| Title: | Non-Additive Measure and Integral Manipulation Functions |
|---|---|
| Description: | S4 tool box for capacity (or non-additive measure, fuzzy measure) and integral manipulation in a finite setting. It contains routines for handling various types of set functions such as games or capacities. It can be used to compute several non-additive integrals: the Choquet integral, the Sugeno integral, and the symmetric and asymmetric Choquet integrals. An analysis of capacities in terms of decision behavior can be performed through the computation of various indices such as the Shapley value, the interaction index, the orness degree, etc. The well-known Möbius transform, as well as other equivalent representations of set functions can also be computed. Kappalab further contains seven capacity identification routines: three least squares based approaches, a method based on linear programming, a maximum entropy like method based on variance minimization, a minimum distance approach and an unsupervised approach based on parametric entropies. The functions contained in Kappalab can for instance be used in the framework of multicriteria decision making or cooperative game theory. |
| Authors: | Michel Grabisch, Ivan Kojadinovic, Patrick Meyer. |
| Maintainer: | Ivan Kojadinovic <[email protected]> |
| License: | CeCILL |
| Version: | 0.4-12 |
| Built: | 2024-12-02 06:53:16 UTC |
| Source: | CRAN |
Creates if possible a new object of the desired class from the old object.
Returns an object of class capacity.
Returns an object of class capacity.
Creates if possible a new object of the desired class from the old object.
Returns an object of class card.capacity.
Returns an object of class card.capacity.
Creates if possible a new object of the desired class from the old object.
Returns an object of class card.game.
Returns an object of class card.game.
Creates if possible a new object of the desired class from the old object.
Returns an object of class
card.set.func.
Returns an object of class
card.set.func.
Returns an object of class
card.set.func.
Creates if possible a new object of the desired class from the old object.
Returns an object of class game.
Returns an object of class game.
Creates if possible a new object of the desired class from the old object.
Returns an object of class Mobius.capacity.
Creates if possible a new object of the desired class from the old object.
Returns an object of class
Mobius.card.set.func.
Returns an object of class
Mobius.card.set.func.
Returns an object of class
Mobius.card.set.func.
Creates if possible a new object of the desired class from the old object.
Returns an object of class Mobius.game.
Creates if possible a new object of the desired class from the old object.
Returns an object of class
Mobius.set.func.
Returns an object of class
Mobius.set.func.
Returns an object of class
Mobius.set.func.
Creates if possible a new object of the desired class from the old object.
Returns an object of class
set.func.
Returns an object of class
set.func.
Returns an object of class set.func.
Class representing a capacity, i.e. a monotone set function vanishing at the empty set (also called fuzzy measure, non-additive measure, monotone measure).
Objects can be mainly created by calls
to the functions capacity and entropy.capa.ident.
n:Object of class numeric of length 1 equal to the
number of elements of the set on which the capacity is defined.
subsets:Object of class numeric of length
2^n containing the power set of the underlying set in
"natural" order. The subsets are coded as integers.
data:Object of class numeric of length
2^n containing the coefficients of the capacity in binary
order. We necessarily have data[1] = 0 plus some additional monotonicity
constraints.
Class game, directly.
Class superclass.capacity, directly.
Class set.func, by class game.
Class superclass.set.func, by class game.
signature(object = "capacity")
signature(object = "capacity")
signature(object = "capacity")
signature(object = "capacity")
signature(object = "capacity")
signature(object = "capacity")
signature(object = "capacity")
signature(object = "capacity")
signature(object = "capacity")
signature(object = "capacity")
capacity,
entropy.capa.ident,
as.card.capacity-methods,
conjugate-methods,
entropy-methods,
favor-methods,
is.normalized-methods,
normalize-methods,
Mobius-methods,
orness-methods,
variance-methods,
veto-methods.
## a capacity mu <- capacity(c(0:13,13,13)/13) ## the attributes of the object mu@n mu@data mu@subsets ## a test is.normalized(mu) normalize(mu) ## a conversion that should not work ## as.card.capacity(mu) ## some transformations conjugate(mu) Mobius(mu) ## let us check ... zeta(Mobius(mu)) ## some summary indices orness(mu) veto(mu) favor(mu) variance(mu) entropy(mu) ## the same summary(mu)## a capacity mu <- capacity(c(0:13,13,13)/13) ## the attributes of the object mu@n mu@data mu@subsets ## a test is.normalized(mu) normalize(mu) ## a conversion that should not work ## as.card.capacity(mu) ## some transformations conjugate(mu) Mobius(mu) ## let us check ... zeta(Mobius(mu)) ## some summary indices orness(mu) veto(mu) favor(mu) variance(mu) entropy(mu) ## the same summary(mu)
Class representing a cardinal capacity, i.e. a capacity whose values depend only on the cardinality of subsets (also called symmetric capacity).
Objects can be created by calls to the functions card.capacity, lower.capacity, upper.capacity, uniform.capacity.
n:Object of class numeric of length 1 equal
to the number of elements of the set on which the cardinal game is defined.
data:Object of class numeric of length
n+1 containing the coefficients of the cardinal capacity. We necessarily have
data[1]=0 and data[i+1]-data[i]>0.
Class card.game, directly.
Class superclass.capacity, directly.
Class card.set.func, by class card.game.
Class superclass.set.func, by class card.game.
signature(object = "card.capacity")
signature(object = "card.capacity")
signature(object = "card.capacity")
signature(object = "card.capacity")
signature(object = "card.capacity")
signature(object = "card.capacity")
signature(object = "card.capacity")
signature(object = "card.capacity")
signature(object = "card.capacity")
capacity-class, card.capacity,
as.capacity-methods, conjugate-methods,
entropy-methods, favor-methods,
is.normalized-methods, orness-methods,
variance-methods, veto-methods.
## a capacity mu <- card.capacity(0:6/6) ## the same mu <- uniform.capacity(6) # the attributes of the object mu@n mu@data ## a test is.normalized(mu) normalize(mu) ## a transformation conjugate(mu) ## some summary indices orness(mu) veto(mu) favor(mu) variance(mu) entropy(mu) ## the same summary(mu)## a capacity mu <- card.capacity(0:6/6) ## the same mu <- uniform.capacity(6) # the attributes of the object mu@n mu@data ## a test is.normalized(mu) normalize(mu) ## a transformation conjugate(mu) ## some summary indices orness(mu) veto(mu) favor(mu) variance(mu) entropy(mu) ## the same summary(mu)
Class representing a cardinal game, i.e. a game whose values depend only on the cardinality of subsets.
Objects can be created by calls to the function card.game.
n:Object of class numeric of length 1 equal
to the number of elements of the set on which the cardinal game is defined.
data:Object of class numeric of length
n+1 containing the coefficients of the cardinal game. We necessarily have
data[1]=0.
Class card.set.func, directly.
Class superclass.set.func, by class card.set.func.
signature(object = "card.game")
signature(object = "card.game", f = "numeric")
signature(object = "card.game", f = "numeric")
signature(object = "card.game", f = "numeric")
game-class, card.game,
as.game-methods, Choquet.integral-methods,
Sipos.integral-methods, Sugeno.integral-methods,
## a cardinal game (which is a capacity) mu <- card.game(c(0,rep(1,4))) # the attributes of the object mu@n mu@data ## a conversion as.game(mu) ## integral calculations f <- c(0.2,0.3,0.1,0.7) Choquet.integral(mu,f) Sugeno.integral(mu,f) f <- c(0.2,-0.3,0.1,-0.7) Sipos.integral(mu,f)## a cardinal game (which is a capacity) mu <- card.game(c(0,rep(1,4))) # the attributes of the object mu@n mu@data ## a conversion as.game(mu) ## integral calculations f <- c(0.2,0.3,0.1,0.7) Choquet.integral(mu,f) Sugeno.integral(mu,f) f <- c(0.2,-0.3,0.1,-0.7) Sipos.integral(mu,f)
These functions create objects of class
card.set.func, card.game, or card.capacity
from an object of class numeric.
card.set.func(object) card.game(object) card.capacity(object) lower.capacity(n) upper.capacity(n) uniform.capacity(n)card.set.func(object) card.game(object) card.capacity(object) lower.capacity(n) upper.capacity(n) uniform.capacity(n)
object |
An object of class |
n |
An object of class |
Return objects of class card.set.func, card.game, or card.capacity.
card.capacity-class,
card.game-class,
card.set.func-class.
card.set.func(4:-2) card.game(c(0,-2:2)) card.capacity(0:5) lower.capacity(3) upper.capacity(4) uniform.capacity(5)card.set.func(4:-2) card.game(c(0,-2:2)) card.capacity(0:5) lower.capacity(3) upper.capacity(4) uniform.capacity(5)
Class representing a cardinal set function, i.e. whose values depend only on the cardinality of subsets.
Objects can be created by calls to the function card.set.func.
n:Object of class numeric of length 1 equal
to the number of elements of the set on which the cardinal set
function is defined.
data:Object of class numeric of length
n+1 containing the coefficients of the cardinal set function.
Class superclass.set.func, directly.
signature(object = "card.set.func")
signature(object = "card.set.func")
signature(object = "card.set.func")
signature(object =
"card.set.func")
signature(object = "card.set.func")
signature(object = "card.set.func")
signature(object =
"card.set.func")
signature(object = "card.set.func")
signature(object = "card.set.func", k =
"numeric")
signature(object = "card.set.func")
signature(object = "card.set.func")
signature(object = "card.set.func")
signature(object = "card.set.func")
set.func-class,
card.set.func,
as.card.game-methods,
as.card.capacity-methods,
as.set.func-methods,
as.Mobius.set.func-methods,
as.Mobius.card.set.func-methods,
conjugate-methods,
interaction.indices-methods,
is.cardinal-methods,
is.kadditive-methods,
is.monotone-methods,
Mobius-methods,
Shapley.value-methods,
to.data.frame-methods.
## a cardinal set function mu <- card.set.func(-3:2) # the attributes of the object mu@n mu@data ## some conversions that cannot work ## Not run: as.card.game(mu) ## Not run: as.card.capacityfunc(mu) ## the following should work as.set.func(mu) ## some tests is.cardinal(mu) is.kadditive(mu,2) is.monotone(mu) ## some transformations conjugate(mu) Mobius(mu) ## let us check ... zeta(Mobius(mu)) ## summary Shapley.value(mu) interaction.indices(mu) # the same summary(mu) ## save the set function to a file d <- to.data.frame(mu) ## Not run: write.table(d,"my.card.set.func.csv",sep="\t") # finally, some other conversions that should work mu <- card.set.func(0:5) as.card.game(mu) as.card.capacity(mu)## a cardinal set function mu <- card.set.func(-3:2) # the attributes of the object mu@n mu@data ## some conversions that cannot work ## Not run: as.card.game(mu) ## Not run: as.card.capacityfunc(mu) ## the following should work as.set.func(mu) ## some tests is.cardinal(mu) is.kadditive(mu,2) is.monotone(mu) ## some transformations conjugate(mu) Mobius(mu) ## let us check ... zeta(Mobius(mu)) ## summary Shapley.value(mu) interaction.indices(mu) # the same summary(mu) ## save the set function to a file d <- to.data.frame(mu) ## Not run: write.table(d,"my.card.set.func.csv",sep="\t") # finally, some other conversions that should work mu <- card.set.func(0:5) as.card.game(mu) as.card.capacity(mu)
Computes the Choquet integral of a discrete function with
respect to a game. The game can be given either under the form of an
object of class game, card.game or
Mobius.game. If the integrand is not positive, this function
computes what is known as the asymmetric Choquet integral.
The Choquet integral of
f is computed from the Möbius transform of a game.
The Choquet integral of
f is computed from a game.
The Choquet integral of
f is computed from a cardinal game.
G. Choquet (1953), Theory of capacities, Annales de l'Institut Fourier 5, pages 131-295.
D. Denneberg (2000), Non-additive measure and integral, basic concepts and their role for applications, in: M. Grabisch, T. Murofushi, and M. Sugeno Eds, Fuzzy Measures and Integrals: Theory and Applications, Physica-Verlag, pages 42-69.
M. Grabisch, T. Murofushi, M. Sugeno Eds (2000), Fuzzy Measures and Integrals: Theory and Applications, Physica-Verlag.
M. Grabisch and Ch. Labreuche (2002), The symmetric and asymmetric Choquet integrals on finite spaces for decision making, Statistical Papers 43, pages 37-52.
M. Grabisch (2000), A graphical interpretation of the Choquet integral, IEEE Transactions on Fuzzy Systems 8, pages 627-631.
J.-L. Marichal (2000), An axiomatic approach of the discrete Choquet integral as a tool to aggregate interacting criteria, IEEE Transactions on Fuzzy Systems 8:6, pages 800-807.
Murofushi and M. Sugeno (1993), Some quantities represented by the Choquet integral, Fuzzy Sets and Systems 56, pages 229-235.
Murofushi and M. Sugeno (2000), Fuzzy measures and fuzzy integrals, in: M. Grabisch, T. Murofushi, and M. Sugeno Eds, Fuzzy Measures and Integrals: Theory and Applications, Physica-Verlag, pages 3-41.
game-class, Mobius.game-class,
card.game-class.
## a normalized capacity mu <- capacity(c(0:13/13,1,1)) ## and its Mobius transform a <- Mobius(mu) ## a discrete positive function f f <- c(0.1,0.9,0.3,0.8) ## the Choquet integral of f w.r.t mu Choquet.integral(mu,f) Choquet.integral(a,f) ## a similar example with a cardinal capacity mu <- uniform.capacity(4) Choquet.integral(mu,f)## a normalized capacity mu <- capacity(c(0:13/13,1,1)) ## and its Mobius transform a <- Mobius(mu) ## a discrete positive function f f <- c(0.1,0.9,0.3,0.8) ## the Choquet integral of f w.r.t mu Choquet.integral(mu,f) Choquet.integral(a,f) ## a similar example with a cardinal capacity mu <- uniform.capacity(4) Choquet.integral(mu,f)
Computes the conjugate (also called the dual) of a set function. The conjugate of the conjugate of a game gives the original game back.
Returns an object of class capacity.
Returns an object of class card.capacity.
Returns an object of class card.game.
Returns an object of class game.
T. Murofushi and M. Sugeno (2000), Fuzzy measures and fuzzy integrals, in: M. Grabisch, T. Murofushi, and M. Sugeno Eds, Fuzzy Measures and Integrals: Theory and Applications, Physica-Verlag, pages 3-41.
capacity-class,
card.capacity-class,
set.func-class,
card.set.func-class.
## a game mu <- game(c(0,-7:7)) mu ## its conjugate conjugate(mu) ## and mu again conjugate(conjugate(mu)) ## a similar example with the upper capacity mu <- capacity(c(0,rep(1,15))) mu conjugate(mu) conjugate(conjugate(mu)) ## a similar example with an object of class card.capacity mu <- upper.capacity(6) mu conjugate(mu) conjugate(conjugate(mu)) ## the conjugate of a set function is a game mu <- set.func(-7:8) mu conjugate(mu) mu <- card.set.func(-2:5) conjugate(mu)## a game mu <- game(c(0,-7:7)) mu ## its conjugate conjugate(mu) ## and mu again conjugate(conjugate(mu)) ## a similar example with the upper capacity mu <- capacity(c(0,rep(1,15))) mu conjugate(mu) conjugate(conjugate(mu)) ## a similar example with an object of class card.capacity mu <- upper.capacity(6) mu conjugate(mu) conjugate(conjugate(mu)) ## the conjugate of a set function is a game mu <- set.func(-7:8) mu conjugate(mu) mu <- card.set.func(-2:5) conjugate(mu)
Computes the normalized entropy of a capacity. The capacity
can be given either under the form of an object of class
capacity, card.capacity or Mobius.capacity.
The normalized entropy is computed from the Möbius transform of a capacity.
The normalized entropy is computed directly from a capacity.
The normalized entropy is computed from a cardinal capacity.
J-L. Marichal (2002), Entropy of discrete Choquet capacities, European Journal of Operational Research, 3:137, 2002, pages 612-624.
I. Kojadinovic, J-L. Marichal and M. Roubens (2005), An axiomatic approach to the definition of the entropy of a discrete Choquet capacity, Information Sciences 172, pages 131-153.
capacity-class, Mobius.capacity-class,
card.capacity-class, Mobius-methods.
## a capacity mu <- capacity(c(0,0,0:13)) ## its Mobius transform a <- Mobius(mu) ## their normalized entropy entropy(mu) entropy(a) ## similar examples with card.capacity objects mu <- lower.capacity(4) entropy(mu) mu <- uniform.capacity(4) entropy(mu)## a capacity mu <- capacity(c(0,0,0:13)) ## its Mobius transform a <- Mobius(mu) ## their normalized entropy entropy(mu) entropy(a) ## similar examples with card.capacity objects mu <- lower.capacity(4) entropy(mu) mu <- uniform.capacity(4) entropy(mu)
This function estimates a capacity using as argument a set of data under the form: datum=(score on attribute 1, ..., score on attribute n). The approach roughly consists in replacing the subjective notion of importance of a subset of attributes by that of information content of a subset of attributes, which is estimated from the data by means of a parametric entropy measure. For more details, see the references hereafter.
entropy.capa.ident(d, entropy = "renyi", parameter = 1)entropy.capa.ident(d, entropy = "renyi", parameter = 1)
d |
An object of class |
entropy |
An object of class |
parameter |
An object of class |
Returns an object of class capacity.
I. Kojadinovic (2004), Estimation of the weights of interacting criteria from the set of profiles by means of information-theoretic functionals, European Journal of Operational Research 155:3, pages 741-751.
I. Kojadinovic (2005), Unusupervised aggregation of commensurate correlated attributes by means of the Choquet integral and entropy functionals, International Journal of Intelligent Systems, in press.
capacity-class,
lin.prog.capa.ident,
mini.var.capa.ident,
mini.dist.capa.ident,
least.squares.capa.ident,
heuristic.ls.capa.ident,
ls.sorting.capa.ident,
ls.ranking.capa.ident.
## a set of randomly generated data ## for instance, marks on a [0,20] scale p <- data.frame(matrix(runif(500,0,20),100,5)) names(p) <- c("Stat","Prob","Alg","Cal","Eng") ## discretization p[p <= 5] <- 1 p[p > 5 & p <= 10] <- 2 p[p > 10 & p <= 15] <- 3 p[p > 15] <- 4 d <- data.frame(factor(p[[1]]), factor(p[[2]]), factor(p[[3]]), factor(p[[4]]), factor(p[[5]])) ## associated unsupervised capacity mu <- entropy.capa.ident(d) mu## a set of randomly generated data ## for instance, marks on a [0,20] scale p <- data.frame(matrix(runif(500,0,20),100,5)) names(p) <- c("Stat","Prob","Alg","Cal","Eng") ## discretization p[p <= 5] <- 1 p[p > 5 & p <= 10] <- 2 p[p > 10 & p <= 15] <- 3 p[p > 15] <- 4 d <- data.frame(factor(p[[1]]), factor(p[[2]]), factor(p[[3]]), factor(p[[4]]), factor(p[[5]])) ## associated unsupervised capacity mu <- entropy.capa.ident(d) mu
Methods for computing the expectation and standard deviation of the Choquet integral in the standard uniform and standard normal cases.
Returns the expectation or the standard deviation of the Choquet integral.
J-L. Marichal and I. Kojadinovic (2007), The distribution of linear combinations of lattice polynomials from the uniform distribution, submitted.
game-class, Mobius.game-class.
## a capacity mu <- capacity(c(0,0.1,0.6,rep(0.9,4),1)) ## the expectation and the standard deviation ## of the Choquet integral in the uniform case expect.Choquet.unif(mu) sd.Choquet.unif(mu) ## the same but empirically m <- 10000 ch <- numeric(m) for (i in 1:m) { f <- runif(3) ch[i] <- Choquet.integral(mu,f) } mean(ch) sd(ch) ## the expectation and the standard deviation ## of the Choquet integral in the normal case expect.Choquet.norm(mu) sd.Choquet.norm(mu) expect.Choquet.norm(Mobius(mu)) ## the same but empirically for (i in 1:m) { f <- rnorm(3) ch[i] <- Choquet.integral(mu,f) } mean(ch) sd(ch)## a capacity mu <- capacity(c(0,0.1,0.6,rep(0.9,4),1)) ## the expectation and the standard deviation ## of the Choquet integral in the uniform case expect.Choquet.unif(mu) sd.Choquet.unif(mu) ## the same but empirically m <- 10000 ch <- numeric(m) for (i in 1:m) { f <- runif(3) ch[i] <- Choquet.integral(mu,f) } mean(ch) sd(ch) ## the expectation and the standard deviation ## of the Choquet integral in the normal case expect.Choquet.norm(mu) sd.Choquet.norm(mu) expect.Choquet.norm(Mobius(mu)) ## the same but empirically for (i in 1:m) { f <- rnorm(3) ch[i] <- Choquet.integral(mu,f) } mean(ch) sd(ch)
Computes the favor indices of a Choquet integral from the
underlying normalized capacity. The capacity can be given either under the form
of an object of class capacity, card.capacity or
Mobius.capacity.
The favor indices are computed from the Möbius transform of a capacity.
The favor indices are computed directly from a capacity.
The favor indices are computed from a cardinal capacity.
J.-L. Marichal (2000), Behavioral analysis of aggregation in multicriteria decision aid, in: Preferences and Decisions under Incomplete Knowledge, J. Fodor and B. De Baets and P. Perny Eds, Physica-Verlag, pages 153-178.
J.-L. Marichal (2004), Tolerant or intolerant character of interacting criteria in aggregation by the Choquet integral, European Journal of Operational Research 155:3, pages 771-791.
capacity-class, Mobius.capacity-class,
card.capacity-class, Mobius-methods.
## a capacity mu <- capacity(c(0:13,13,13)) ## its Mobius transform a <- Mobius(mu) ## their favor indices favor(mu) favor(a) ## the same with a card.capacity object mu <- lower.capacity(4) favor(mu)## a capacity mu <- capacity(c(0:13,13,13)) ## its Mobius transform a <- Mobius(mu) ## their favor indices favor(mu) favor(a) ## the same with a card.capacity object mu <- lower.capacity(4) favor(mu)
Class representing a game, i.e. a set function vanishing at the empty set (also called non monotonic fuzzy measure).
Objects can be created by calls to the function game.
n:Object of class numeric of length 1 equal to the
number of elements of the set on which the game is defined.
subsets:Object of class numeric of length
2^n containing the power set of the underlying set in
"natural" order. The subsets are coded as integers.
data:Object of class numeric of length
2^n containing the coefficients of the game in binary
order. We necessarily have data[1] = 0.
Class set.func, directly.
Class superclass.set.func, by class set.func.
signature(object = "game")
signature(object = "game", f = "numeric")
signature(object = "game")
signature(object = "game", f = "numeric")
signature(object = "game", f =
"numeric")
signature(object = "game", f = "numeric")
signature(object = "game", f = "numeric")
signature(object = "game")
signature(object = "game")
signature(object = "game")
signature(object = "game")
game,
as.card.game-methods,
Choquet.integral-methods,
Mobius-methods,
Sipos.integral-methods,
Sugeno.integral-methods,
pdf.Choquet.unif-methods,
cdf.Choquet.unif-methods,
expect.Choquet.unif-methods,
sd.Choquet.unif-methods,
expect.Choquet.norm-methods,
sd.Choquet.norm-methods.
## a game (which is a capacity) mu <- game(c(0,rep(1,15))) ## the attributes of the object mu@n mu@data mu@subsets ## a conversion as.card.game(mu) ## a transformation Mobius(mu) ## let us check ... zeta(Mobius(mu)) ## integral calculations f <- c(0.2,0.3,0.1,0.7) Choquet.integral(mu,f) Sugeno.integral(mu,f) f <- c(0.2,-0.3,0.1,-0.7) Sipos.integral(mu,f)## a game (which is a capacity) mu <- game(c(0,rep(1,15))) ## the attributes of the object mu@n mu@data mu@subsets ## a conversion as.card.game(mu) ## a transformation Mobius(mu) ## let us check ... zeta(Mobius(mu)) ## integral calculations f <- c(0.2,0.3,0.1,0.7) Choquet.integral(mu,f) Sugeno.integral(mu,f) f <- c(0.2,-0.3,0.1,-0.7) Sipos.integral(mu,f)
Creates an object of class capacity or game
by means of the heuristic algorithm proposed by Grabisch (1995). More
precisely, given a set of data under the form:
datum=(score on criterion 1, ..., score on criterion
n, overall score), this function heuristically determines a capacity
that should be close to minimizing the sum of squared errors between overall scores
as given by the data and the output of the Choquet integral for those
data. See reference hereafter for more details.
heuristic.ls.capa.ident(n, mu, C, g, Integral="Choquet", maxiter = 500, alpha = 0.01, epsilon = 1e-6)heuristic.ls.capa.ident(n, mu, C, g, Integral="Choquet", maxiter = 500, alpha = 0.01, epsilon = 1e-6)
n |
Object of class |
mu |
Object of class |
C |
Object of class |
g |
Object of class |
Integral |
Object of class |
maxiter |
Maximum number of iterations. |
alpha |
Object of class |
epsilon |
Object of class |
The algorithm is explained in details in the reference hereafter.
The function returns a list structured as follows:
solution |
Object of class |
n.iter |
Number of iterations taken by the algorithm. |
residuals |
Differences between the provided global evaluations and those returned by the obtained model. |
mse |
Mean square error between the provided global evaluations and those returned by the obtained model. |
M. Grabisch (1995), A new algorithm for identifying fuzzy measures and its application to pattern recognition, Int. Joint Conf. of the 4th IEEE Int. Conf. on Fuzzy Systems and the 2nd Int. Fuzzy Engineering Symposium, Yokohama, Japan, 145-150.
capacity-class,
least.squares.capa.ident,
lin.prog.capa.ident,
mini.var.capa.ident,
mini.dist.capa.ident,
ls.sorting.capa.ident,
ls.ranking.capa.ident,
entropy.capa.ident.
## number of criteria n <- 4 ## the number of alternatives n.a <- 1000 ## a randomly generated 5-criteria matrix C <- matrix(rnorm(n*n.a,10,2),n.a,n) ## the corresponding global scores g <- numeric(n.a) ## generate a random capacity x <- runif(2^n-1) for (i in 2:(2^n-1)) x[i] <- x[i] + x[i-1] mu <- normalize(capacity(c(0,x))) for (i in 1:n.a) g[i] <- Choquet.integral(mu,C[i,]) ## the initial capacity ## here the uniform capacity mu.in <- as.capacity(uniform.capacity(n)) ## the solution hlsc <- heuristic.ls.capa.ident(n,mu.in,C,g) mu.sol <- hlsc$solution ## the difference between mu and mu.sol mu@data - mu.sol@data hlsc## number of criteria n <- 4 ## the number of alternatives n.a <- 1000 ## a randomly generated 5-criteria matrix C <- matrix(rnorm(n*n.a,10,2),n.a,n) ## the corresponding global scores g <- numeric(n.a) ## generate a random capacity x <- runif(2^n-1) for (i in 2:(2^n-1)) x[i] <- x[i] + x[i-1] mu <- normalize(capacity(c(0,x))) for (i in 1:n.a) g[i] <- Choquet.integral(mu,C[i,]) ## the initial capacity ## here the uniform capacity mu.in <- as.capacity(uniform.capacity(n)) ## the solution hlsc <- heuristic.ls.capa.ident(n,mu.in,C,g) mu.sol <- hlsc$solution ## the difference between mu and mu.sol mu@data - mu.sol@data hlsc
Computes the Shapley interaction index for pairs of elements with
respect to a set function. The set function can be given either under
the form of an object of class set.func, card.set.func
or Mobius.set.func
.
The Shapley interaction indices are computed from the Möbius transform of a set function.
The Shapley interaction indices are computed from a cardinal set function.
The Shapley interaction indices are computed from a general set function.
G. Owen (1971/72), Multilinear extensions of games, Management Sci. 18, pages 64–79.
T. Murofushi and S. Soneda (1993), Techniques for reading fuzzy measures (III): interaction index, 9th Fuzzy System Symposium, pages 693–696, Saporo, Japan.
M. Grabisch, J-L. Marichal and M. Roubens (2000), Equivalent representations of set functions, Mathematics of Operations Research 25(2), pages 157–178.
Mobius.set.func-class,
card.set.func-class,
set.func-class,
Mobius-methods.
## a set function mu <- set.func(c(-7:6,6,6)) ## the associated interaction indices interaction.indices(mu) ## a similar example using a Mobius.set.func object a <- Mobius(mu) interaction.indices(a) ## a similar example using a card.set.func object mu <- upper.capacity(6) interaction.indices(mu)## a set function mu <- set.func(c(-7:6,6,6)) ## the associated interaction indices interaction.indices(mu) ## a similar example using a Mobius.set.func object a <- Mobius(mu) interaction.indices(a) ## a similar example using a card.set.func object mu <- upper.capacity(6) interaction.indices(mu)
Tests whether a set function is cardinal, i.e., if its values
depend only on the cardinality of subsets. The set function
can be given either under the form of an object of class
set.func, card.set.func or Mobius.set.func.
Returns an object of class logical.
Returns an object of class logical.
Returns an object of class logical.
is.cardinal(set.func(-7:8)) is.cardinal(uniform.capacity(8)) is.cardinal(Mobius.game(0:10,4,2))is.cardinal(set.func(-7:8)) is.cardinal(uniform.capacity(8)) is.cardinal(Mobius.game(0:10,4,2))
Tests whether a set function is k-additive, i.e., if its
Möbius function vanishes for subsets of more than k elements. The set
function can be given either under the form of an object of class
set.func, card.set.func or
Mobius.set.func.
In order to test whether a coefficient is equal to zero, its
absolute value is compared with epsilon whose default
value is 1e-9.
Returns an object of class logical.
Returns an object of class logical.
Returns an object of class logical.
M. Grabisch (1997), k-order additive discrete fuzzy measures and their representation, Fuzzy Sets and Systems 92(2), pages 167–189.
M. Grabisch (2000), The interaction and Möbius representations of fuzzy measures on finites spaces, k-additive measures: a survey, in: Fuzzy Measures and Integrals: Theory and Applications, M. Grabisch, T. Murofushi, and M. Sugeno Eds, Physica Verlag, pages 70-93.
Mobius.set.func-class,
card.set.func-class,
set.func-class,
Mobius-methods, k.truncate.Mobius-methods.
## a set function mu <- set.func(c(0,1,1,1,2,2,2,3)) mu is.kadditive(mu,2) is.kadditive(mu,1) ## the Mobius representation of a set function, 2-additive by construction a <- Mobius.set.func(c(0,1,2,1,3,1,2,1,2,3,1),4,2) is.kadditive(a,2) is.kadditive(a,1)## a set function mu <- set.func(c(0,1,1,1,2,2,2,3)) mu is.kadditive(mu,2) is.kadditive(mu,1) ## the Mobius representation of a set function, 2-additive by construction a <- Mobius.set.func(c(0,1,2,1,3,1,2,1,2,3,1),4,2) is.kadditive(a,2) is.kadditive(a,1)
Tests whether a set function is monotone with respect to set
inclusion. The set function
can be given either under the form of an object of class
set.func, card.set.func or Mobius.set.func.
For objects of class set.func or card.set.func, the
monotonicity constraints are considered to be satisfied
(cf. references hereafter) if the following inequalities are satisfied
for all and all .
For objects of class Mobius.set.func, it is
required that a similar condition with respect to the Möbius
representation be satisfied (cf. references hereafter).
Returns an object of class logical. If verbose=TRUE,
displays the violated monotonicity constraints, if any.
Returns an object of class logical. If
verbose=TRUE, displays the violated monotonicity
constraints, if any.
Returns an object of class logical. If verbose=TRUE,
displays the violated monotonicity constraints, if any.
A. Chateauneuf and J-Y. Jaffray (1989), Some characterizations of lower probabilities and other monotone capacities through the use of Möbius inversion, Mathematical Social Sciences 17:3, pages 263–283.
M. Grabisch (2000), The interaction and Möbius representations of fuzzy measures on finites spaces, k-additive measures: a survey, in: Fuzzy Measures and Integrals: Theory and Applications, M. Grabisch, T. Murofushi, and M. Sugeno Eds, Physica Verlag, pages 70-93.
Mobius.set.func-class,
card.set.func-class,
set.func-class.
## a monotone set function mu <- set.func(c(0,1,1,1,2,2,2,3)) mu is.monotone(mu) ## the Mobius representation of a monotone set function a <- Mobius.set.func(c(0,1,2,1,3,1,2,1,2,3,1),4,2) is.monotone(a) ## non-monotone examples mu <- set.func(c(0,-7:7)) is.monotone(mu,verbose=TRUE) a <- Mobius(mu) is.monotone(a,verbose=TRUE)## a monotone set function mu <- set.func(c(0,1,1,1,2,2,2,3)) mu is.monotone(mu) ## the Mobius representation of a monotone set function a <- Mobius.set.func(c(0,1,2,1,3,1,2,1,2,3,1),4,2) is.monotone(a) ## non-monotone examples mu <- set.func(c(0,-7:7)) is.monotone(mu,verbose=TRUE) a <- Mobius(mu) is.monotone(a,verbose=TRUE)
Tests whether a capacity is normalized, i.e., if its value on the
universal set is 1. The capacity can be
given either under the form of an object of class capacity,
card.capacity or Mobius.capacity.
Returns a logical.
Returns a logical.
Returns a logical.
capacity-class,
Mobius.capacity-class,
card.capacity-class.
## a capacity mu <- capacity(0:15) is.normalized(mu) normalize(mu) ## its Mobius transform a <- Mobius(mu) is.normalized(a) normalize(a) ## a cardinal capacity mu <- uniform.capacity(7) is.normalized(mu)## a capacity mu <- capacity(0:15) is.normalized(mu) normalize(mu) ## its Mobius transform a <- Mobius(mu) is.normalized(a) normalize(a) ## a cardinal capacity mu <- uniform.capacity(7) is.normalized(mu)
Truncates the Möbius representation of a set function by
considering that the values of subsets whose cardinal is superior to k
are zero. The result is at most k-additive.
Returns an object of class Mobius.set.func. The Möbius representation of the set function is first computed and then k-truncated.
Returns an object of class Mobius.set.func.
M. Grabisch (1997), k-order additive discrete fuzzy measures and their representation, Fuzzy Sets and Systems 92(2), pages 167-189.
M. Grabisch (2000), The interaction and Möbius representations of fuzzy measures on finites spaces, k-additive measures: a survey, in: Fuzzy Measures and Integrals: Theory and Applications, M. Grabisch, T. Murofushi, and M. Sugeno Eds, Physica Verlag, pages 70-93.
Mobius.set.func-class,
set.func-class,
Mobius-methods.
## a set function mu <- set.func(c(0,1,1,1,2,2,2,3)) mu ## 2-truncate it k.truncate.Mobius(mu,2) ## 2-truncate it k.truncate.Mobius(Mobius(mu),2)## a set function mu <- set.func(c(0,1,1,1,2,2,2,3)) mu ## 2-truncate it k.truncate.Mobius(mu,2) ## 2-truncate it k.truncate.Mobius(Mobius(mu),2)
Creates an object of class Mobius.capacity by means of an
approach grounded on least squares optimization. More precisely, given a set
of data under the form: datum=(score on criterion 1, ..., score on criterion
n, overall score), and possibly additional linear constraints expressing
preferences, importance of criteria, etc., this function determines, if it
exists, a capacity minimizing the sum of squared errors between overall scores
as given by the data and the output of the Choquet integral for those data,
and compatible with the additional linear constraints. The existence is
ensured if no additional constraint is given. The problem is solved using
quadratic programming.
least.squares.capa.ident(n, k, C, g, Integral="Choquet", A.Shapley.preorder = NULL, A.Shapley.interval = NULL, A.interaction.preorder = NULL, A.interaction.interval = NULL, A.inter.additive.partition = NULL, sigf = 7, maxiter = 40, epsilon = 1e-6)least.squares.capa.ident(n, k, C, g, Integral="Choquet", A.Shapley.preorder = NULL, A.Shapley.interval = NULL, A.interaction.preorder = NULL, A.interaction.interval = NULL, A.inter.additive.partition = NULL, sigf = 7, maxiter = 40, epsilon = 1e-6)
n |
Object of class |
k |
Object of class |
C |
Object of class |
g |
Object of class |
Integral |
Object of class |
A.Shapley.preorder |
Object of class |
A.Shapley.interval |
Object of class |
A.interaction.preorder |
Object of class |
A.interaction.interval |
Object of class |
A.inter.additive.partition |
Object of class |
sigf |
Precision (default: 7 significant figures). Parameter to
be passed to the |
maxiter |
Maximum number of iterations. Parameter to
be passed to the |
epsilon |
Object of class |
The quadratic program is solved using the ipop function of
the kernlab package.
The function returns a list structured as follows:
solution |
Object of class
|
dual |
The dual solution of the problem. |
how |
Character string describing the type of convergence. |
residuals |
Differences between the provided global evaluations and those returned by the obtained model. |
K. Fujimoto and T. Murofushi (2000) Hierarchical decomposition of the Choquet integral, in: Fuzzy Measures and Integrals: Theory and Applications, M. Grabisch, T. Murofushi, and M. Sugeno Eds, Physica Verlag, pages 95-103.
M. Grabisch, H.T. Nguyen and E.A. Walker (1995), Fundamentals of uncertainty calculi with applications to fuzzy inference, Kluwer Academic, Dordrecht.
M. Grabisch and M. Roubens (2000), Application of the Choquet Integral in Multicriteria Decision Making, in: Fuzzy Measures and Integrals: Theory and Applications, M. Grabisch, T. Murofushi, and M. Sugeno Eds, Physica Verlag, pages 415-434.
P. Miranda and M. Grabisch (1999), Optimization issues for fuzzy measures, International Journal of Fuzziness and Knowledge-based Systems 7:6, pages 545-560.
Mobius.capacity-class,
heuristic.ls.capa.ident,
lin.prog.capa.ident,
mini.var.capa.ident,
mini.dist.capa.ident,
ls.sorting.capa.ident,
entropy.capa.ident.
## the number of data n.d <- 20 ## a randomly generated 5-criteria matrix C <- matrix(rnorm(5*n.d,10,2),n.d,5) ## the corresponding global scores g <- numeric(n.d) mu <- capacity(c(0:29,29,29)/29) for (i in 1:n.d) g[i] <- Choquet.integral(mu,C[i,]) ## Not run: ## the full solution lsc <- least.squares.capa.ident(5,5,C,g) a <- lsc$solution a mu.sol <- zeta(a) ## the difference between mu and mu.sol mu@data - mu.sol@data ## the residuals lsc$residuals ## the mean square error mean(lsc$residuals^2) ## a 3-additive solution lsc <- least.squares.capa.ident(5,3,C,g) a <- lsc$solution mu.sol <- zeta(a) mu@data - mu.sol@data lsc$residuals ## End(Not run) ## a similar example based on the Sipos integral ## a randomly generated 5-criteria matrix C <- matrix(rnorm(5*n.d,0,2),n.d,5) ## the corresponding global scores g <- numeric(n.d) mu <- capacity(c(0:29,29,29)/29) for (i in 1:n.d) g[i] <- Sipos.integral(mu,C[i,]) ## Not run: ## the full solution lsc <- least.squares.capa.ident(5,5,C,g,Integral = "Sipos") a <- lsc$solution mu.sol <- zeta(a) mu@data - mu.sol@data lsc$residuals ## a 3-additive solution lsc <- least.squares.capa.ident(5,3,C,g,Integral = "Sipos") a <- lsc$solution mu.sol <- zeta(a) mu@data - mu.sol@data lsc$residuals ## End(Not run) ## additional constraints ## a Shapley preorder constraint matrix ## Sh(1) - Sh(2) >= -delta.S ## Sh(2) - Sh(1) >= -delta.S ## Sh(3) - Sh(4) >= -delta.S ## Sh(4) - Sh(3) >= -delta.S ## i.e. criteria 1,2 and criteria 3,4 ## should have the same global importances delta.S <- 0.01 Asp <- rbind(c(1,2,-delta.S), c(2,1,-delta.S), c(3,4,-delta.S), c(4,3,-delta.S) ) ## a Shapley interval constraint matrix ## 0.3 <= Sh(1) <= 0.9 Asi <- rbind(c(1,0.3,0.9)) ## an interaction preorder constraint matrix ## such that I(12) = I(45) delta.I <- 0.01 Aip <- rbind(c(1,2,4,5,-delta.I), c(4,5,1,2,-delta.I)) ## an interaction interval constraint matrix ## i.e. -0.20 <= I(12) <= -0.15 delta.I <- 0.01 Aii <- rbind(c(1,2,-0.2,-0.15)) ## an inter-additive partition constraint ## criteria 1,2,3 and criteria 4,5 are independent Aiap <- c(1,1,1,2,2) ## a more constrained solution lsc <- least.squares.capa.ident(5,5,C,g,Integral = "Sipos", A.Shapley.preorder = Asp, A.Shapley.interval = Asi, A.interaction.preorder = Aip, A.interaction.interval = Aii, A.inter.additive.partition = Aiap, sigf = 5) a <- lsc$solution mu.sol <- zeta(a) mu@data - mu.sol@data lsc$residuals summary(a)## the number of data n.d <- 20 ## a randomly generated 5-criteria matrix C <- matrix(rnorm(5*n.d,10,2),n.d,5) ## the corresponding global scores g <- numeric(n.d) mu <- capacity(c(0:29,29,29)/29) for (i in 1:n.d) g[i] <- Choquet.integral(mu,C[i,]) ## Not run: ## the full solution lsc <- least.squares.capa.ident(5,5,C,g) a <- lsc$solution a mu.sol <- zeta(a) ## the difference between mu and mu.sol mu@data - mu.sol@data ## the residuals lsc$residuals ## the mean square error mean(lsc$residuals^2) ## a 3-additive solution lsc <- least.squares.capa.ident(5,3,C,g) a <- lsc$solution mu.sol <- zeta(a) mu@data - mu.sol@data lsc$residuals ## End(Not run) ## a similar example based on the Sipos integral ## a randomly generated 5-criteria matrix C <- matrix(rnorm(5*n.d,0,2),n.d,5) ## the corresponding global scores g <- numeric(n.d) mu <- capacity(c(0:29,29,29)/29) for (i in 1:n.d) g[i] <- Sipos.integral(mu,C[i,]) ## Not run: ## the full solution lsc <- least.squares.capa.ident(5,5,C,g,Integral = "Sipos") a <- lsc$solution mu.sol <- zeta(a) mu@data - mu.sol@data lsc$residuals ## a 3-additive solution lsc <- least.squares.capa.ident(5,3,C,g,Integral = "Sipos") a <- lsc$solution mu.sol <- zeta(a) mu@data - mu.sol@data lsc$residuals ## End(Not run) ## additional constraints ## a Shapley preorder constraint matrix ## Sh(1) - Sh(2) >= -delta.S ## Sh(2) - Sh(1) >= -delta.S ## Sh(3) - Sh(4) >= -delta.S ## Sh(4) - Sh(3) >= -delta.S ## i.e. criteria 1,2 and criteria 3,4 ## should have the same global importances delta.S <- 0.01 Asp <- rbind(c(1,2,-delta.S), c(2,1,-delta.S), c(3,4,-delta.S), c(4,3,-delta.S) ) ## a Shapley interval constraint matrix ## 0.3 <= Sh(1) <= 0.9 Asi <- rbind(c(1,0.3,0.9)) ## an interaction preorder constraint matrix ## such that I(12) = I(45) delta.I <- 0.01 Aip <- rbind(c(1,2,4,5,-delta.I), c(4,5,1,2,-delta.I)) ## an interaction interval constraint matrix ## i.e. -0.20 <= I(12) <= -0.15 delta.I <- 0.01 Aii <- rbind(c(1,2,-0.2,-0.15)) ## an inter-additive partition constraint ## criteria 1,2,3 and criteria 4,5 are independent Aiap <- c(1,1,1,2,2) ## a more constrained solution lsc <- least.squares.capa.ident(5,5,C,g,Integral = "Sipos", A.Shapley.preorder = Asp, A.Shapley.interval = Asi, A.interaction.preorder = Aip, A.interaction.interval = Aii, A.inter.additive.partition = Aiap, sigf = 5) a <- lsc$solution mu.sol <- zeta(a) mu@data - mu.sol@data lsc$residuals summary(a)
Creates an object of class Mobius.capacity using the
linear programming approach proposed by Marichal and Roubens (see
reference hereafter). Roughly speaking, this function determines, if it
exists, the capacity compatible with a set of linear constraints that
"separates" the most the provided alternatives. The problem is solved
using the lpSolve package.
lin.prog.capa.ident(n, k, A.Choquet.preorder = NULL, A.Shapley.preorder = NULL, A.Shapley.interval = NULL, A.interaction.preorder = NULL, A.interaction.interval = NULL, A.inter.additive.partition = NULL, epsilon = 1e-6)lin.prog.capa.ident(n, k, A.Choquet.preorder = NULL, A.Shapley.preorder = NULL, A.Shapley.interval = NULL, A.interaction.preorder = NULL, A.interaction.interval = NULL, A.inter.additive.partition = NULL, epsilon = 1e-6)
n |
Object of class |
k |
Object of class |
A.Choquet.preorder |
Object of class |
A.Shapley.preorder |
Object of class |
A.Shapley.interval |
Object of class |
A.interaction.preorder |
Object of class |
A.interaction.interval |
Object of class |
A.inter.additive.partition |
Object of class |
epsilon |
Object of class |
The linear program is solved using the lp function of
the lpSolve.
The function returns a list structured as follows:
solution |
Object of class |
value |
Value of the objective function. |
lp.object |
Object of class |
K. Fujimoto and T. Murofushi (2000) Hierarchical decomposition of the Choquet integral, in: Fuzzy Measures and Integrals: Theory and Applications, M. Grabisch, T. Murofushi, and M. Sugeno Eds, Physica Verlag, pages 95-103.
J-L. Marichal and M. Roubens (2000), Determination of weights of interacting criteria from a reference set, European Journal of Operational Research 124, pages 641-650.
Mobius.capacity-class,
mini.var.capa.ident,
mini.dist.capa.ident,
least.squares.capa.ident,
heuristic.ls.capa.ident,
ls.sorting.capa.ident,
entropy.capa.ident.
## some alternatives a <- c(18,11,18,11,11) b <- c(18,18,11,11,11) c <- c(11,11,18,18,11) d <- c(18,11,11,11,18) e <- c(11,11,18,11,18) ## preference threshold relative ## to the preorder of the alternatives delta.C <- 1 ## corresponding Choquet preorder constraint matrix Acp <- rbind(c(d,a,delta.C), c(a,e,delta.C), c(e,b,delta.C), c(b,c,delta.C) ) ## a Shapley preorder constraint matrix ## Sh(1) - Sh(2) >= -delta.S ## Sh(2) - Sh(1) >= -delta.S ## Sh(3) - Sh(4) >= -delta.S ## Sh(4) - Sh(3) >= -delta.S ## i.e. criteria 1,2 and criteria 3,4 ## should have the same global importances delta.S <- 0.01 Asp <- rbind(c(1,2,-delta.S), c(2,1,-delta.S), c(3,4,-delta.S), c(4,3,-delta.S) ) ## a Shapley interval constraint matrix ## 0.3 <= Sh(1) <= 0.9 Asi <- rbind(c(1,0.3,0.9)) ## an interaction preorder constraint matrix ## such that I(12) = I(34) delta.I <- 0.01 Aip <- rbind(c(1,2,3,4,-delta.I), c(3,4,1,2,-delta.I)) ## an interaction interval constraint matrix ## i.e. -0.20 <= I(12) <= -0.15 Aii <- rbind(c(1,2,-0.2,-0.15)) ## Not run: ## a LP 2-additive solution lin.prog <- lin.prog.capa.ident(5,2,A.Choquet.preorder = Acp) m <- lin.prog$solution m ## the resulting global evaluations rbind(c(a,mean(a),Choquet.integral(m,a)), c(b,mean(b),Choquet.integral(m,b)), c(c,mean(c),Choquet.integral(m,c)), c(d,mean(d),Choquet.integral(m,d)), c(e,mean(e),Choquet.integral(m,e))) ## the Shapley value Shapley.value(m) ## a LP 3-additive more constrained solution lin.prog2 <- lin.prog.capa.ident(5,3, A.Choquet.preorder = Acp, A.Shapley.preorder = Asp) m <- lin.prog2$solution m rbind(c(a,mean(a),Choquet.integral(m,a)), c(b,mean(b),Choquet.integral(m,b)), c(c,mean(c),Choquet.integral(m,c)), c(d,mean(d),Choquet.integral(m,d)), c(e,mean(e),Choquet.integral(m,e))) Shapley.value(m) ## a LP 5-additive more constrained solution lin.prog3 <- lin.prog.capa.ident(5,5, A.Choquet.preorder = Acp, A.Shapley.preorder = Asp, A.Shapley.interval = Asi, A.interaction.preorder = Aip, A.interaction.interval = Aii) m <- lin.prog3$solution m rbind(c(a,mean(a),Choquet.integral(m,a)), c(b,mean(b),Choquet.integral(m,b)), c(c,mean(c),Choquet.integral(m,c)), c(d,mean(d),Choquet.integral(m,d)), c(e,mean(e),Choquet.integral(m,e))) summary(m) ## End(Not run)## some alternatives a <- c(18,11,18,11,11) b <- c(18,18,11,11,11) c <- c(11,11,18,18,11) d <- c(18,11,11,11,18) e <- c(11,11,18,11,18) ## preference threshold relative ## to the preorder of the alternatives delta.C <- 1 ## corresponding Choquet preorder constraint matrix Acp <- rbind(c(d,a,delta.C), c(a,e,delta.C), c(e,b,delta.C), c(b,c,delta.C) ) ## a Shapley preorder constraint matrix ## Sh(1) - Sh(2) >= -delta.S ## Sh(2) - Sh(1) >= -delta.S ## Sh(3) - Sh(4) >= -delta.S ## Sh(4) - Sh(3) >= -delta.S ## i.e. criteria 1,2 and criteria 3,4 ## should have the same global importances delta.S <- 0.01 Asp <- rbind(c(1,2,-delta.S), c(2,1,-delta.S), c(3,4,-delta.S), c(4,3,-delta.S) ) ## a Shapley interval constraint matrix ## 0.3 <= Sh(1) <= 0.9 Asi <- rbind(c(1,0.3,0.9)) ## an interaction preorder constraint matrix ## such that I(12) = I(34) delta.I <- 0.01 Aip <- rbind(c(1,2,3,4,-delta.I), c(3,4,1,2,-delta.I)) ## an interaction interval constraint matrix ## i.e. -0.20 <= I(12) <= -0.15 Aii <- rbind(c(1,2,-0.2,-0.15)) ## Not run: ## a LP 2-additive solution lin.prog <- lin.prog.capa.ident(5,2,A.Choquet.preorder = Acp) m <- lin.prog$solution m ## the resulting global evaluations rbind(c(a,mean(a),Choquet.integral(m,a)), c(b,mean(b),Choquet.integral(m,b)), c(c,mean(c),Choquet.integral(m,c)), c(d,mean(d),Choquet.integral(m,d)), c(e,mean(e),Choquet.integral(m,e))) ## the Shapley value Shapley.value(m) ## a LP 3-additive more constrained solution lin.prog2 <- lin.prog.capa.ident(5,3, A.Choquet.preorder = Acp, A.Shapley.preorder = Asp) m <- lin.prog2$solution m rbind(c(a,mean(a),Choquet.integral(m,a)), c(b,mean(b),Choquet.integral(m,b)), c(c,mean(c),Choquet.integral(m,c)), c(d,mean(d),Choquet.integral(m,d)), c(e,mean(e),Choquet.integral(m,e))) Shapley.value(m) ## a LP 5-additive more constrained solution lin.prog3 <- lin.prog.capa.ident(5,5, A.Choquet.preorder = Acp, A.Shapley.preorder = Asp, A.Shapley.interval = Asi, A.interaction.preorder = Aip, A.interaction.interval = Aii) m <- lin.prog3$solution m rbind(c(a,mean(a),Choquet.integral(m,a)), c(b,mean(b),Choquet.integral(m,b)), c(c,mean(c),Choquet.integral(m,c)), c(d,mean(d),Choquet.integral(m,d)), c(e,mean(e),Choquet.integral(m,e))) summary(m) ## End(Not run)
Ranking alternatives means ordering them from the best to the worst alternative. The aim of the implemented method is to model a given ranking by means of a Choquet integral. The result of the function is an object of class Mobius.capacity. This function is an implementation of the TOMASO method (see Meyer and Roubens (2005)) in the particular ranking framework. The input data are given under the form of a set of alternatives and a partial weak order, each alternative being described according to a set of criteria. These well-known alternatives are called "prototypes". They represent alternatives for which the decision maker has an a priori knowledge and for which he/she is able to build a ranking. If the provided ranking (partial weak order) of the prototypes cannot be described by a Choquet integral, an approximative solution, which minimizes the "gap" between the given ranking and the one derived from the Choquet integral, is proposed. The problem is solved by quadratic programming.
ls.ranking.capa.ident(n, k, C, rk, d, A.Shapley.preorder = NULL, A.Shapley.interval = NULL, A.interaction.preorder = NULL, A.interaction.interval = NULL, A.inter.additive.partition = NULL, sigf = 5, maxiter = 20, epsilon = 1e-6)ls.ranking.capa.ident(n, k, C, rk, d, A.Shapley.preorder = NULL, A.Shapley.interval = NULL, A.interaction.preorder = NULL, A.interaction.interval = NULL, A.inter.additive.partition = NULL, sigf = 5, maxiter = 20, epsilon = 1e-6)
n |
Object of class |
k |
Object of class |
C |
Object of class |
rk |
Object of class |
d |
Object of class |
A.Shapley.preorder |
Object of class |
A.Shapley.interval |
Object of class |
A.interaction.preorder |
Object of class |
A.interaction.interval |
Object of class |
A.inter.additive.partition |
Object of class |
sigf |
Precision (default: 5 significant figures). Parameter to
be passed to the |
maxiter |
Maximum number of iterations. Parameter to
be passed to the |
epsilon |
Object of class |
The quadratic program is solved using the ipop function of
the kernlab package.
The function returns a list structured as follows:
solution |
Object of class
|
glob.eval |
The global evaluations satisfying the given ranking. |
how |
Information returned by |
rk.C |
The ranks of the prototypes |
Choquet.C |
The Choquet integral of the prototypes |
K. Fujimoto and T. Murofushi (2000) Hierarchical decomposition of the Choquet integral, in: Fuzzy Measures and Integrals: Theory and Applications, M. Grabisch, T. Murofushi, and M. Sugeno Eds, Physica Verlag, pages 95-103.
P. Meyer, M. Roubens (2005), Choice, Ranking and Sorting in Fuzzy Multiple Criteria Decision Aid, in: J. Figueira, S. Greco, and M. Ehrgott, Eds, Multiple Criteria Decision Analysis: State of the Art Surveys, volume 78 of International Series in Operations Research and Management Science, chapter 12, pages 471-506. Springer Science + Business Media, Inc., New York.
Mobius.capacity-class,
lin.prog.capa.ident,
mini.var.capa.ident,
mini.dist.capa.ident,
least.squares.capa.ident,
heuristic.ls.capa.ident,
entropy.capa.ident.
arthur <- c(1, 1, 0.75, 0.25) lancelot <- c(0.75, 0.75, 0.75, 0.75) yvain <- c(1, 0.625, 0.5, 1) perceval <- c(0.25, 0.5, 0.75, 0.75) erec <- c(0.375, 1, 0.5 , 0.75) P <- rbind(arthur, lancelot, yvain, perceval, erec) # lancelot > erec; yvain > erec, erec > perceval, erec > arthur rk.proto <- rbind(c("lancelot","erec"), c("yvain","erec"), c("erec","perceval"), c("erec","arthur")) n<-4 k<-2 d<-0.1 ## search for a capacity which satisfies the constraints lrc <- ls.ranking.capa.ident(n ,k, P, rk.proto, d) lrcarthur <- c(1, 1, 0.75, 0.25) lancelot <- c(0.75, 0.75, 0.75, 0.75) yvain <- c(1, 0.625, 0.5, 1) perceval <- c(0.25, 0.5, 0.75, 0.75) erec <- c(0.375, 1, 0.5 , 0.75) P <- rbind(arthur, lancelot, yvain, perceval, erec) # lancelot > erec; yvain > erec, erec > perceval, erec > arthur rk.proto <- rbind(c("lancelot","erec"), c("yvain","erec"), c("erec","perceval"), c("erec","arthur")) n<-4 k<-2 d<-0.1 ## search for a capacity which satisfies the constraints lrc <- ls.ranking.capa.ident(n ,k, P, rk.proto, d) lrc
Sorting alternatives means assigning each alternative to a predefined
ordered class. The aim of the implemented method is to model a given classification (sorting)
of the alternatives by means of a Choquet integral. The result of the function
is an object of class Mobius.capacity. This function (in
combination with ls.sorting.treatment) is an implementation of
the TOMASO method; see Meyer and Roubens (2005). The input data are
given under the form of a set of alternatives and associated classes,
each alternative being described according to a set of criteria. These
well-known alternatives are called "prototypes". They represent
alternatives for which the decision maker has an a priori knowledge
and that he/she is able to assign to one of the
ordered classes. If the provided classification of the prototypes cannot be
described by a Choquet integral, an approximative solution, which minimizes
the "gap" between the given classification and the one derived from
the Choquet integral, is proposed. The problem is solved by quadratic
programming. This function should be used in combination with
ls.sorting.treatment which allows to evaluate the model which
has been built and to assign other alternatives to the ordered classes.
ls.sorting.capa.ident(n, k, C, cl, d, A.Shapley.preorder = NULL, A.Shapley.interval = NULL, A.interaction.preorder = NULL, A.interaction.interval = NULL, A.inter.additive.partition = NULL, sigf = 5, maxiter = 20, epsilon = 1e-6)ls.sorting.capa.ident(n, k, C, cl, d, A.Shapley.preorder = NULL, A.Shapley.interval = NULL, A.interaction.preorder = NULL, A.interaction.interval = NULL, A.inter.additive.partition = NULL, sigf = 5, maxiter = 20, epsilon = 1e-6)
n |
Object of class |
k |
Object of class |
C |
Object of class |
cl |
Object of class |
d |
Object of class |
A.Shapley.preorder |
Object of class |
A.Shapley.interval |
Object of class |
A.interaction.preorder |
Object of class |
A.interaction.interval |
Object of class |
A.inter.additive.partition |
Object of class |
sigf |
Precision (default: 5 significant figures). Parameter to
be passed to the |
maxiter |
Maximum number of iterations. Parameter to
be passed to the |
epsilon |
Object of class |
The quadratic program is solved using the ipop function of
the kernlab package.
The function returns a list structured as follows:
solution |
Object of class
|
glob.eval |
The global evaluations satisfying the given classification. |
how |
Information returned by |
K. Fujimoto and T. Murofushi (2000) Hierarchical decomposition of the Choquet integral, in: Fuzzy Measures and Integrals: Theory and Applications, M. Grabisch, T. Murofushi, and M. Sugeno Eds, Physica Verlag, pages 95-103.
P. Meyer, M. Roubens (2005), Choice, Ranking and Sorting in Fuzzy Multiple Criteria Decision Aid, in: J. Figueira, S. Greco, and M. Ehrgott, Eds, Multiple Criteria Decision Analysis: State of the Art Surveys, volume 78 of International Series in Operations Research and Management Science, chapter 12, pages 471-506. Springer Science + Business Media, Inc., New York.
Mobius.capacity-class,
lin.prog.capa.ident,
mini.var.capa.ident,
mini.dist.capa.ident,
least.squares.capa.ident,
heuristic.ls.capa.ident,
ls.sorting.treatment,
entropy.capa.ident.
## generate a random problem with 10 prototypes and 4 criteria n.proto <- 10 ## prototypes n <- 4 ## criteria k <- 4 d <- 0.1 ## generating random data for the prototypes C <- matrix(runif(n.proto*n,0,1),n.proto,n) cl <- numeric(n.proto) ## the corresponding global evaluations glob.eval <- numeric(n.proto) a <- capacity(c(0:(2^n-3),(2^n-3),(2^n-3))/(2^n-3)) for (i in 1:n.proto) glob.eval[i] <- Choquet.integral(a,C[i,]) ## and the classes for the prototypes cl[glob.eval <= 0.33] <- 1 cl[glob.eval > 0.33 & glob.eval <= 0.66] <-2 cl[glob.eval > 0.66] <- 3 cl ## Not run: # starting the calculations # search for a capacity which satisfies the constraints lsc <- ls.sorting.capa.ident(n ,k, C, cl, d) ## output of the quadratic program (ipop, package kernlab) lsc$how ## the capacity satisfying the constraints lsc$solution summary(lsc$solution) ## the global evaluations satisfying the constraints lsc$glob.eval ## End(Not run) ## let us now add some constraints ## a Shapley preorder constraint matrix ## Sh(1) > Sh(2) ## Sh(3) > Sh(4) delta.S <-0.01 Asp <- rbind(c(1,2,delta.S), c(3,4,delta.S)) ## a Shapley interval constraint matrix ## 0.1 <= Sh(1) <= 0.2 Asi <- rbind(c(1,0.1,0.2)) ## an interaction preorder constraint matrix ## such that I(12) > I(34) delta.I <- 0.01 Aip <- rbind(c(1,2,3,4,delta.I)) ## an interaction interval constraint matrix ## i.e. 0.2 <= I(12) <= 0.4 ## and 0 < I(34) <= 1 Aii <- rbind(c(1,2,0.2,0.4), c(3,4,delta.I,1)) ## an inter-additive partition constraint ## criteria 1,2 and criteria 3,4 are independent Aiap <- c(1,1,2,2) ## starting the calculations ## search for a capacity which satisfies the constraints lsc <- ls.sorting.capa.ident(n ,k, C, cl, d, A.Shapley.preorder = Asp, A.Shapley.interval = Asi, A.interaction.preorder = Aip, A.interaction.interval = Aii, A.inter.additive.partition = Aiap) ## output of ipop lsc$how ## the capacity satisfying the constraints lsc$solution summary(lsc$solution) ## the global evaluations satisfying the constraints lsc$glob.eval## generate a random problem with 10 prototypes and 4 criteria n.proto <- 10 ## prototypes n <- 4 ## criteria k <- 4 d <- 0.1 ## generating random data for the prototypes C <- matrix(runif(n.proto*n,0,1),n.proto,n) cl <- numeric(n.proto) ## the corresponding global evaluations glob.eval <- numeric(n.proto) a <- capacity(c(0:(2^n-3),(2^n-3),(2^n-3))/(2^n-3)) for (i in 1:n.proto) glob.eval[i] <- Choquet.integral(a,C[i,]) ## and the classes for the prototypes cl[glob.eval <= 0.33] <- 1 cl[glob.eval > 0.33 & glob.eval <= 0.66] <-2 cl[glob.eval > 0.66] <- 3 cl ## Not run: # starting the calculations # search for a capacity which satisfies the constraints lsc <- ls.sorting.capa.ident(n ,k, C, cl, d) ## output of the quadratic program (ipop, package kernlab) lsc$how ## the capacity satisfying the constraints lsc$solution summary(lsc$solution) ## the global evaluations satisfying the constraints lsc$glob.eval ## End(Not run) ## let us now add some constraints ## a Shapley preorder constraint matrix ## Sh(1) > Sh(2) ## Sh(3) > Sh(4) delta.S <-0.01 Asp <- rbind(c(1,2,delta.S), c(3,4,delta.S)) ## a Shapley interval constraint matrix ## 0.1 <= Sh(1) <= 0.2 Asi <- rbind(c(1,0.1,0.2)) ## an interaction preorder constraint matrix ## such that I(12) > I(34) delta.I <- 0.01 Aip <- rbind(c(1,2,3,4,delta.I)) ## an interaction interval constraint matrix ## i.e. 0.2 <= I(12) <= 0.4 ## and 0 < I(34) <= 1 Aii <- rbind(c(1,2,0.2,0.4), c(3,4,delta.I,1)) ## an inter-additive partition constraint ## criteria 1,2 and criteria 3,4 are independent Aiap <- c(1,1,2,2) ## starting the calculations ## search for a capacity which satisfies the constraints lsc <- ls.sorting.capa.ident(n ,k, C, cl, d, A.Shapley.preorder = Asp, A.Shapley.interval = Asi, A.interaction.preorder = Aip, A.interaction.interval = Aii, A.inter.additive.partition = Aiap) ## output of ipop lsc$how ## the capacity satisfying the constraints lsc$solution summary(lsc$solution) ## the global evaluations satisfying the constraints lsc$glob.eval
This function assigns alternatives to classes and optionally compares
the obtained classification to a given one. The classes are
described by a set of prototypes (well-known alternatives for the
decision maker) and a capacity (which can, for instance, be determined by
ls.sorting.capa.ident). This function (in combination with
ls.sorting.capa.ident) is an
implementation of the TOMASO method; see Meyer and Roubens (2005).
ls.sorting.treatment(P, cl.proto, a, A, cl.orig.A = NULL)ls.sorting.treatment(P, cl.proto, a, A, cl.orig.A = NULL)
P |
Object of class |
cl.proto |
Object of class |
a |
Object of class |
A |
Object of class |
cl.orig.A |
Object of class |
The function returns a list structured as follows:
correct.A |
Object of class |
class.A |
Object of class |
eval.correct |
Object of class |
minmax.P |
Object of class |
Choquet.A |
Object of class |
P. Meyer, M. Roubens (2005), Choice, Ranking and Sorting in Fuzzy Multiple Criteria Decision Aid, in: J. Figueira, S. Greco, and M. Ehrgott, Eds, Multiple Criteria Decision Analysis: State of the Art Surveys, volume 78 of International Series in Operations Research and Management Science, chapter 12, pages 471-506. Springer Science + Business Media, Inc., New York.
Mobius.capacity-class,
mini.var.capa.ident,
mini.dist.capa.ident,
ls.sorting.capa.ident,
least.squares.capa.ident,
heuristic.ls.capa.ident,
entropy.capa.ident.
## generate a random problem with 10 prototypes and 4 criteria n.proto <- 10 ## prototypes n <- 4 ## criteria P <- matrix(runif(n.proto*n,0,1),n.proto,n) ## the corresponding global scores, based on a randomly generated ## capacity a glob.eval <- numeric(n.proto) a <- capacity(c(0:(2^n-3),(2^n-3),(2^n-3))/(2^n-3)) for (i in 1:n.proto) glob.eval[i] <- Choquet.integral(a,P[i,]) ## based on these global scores, let us create a classification (3 classes) cl.proto<-numeric(n.proto) cl.proto[glob.eval <= 0.33] <- 1 cl.proto[glob.eval > 0.33 & glob.eval<=0.66] <-2 cl.proto[glob.eval > 0.66] <- 3 ## search for a capacity which satisfies the constraints lsc <- ls.sorting.capa.ident(n ,4, P, cl.proto, 0.1) ## output of the QP lsc$how ## analyse the quality of the model (classify the prototypes by the ## model and compare both assignments) lst <- ls.sorting.treatment(P,cl.proto,lsc$solution,P,cl.proto) ## assignments of the prototypes lst$class.A ## assignment types lst$correct.A ## evaluation lst$eval.correct ## generate a second set of random alternatives (A) ## their "correct" class is determined as beforehand with the ## randomly generated capacity a ## the goal is to see if we can reproduce this classification ## by the capacity learnt from the prototypes ## a randomly generated criteria matrix of 10 alternatives A <- matrix(runif(10*n,0,1),10,n) cl.orig.A <-numeric(10) ## the corresponding global scores glob.eval.A <- numeric(10) for (i in 1:10) glob.eval.A[i] <- Choquet.integral(a,A[i,]) ## based on these global scores, let us determine a classification cl.orig.A[glob.eval.A <= 0.33] <- 1 cl.orig.A[glob.eval.A>0.33 & glob.eval.A<=0.66] <-2 cl.orig.A[glob.eval.A > 0.66] <- 3 ## let us now classify the alternatives of A according to the model ## built on P lst <- ls.sorting.treatment(P,cl.proto,lsc$solution,A,cl.orig.A) ## assignment of the alternatives of A lst$class.A ## type of assignments lst$correct.A ## evaluation lst$eval.correct ## show the learnt capacity ## x11() ## barplot(Shapley.value(lsc$solution), main="Learnt capacity", sub="Shapley") ## summary of the learnt capacity lsc$solution summary(lsc$solution)## generate a random problem with 10 prototypes and 4 criteria n.proto <- 10 ## prototypes n <- 4 ## criteria P <- matrix(runif(n.proto*n,0,1),n.proto,n) ## the corresponding global scores, based on a randomly generated ## capacity a glob.eval <- numeric(n.proto) a <- capacity(c(0:(2^n-3),(2^n-3),(2^n-3))/(2^n-3)) for (i in 1:n.proto) glob.eval[i] <- Choquet.integral(a,P[i,]) ## based on these global scores, let us create a classification (3 classes) cl.proto<-numeric(n.proto) cl.proto[glob.eval <= 0.33] <- 1 cl.proto[glob.eval > 0.33 & glob.eval<=0.66] <-2 cl.proto[glob.eval > 0.66] <- 3 ## search for a capacity which satisfies the constraints lsc <- ls.sorting.capa.ident(n ,4, P, cl.proto, 0.1) ## output of the QP lsc$how ## analyse the quality of the model (classify the prototypes by the ## model and compare both assignments) lst <- ls.sorting.treatment(P,cl.proto,lsc$solution,P,cl.proto) ## assignments of the prototypes lst$class.A ## assignment types lst$correct.A ## evaluation lst$eval.correct ## generate a second set of random alternatives (A) ## their "correct" class is determined as beforehand with the ## randomly generated capacity a ## the goal is to see if we can reproduce this classification ## by the capacity learnt from the prototypes ## a randomly generated criteria matrix of 10 alternatives A <- matrix(runif(10*n,0,1),10,n) cl.orig.A <-numeric(10) ## the corresponding global scores glob.eval.A <- numeric(10) for (i in 1:10) glob.eval.A[i] <- Choquet.integral(a,A[i,]) ## based on these global scores, let us determine a classification cl.orig.A[glob.eval.A <= 0.33] <- 1 cl.orig.A[glob.eval.A>0.33 & glob.eval.A<=0.66] <-2 cl.orig.A[glob.eval.A > 0.66] <- 3 ## let us now classify the alternatives of A according to the model ## built on P lst <- ls.sorting.treatment(P,cl.proto,lsc$solution,A,cl.orig.A) ## assignment of the alternatives of A lst$class.A ## type of assignments lst$correct.A ## evaluation lst$eval.correct ## show the learnt capacity ## x11() ## barplot(Shapley.value(lsc$solution), main="Learnt capacity", sub="Shapley") ## summary of the learnt capacity lsc$solution summary(lsc$solution)
Creates an object of class Mobius.capacity using a
minimum distance principle. More precisely, this function determines,
if it exists, the closest capacity to a user-given game compatible
with a set of linear constraints. The distance can be chosen among
three quadratic distances (see help and references hereafter). The
problem is solved using strictly convex quadratic programming.
mini.dist.capa.ident(a, k, distance = "Choquet.coefficients", A.Choquet.preorder = NULL, A.Shapley.preorder = NULL, A.Shapley.interval = NULL, A.interaction.preorder = NULL, A.interaction.interval = NULL, A.inter.additive.partition = NULL, epsilon = 1e-6)mini.dist.capa.ident(a, k, distance = "Choquet.coefficients", A.Choquet.preorder = NULL, A.Shapley.preorder = NULL, A.Shapley.interval = NULL, A.interaction.preorder = NULL, A.interaction.interval = NULL, A.inter.additive.partition = NULL, epsilon = 1e-6)
a |
Object of class |
k |
Object of class |
distance |
Object of class |
A.Choquet.preorder |
Object of class |
A.Shapley.preorder |
Object of class |
A.Shapley.interval |
Object of class |
A.interaction.preorder |
Object of class |
A.interaction.interval |
Object of class |
A.inter.additive.partition |
Object of class |
epsilon |
Object of class |
The quadratic program is solved using the solve.QP function of
the quadprog package.
The function returns a list structured as follows:
solution |
Object of class |
value |
Value of the objective function. |
iterations |
Information returned by |
iact |
Information returned by |
K. Fujimoto and T. Murofushi (2000) Hierarchical decomposition of the Choquet integral, in: Fuzzy Measures and Integrals: Theory and Applications, M. Grabisch, T. Murofushi, and M. Sugeno Eds, Physica Verlag, pages 95-103.
I. Kojadinovic (2006), Quadratic objective functions for capacity and bi-capacity identification and approximation, A Quarterly Journal of Operations Research (40R), in press.
Mobius.capacity-class,
lin.prog.capa.ident,
mini.var.capa.ident,
least.squares.capa.ident,
heuristic.ls.capa.ident,
ls.sorting.capa.ident,
entropy.capa.ident.
## some alternatives a <- c(18,11,18,11,11) b <- c(18,18,11,11,11) c <- c(11,11,18,18,11) d <- c(18,11,11,11,18) e <- c(11,11,18,11,18) ## preference threshold relative ## to the preorder of the alternatives delta.C <- 1 ## corresponding Choquet preorder constraint matrix Acp <- rbind(c(d,a,delta.C), c(a,e,delta.C), c(e,b,delta.C), c(b,c,delta.C) ) ## a Shapley preorder constraint matrix ## Sh(1) - Sh(2) >= -delta.S ## Sh(2) - Sh(1) >= -delta.S ## Sh(3) - Sh(4) >= -delta.S ## Sh(4) - Sh(3) >= -delta.S ## i.e. criteria 1,2 and criteria 3,4 ## should have the same global importances delta.S <- 0.01 Asp <- rbind(c(1,2,-delta.S), c(2,1,-delta.S), c(3,4,-delta.S), c(4,3,-delta.S) ) ## a Shapley interval constraint matrix ## 0.3 <= Sh(1) <= 0.9 Asi <- rbind(c(1,0.3,0.9)) ## an interaction preorder constraint matrix ## such that I(12) = I(34) delta.I <- 0.01 Aip <- rbind(c(1,2,3,4,-delta.I), c(3,4,1,2,-delta.I)) ## an interaction interval constraint matrix ## i.e. -0.20 <= I(12) <= -0.15 Aii <- rbind(c(1,2,-0.2,-0.15)) ## the capacity that we want to approach x <- runif(31) for (i in 2:31) x[i] <- x[i] + x[i-1] mu <- normalize(capacity(c(0,x))) ## and its Mobius transform a.mu <- Mobius(mu) ## some basic checks ## Not run: mini.dist.capa.ident(a.mu,5) mini.dist.capa.ident(a.mu,5,"binary.alternatives") mini.dist.capa.ident(a.mu,5,"global.scores") mini.dist.capa.ident(a.mu,3) mini.dist.capa.ident(a.mu,3,"binary.alternatives") mini.dist.capa.ident(a.mu,3,"global.scores") ## End(Not run) ## a minimum distance 2-additive solution min.dist <- mini.dist.capa.ident(a.mu,2,"binary.alternatives", A.Choquet.preorder = Acp) m <- min.dist$solution m ## a minimum distance 3-additive more constrained solution min.dist2 <- mini.dist.capa.ident(a.mu,3,"global.scores", A.Choquet.preorder = Acp, A.Shapley.preorder = Asp) m <- min.dist2$solution m rbind(c(a,mean(a),Choquet.integral(m,a)), c(b,mean(b),Choquet.integral(m,b)), c(c,mean(c),Choquet.integral(m,c)), c(d,mean(d),Choquet.integral(m,d)), c(e,mean(e),Choquet.integral(m,e))) Shapley.value(m) ## Not run: ## a minimum distance 5-additive more constrained solution min.dist3 <- mini.dist.capa.ident(a.mu,5, A.Choquet.preorder = Acp, A.Shapley.preorder = Asp, A.Shapley.interval = Asi, A.interaction.preorder = Aip, A.interaction.interval = Aii) m <- min.dist3$solution m rbind(c(a,mean(a),Choquet.integral(m,a)), c(b,mean(b),Choquet.integral(m,b)), c(c,mean(c),Choquet.integral(m,c)), c(d,mean(d),Choquet.integral(m,d)), c(e,mean(e),Choquet.integral(m,e))) summary(m) ## End(Not run)## some alternatives a <- c(18,11,18,11,11) b <- c(18,18,11,11,11) c <- c(11,11,18,18,11) d <- c(18,11,11,11,18) e <- c(11,11,18,11,18) ## preference threshold relative ## to the preorder of the alternatives delta.C <- 1 ## corresponding Choquet preorder constraint matrix Acp <- rbind(c(d,a,delta.C), c(a,e,delta.C), c(e,b,delta.C), c(b,c,delta.C) ) ## a Shapley preorder constraint matrix ## Sh(1) - Sh(2) >= -delta.S ## Sh(2) - Sh(1) >= -delta.S ## Sh(3) - Sh(4) >= -delta.S ## Sh(4) - Sh(3) >= -delta.S ## i.e. criteria 1,2 and criteria 3,4 ## should have the same global importances delta.S <- 0.01 Asp <- rbind(c(1,2,-delta.S), c(2,1,-delta.S), c(3,4,-delta.S), c(4,3,-delta.S) ) ## a Shapley interval constraint matrix ## 0.3 <= Sh(1) <= 0.9 Asi <- rbind(c(1,0.3,0.9)) ## an interaction preorder constraint matrix ## such that I(12) = I(34) delta.I <- 0.01 Aip <- rbind(c(1,2,3,4,-delta.I), c(3,4,1,2,-delta.I)) ## an interaction interval constraint matrix ## i.e. -0.20 <= I(12) <= -0.15 Aii <- rbind(c(1,2,-0.2,-0.15)) ## the capacity that we want to approach x <- runif(31) for (i in 2:31) x[i] <- x[i] + x[i-1] mu <- normalize(capacity(c(0,x))) ## and its Mobius transform a.mu <- Mobius(mu) ## some basic checks ## Not run: mini.dist.capa.ident(a.mu,5) mini.dist.capa.ident(a.mu,5,"binary.alternatives") mini.dist.capa.ident(a.mu,5,"global.scores") mini.dist.capa.ident(a.mu,3) mini.dist.capa.ident(a.mu,3,"binary.alternatives") mini.dist.capa.ident(a.mu,3,"global.scores") ## End(Not run) ## a minimum distance 2-additive solution min.dist <- mini.dist.capa.ident(a.mu,2,"binary.alternatives", A.Choquet.preorder = Acp) m <- min.dist$solution m ## a minimum distance 3-additive more constrained solution min.dist2 <- mini.dist.capa.ident(a.mu,3,"global.scores", A.Choquet.preorder = Acp, A.Shapley.preorder = Asp) m <- min.dist2$solution m rbind(c(a,mean(a),Choquet.integral(m,a)), c(b,mean(b),Choquet.integral(m,b)), c(c,mean(c),Choquet.integral(m,c)), c(d,mean(d),Choquet.integral(m,d)), c(e,mean(e),Choquet.integral(m,e))) Shapley.value(m) ## Not run: ## a minimum distance 5-additive more constrained solution min.dist3 <- mini.dist.capa.ident(a.mu,5, A.Choquet.preorder = Acp, A.Shapley.preorder = Asp, A.Shapley.interval = Asi, A.interaction.preorder = Aip, A.interaction.interval = Aii) m <- min.dist3$solution m rbind(c(a,mean(a),Choquet.integral(m,a)), c(b,mean(b),Choquet.integral(m,b)), c(c,mean(c),Choquet.integral(m,c)), c(d,mean(d),Choquet.integral(m,d)), c(e,mean(e),Choquet.integral(m,e))) summary(m) ## End(Not run)
Creates an object of class Mobius.capacity using a
maximum like quadratic entropy principle, which is equivalent to the minimization of the
variance. More precisely, this function determines, if it exists, the minimum
variance capacity compatible with a set of linear constraints. The
problem is solved using strictly convex quadratic programming.
mini.var.capa.ident(n, k, A.Choquet.preorder = NULL, A.Shapley.preorder = NULL, A.Shapley.interval = NULL, A.interaction.preorder = NULL, A.interaction.interval = NULL, A.inter.additive.partition = NULL, epsilon = 1e-6)mini.var.capa.ident(n, k, A.Choquet.preorder = NULL, A.Shapley.preorder = NULL, A.Shapley.interval = NULL, A.interaction.preorder = NULL, A.interaction.interval = NULL, A.inter.additive.partition = NULL, epsilon = 1e-6)
n |
Object of class |
k |
Object of class |
A.Choquet.preorder |
Object of class |
A.Shapley.preorder |
Object of class |
A.Shapley.interval |
Object of class |
A.interaction.preorder |
Object of class |
A.interaction.interval |
Object of class |
A.inter.additive.partition |
Object of class |
epsilon |
Object of class |
The quadratic program is solved using the solve.QP function of
the quadprog package.
The function returns a list structured as follows:
solution |
Object of class |
value |
Value of the objective function. |
iterations |
Information returned by |
iact |
Information returned by |
K. Fujimoto and T. Murofushi (2000) Hierarchical decomposition of the Choquet integral, in: Fuzzy Measures and Integrals: Theory and Applications, M. Grabisch, T. Murofushi, and M. Sugeno Eds, Physica Verlag, pages 95-103.
I. Kojadinovic (2005), Minimum variance capacity identification, European Journal of Operational Research, in press.
Mobius.capacity-class,
lin.prog.capa.ident,
mini.dist.capa.ident,
least.squares.capa.ident,
heuristic.ls.capa.ident,
ls.sorting.capa.ident,
entropy.capa.ident.
## some alternatives a <- c(18,11,18,11,11) b <- c(18,18,11,11,11) c <- c(11,11,18,18,11) d <- c(18,11,11,11,18) e <- c(11,11,18,11,18) ## preference threshold relative ## to the preorder of the alternatives delta.C <- 1 ## corresponding Choquet preorder constraint matrix Acp <- rbind(c(d,a,delta.C), c(a,e,delta.C), c(e,b,delta.C), c(b,c,delta.C) ) ## a Shapley preorder constraint matrix ## Sh(1) - Sh(2) >= -delta.S ## Sh(2) - Sh(1) >= -delta.S ## Sh(3) - Sh(4) >= -delta.S ## Sh(4) - Sh(3) >= -delta.S ## i.e. criteria 1,2 and criteria 3,4 ## should have the same global importances delta.S <- 0.01 Asp <- rbind(c(1,2,-delta.S), c(2,1,-delta.S), c(3,4,-delta.S), c(4,3,-delta.S) ) ## a Shapley interval constraint matrix ## 0.3 <= Sh(1) <= 0.9 Asi <- rbind(c(1,0.3,0.9)) ## an interaction preorder constraint matrix ## such that I(12) = I(34) delta.I <- 0.01 Aip <- rbind(c(1,2,3,4,-delta.I), c(3,4,1,2,-delta.I)) ## an interaction interval constraint matrix ## i.e. -0.20 <= I(12) <= -0.15 Aii <- rbind(c(1,2,-0.2,-0.15)) ## a minimum variance 2-additive solution min.var <- mini.var.capa.ident(5,2,A.Choquet.preorder = Acp) m <- min.var$solution m ## the resulting global evaluations rbind(c(a,mean(a),Choquet.integral(m,a)), c(b,mean(b),Choquet.integral(m,b)), c(c,mean(c),Choquet.integral(m,c)), c(d,mean(d),Choquet.integral(m,d)), c(e,mean(e),Choquet.integral(m,e))) ## the Shapley value Shapley.value(m) ## a minimum variance 3-additive more constrained solution min.var2 <- mini.var.capa.ident(5,3, A.Choquet.preorder = Acp, A.Shapley.preorder = Asp) m <- min.var2$solution m rbind(c(a,mean(a),Choquet.integral(m,a)), c(b,mean(b),Choquet.integral(m,b)), c(c,mean(c),Choquet.integral(m,c)), c(d,mean(d),Choquet.integral(m,d)), c(e,mean(e),Choquet.integral(m,e))) Shapley.value(m) ## a minimum variance 5-additive more constrained solution min.var3 <- mini.var.capa.ident(5,5, A.Choquet.preorder = Acp, A.Shapley.preorder = Asp, A.Shapley.interval = Asi, A.interaction.preorder = Aip, A.interaction.interval = Aii) m <- min.var3$solution m rbind(c(a,mean(a),Choquet.integral(m,a)), c(b,mean(b),Choquet.integral(m,b)), c(c,mean(c),Choquet.integral(m,c)), c(d,mean(d),Choquet.integral(m,d)), c(e,mean(e),Choquet.integral(m,e))) summary(m)## some alternatives a <- c(18,11,18,11,11) b <- c(18,18,11,11,11) c <- c(11,11,18,18,11) d <- c(18,11,11,11,18) e <- c(11,11,18,11,18) ## preference threshold relative ## to the preorder of the alternatives delta.C <- 1 ## corresponding Choquet preorder constraint matrix Acp <- rbind(c(d,a,delta.C), c(a,e,delta.C), c(e,b,delta.C), c(b,c,delta.C) ) ## a Shapley preorder constraint matrix ## Sh(1) - Sh(2) >= -delta.S ## Sh(2) - Sh(1) >= -delta.S ## Sh(3) - Sh(4) >= -delta.S ## Sh(4) - Sh(3) >= -delta.S ## i.e. criteria 1,2 and criteria 3,4 ## should have the same global importances delta.S <- 0.01 Asp <- rbind(c(1,2,-delta.S), c(2,1,-delta.S), c(3,4,-delta.S), c(4,3,-delta.S) ) ## a Shapley interval constraint matrix ## 0.3 <= Sh(1) <= 0.9 Asi <- rbind(c(1,0.3,0.9)) ## an interaction preorder constraint matrix ## such that I(12) = I(34) delta.I <- 0.01 Aip <- rbind(c(1,2,3,4,-delta.I), c(3,4,1,2,-delta.I)) ## an interaction interval constraint matrix ## i.e. -0.20 <= I(12) <= -0.15 Aii <- rbind(c(1,2,-0.2,-0.15)) ## a minimum variance 2-additive solution min.var <- mini.var.capa.ident(5,2,A.Choquet.preorder = Acp) m <- min.var$solution m ## the resulting global evaluations rbind(c(a,mean(a),Choquet.integral(m,a)), c(b,mean(b),Choquet.integral(m,b)), c(c,mean(c),Choquet.integral(m,c)), c(d,mean(d),Choquet.integral(m,d)), c(e,mean(e),Choquet.integral(m,e))) ## the Shapley value Shapley.value(m) ## a minimum variance 3-additive more constrained solution min.var2 <- mini.var.capa.ident(5,3, A.Choquet.preorder = Acp, A.Shapley.preorder = Asp) m <- min.var2$solution m rbind(c(a,mean(a),Choquet.integral(m,a)), c(b,mean(b),Choquet.integral(m,b)), c(c,mean(c),Choquet.integral(m,c)), c(d,mean(d),Choquet.integral(m,d)), c(e,mean(e),Choquet.integral(m,e))) Shapley.value(m) ## a minimum variance 5-additive more constrained solution min.var3 <- mini.var.capa.ident(5,5, A.Choquet.preorder = Acp, A.Shapley.preorder = Asp, A.Shapley.interval = Asi, A.interaction.preorder = Aip, A.interaction.interval = Aii) m <- min.var3$solution m rbind(c(a,mean(a),Choquet.integral(m,a)), c(b,mean(b),Choquet.integral(m,b)), c(c,mean(c),Choquet.integral(m,c)), c(d,mean(d),Choquet.integral(m,d)), c(e,mean(e),Choquet.integral(m,e))) summary(m)
Computes the Möbius transform of a set function. The Möbius transform is the inverse of the zeta transform.
Returns an object of class Mobius.capacity.
Returns an object of class Mobius.card.set.func.
Returns an object of class Mobius.game.
Returns an object of class Mobius.set.func.
G-C. Rota (1964), On the foundations of combinatorial theory. I. Theory of Möbius functions, Z. Wahrscheinlichkeitstheorie und Verw. Gebiete 2, pages 340-368.
A. Chateauneuf and J-Y. Jaffray (1989), Some characterizations of lower probabilities and other monotone capacities through the use of Möbius inversion, Mathematical Social Sciences 17, pages 263-283.
M. Grabisch, J-L. Marichal and M. Roubens (2000), Equivalent representations of set functions, Mathematics of Operations Research 25:2, pages 157-178.
Mobius.capacity-class,
Mobius.card.set.func-class,
Mobius.game-class,
Mobius.set.func-class,
capacity-class,
card.set.func-class,
game-class,
set.func-class,
zeta-methods.
## a capacity mu <- capacity(0:15) mu ## its Mobius transform a <- Mobius(mu) a ## its zeta transform zeta(a) ## a similar example with a game object mu <- game(c(0,-2:12)) mu Mobius(mu) zeta(Mobius(mu)) ## a similar example with a set.func object mu <- set.func(-7:8) mu Mobius(mu) zeta(Mobius(mu)) ## a similar example with a card.set.func object mu <- card.set.func(-3:4) mu Mobius(mu) zeta(Mobius(mu))## a capacity mu <- capacity(0:15) mu ## its Mobius transform a <- Mobius(mu) a ## its zeta transform zeta(a) ## a similar example with a game object mu <- game(c(0,-2:12)) mu Mobius(mu) zeta(Mobius(mu)) ## a similar example with a set.func object mu <- set.func(-7:8) mu Mobius(mu) zeta(Mobius(mu)) ## a similar example with a card.set.func object mu <- card.set.func(-3:4) mu Mobius(mu) zeta(Mobius(mu))
Class representing the Möbius transform of a capacity.
Objects can be mainly created by calls
to the functions Mobius.capacity,
mini.var.capa.ident,
ls.sorting.capa.ident,
and least.squares.capa.ident.
n:Object of class numeric of length 1 containing the
number of elements of the set on which the Möbius transform is
defined.
k:Object of class numeric of length 1 containg the order of
truncation of the Möbius transform: the value of subsets whose cardinal is
superior to k is put to zero.
subsets:Object of class numeric containing
the "k power set" of the underlying
set in "natural" order . The subsets are encoded as integers.
data:Object of class numeric of length
choose(n,0) + ... + choose(n,k) representing the
coefficients of a truncated Möbius transform of a capacity in "natural" order.
Class Mobius.game, directly.
Class superclass.capacity, directly.
Class Mobius.set.func, by class Mobius.game.
Class superclass.set.func, by class Mobius.game.
signature(object = "Mobius.capacity")
signature(object = "Mobius.capacity")
signature(object = "Mobius.capacity")
signature(object = "Mobius.capacity")
signature(object = "Mobius.capacity")
signature(object = "Mobius.capacity")
signature(object = "Mobius.capacity")
signature(object = "Mobius.capacity")
capacity-class,
entropy-methods,
favor-methods,
is.normalized-methods,
orness-methods,
variance-methods,
veto-methods,
zeta-methods,
mini.var.capa.ident,
least.squares.capa.ident,
ls.sorting.capa.ident.
## a capacity mu <- capacity(c(0,0,0:13)) ## and its Mobius representation a <- Mobius(mu) a # the attributes of object a a@n a@k a@data a@subsets ## a test is.normalized(a) ## normalize it normalize(a) ## a transformation zeta(a) ## Let us check ... Mobius(zeta(a)) ## some summary indices orness(a) veto(a) favor(a) variance(a) entropy(a) ## the same summary(a)## a capacity mu <- capacity(c(0,0,0:13)) ## and its Mobius representation a <- Mobius(mu) a # the attributes of object a a@n a@k a@data a@subsets ## a test is.normalized(a) ## normalize it normalize(a) ## a transformation zeta(a) ## Let us check ... Mobius(zeta(a)) ## some summary indices orness(a) veto(a) favor(a) variance(a) entropy(a) ## the same summary(a)
Creates objects of class Mobius.card.set.func: from
an object of class numeric.
Mobius.card.set.func(object)Mobius.card.set.func(object)
object |
An object of class |
Returns an object of class Mobius.card.set.func.
Mobius.card.set.func(4:-2)Mobius.card.set.func(4:-2)
Class representing the Möbius transform of a cardinal set function.
Objects can be created by calls to the function
Mobius.card.set.func.
n:Object of class numeric of length 1 equal
to the number of elements of the set on which the Möbius
representation of a cardinal set function is defined.
data:Object of class numeric of length
n+1 containing the coefficients of the Möbius
representation of a cardinal set function.
Class superclass.set.func, directly.
signature(object =
"Mobius.card.set.func")
signature(object =
"Mobius.card.set.func")
signature(object = "Mobius.card.set.func")
signature(object = "Mobius.card.set.func")
signature(object = "Mobius.card.set.func")
Mobius.set.func-class,
Mobius.card.set.func,
as.Mobius.set.func-methods,
as.card.set.func-methods,
as.set.func-methods,
zeta-methods,
to.data.frame-methods.
## the Mobius representation of a cardinal set function a <- Mobius.card.set.func(-3:2) # the attributes of the object a@n a@data ## some transformations as.set.func(a) zeta(a) ## let us check ... Mobius(zeta(a))## the Mobius representation of a cardinal set function a <- Mobius.card.set.func(-3:2) # the attributes of the object a@n a@data ## some transformations as.set.func(a) zeta(a) ## let us check ... Mobius(zeta(a))
Class representing the Möbius transform of a game.
Objects can be created by calls to the function Mobius.game.
n:Object of class numeric of length 1 containing the
number of elements of the set on which the Möbius transform is
defined.
k:Object of class numeric of length 1 containg the order
of truncation of the Möbius transform: subsets whose cardinal is
superior to k are considered to be zero.
subsets:Object of class numeric containing
the "k power set" of the underlying
set in "natural" order . The subsets are encoded as integers.
data:Object of class numeric of length
choose(n,0) + ... + choose(n,k) representing the
coefficients of a truncated Möbius transform of a game in "natural" order.
Class Mobius.set.func, directly.
Class superclass.set.func, by class Mobius.set.func.
signature(object = "Mobius.game", f =
"numeric")
signature(object = "Mobius.game", f =
"numeric")
signature(object = "Mobius.game", f =
"numeric")
signature(object = "Mobius.game")
game-class,
Mobius.game,
Choquet.integral-methods,
Sipos.integral-methods,
Sugeno.integral-methods,
zeta-methods,
expect.Choquet.norm-methods.
## a game (which is a capacity) mu <- game(c(0,rep(1,15))) ## and its Mobius representation a <- Mobius(mu) # the attributes of object a a@n a@k a@data a@subsets ## a transformation zeta(a) ## let us check ... Mobius(zeta(a)) ## integral calculations f <- c(0.2,0.3,0.1,0.7) Choquet.integral(a,f) Sugeno.integral(a,f) f <- c(0.2,-0.3,0.1,-0.7) Sipos.integral(a,f)## a game (which is a capacity) mu <- game(c(0,rep(1,15))) ## and its Mobius representation a <- Mobius(mu) # the attributes of object a a@n a@k a@data a@subsets ## a transformation zeta(a) ## let us check ... Mobius(zeta(a)) ## integral calculations f <- c(0.2,0.3,0.1,0.7) Choquet.integral(a,f) Sugeno.integral(a,f) f <- c(0.2,-0.3,0.1,-0.7) Sipos.integral(a,f)
These functions create objects of class
Mobius.set.func, Mobius.game, or Mobius.capacity from an object of class numeric.
Mobius.set.func(object, n, k) Mobius.game(object, n, k) Mobius.capacity(object, n, k) additive.capacity(v)Mobius.set.func(object, n, k) Mobius.game(object, n, k) Mobius.capacity(object, n, k) additive.capacity(v)
n |
An object of class |
k |
An object of class |
object |
Object of class |
v |
An object of class |
Return objects of class Mobius.set.func, Mobius.game, or Mobius.capacity.
Mobius.capacity-class,
Mobius.game-class,
Mobius.set.func-class,
k.truncate.Mobius-methods.
Mobius.set.func(c(0,1,1,2,1,2,1,2,2,3,2),4,2) Mobius.game(c(0,1,1,2,1,2,1,2,2,3,2),4,2) Mobius.capacity(c(0,1,1,2,1,2,1,2,2,3,2),4,2) additive.capacity(c(1,2,3,4))Mobius.set.func(c(0,1,1,2,1,2,1,2,2,3,2),4,2) Mobius.game(c(0,1,1,2,1,2,1,2,2,3,2),4,2) Mobius.capacity(c(0,1,1,2,1,2,1,2,2,3,2),4,2) additive.capacity(c(1,2,3,4))
Class representing the Möbius transform of a set function.
Objects can be created by calls to the
function Mobius.set.func.
n:Object of class numeric of length 1 containing the
number of elements of the set on which the Möbius transform is
defined.
k:Object of class numeric of length 1 containg the order
of truncation of the Möbius transform: subsets whose cardinal is
superior to k are considered to be zero.
subsets:Object of class numeric containing
the "k power set" of the underlying
set in "natural" order . The subsets are encoded as integers.
data:Object of class numeric of length
choose(n,0) + ... + choose(n,k) representing the
coefficients of a truncated Möbius transform of a set function in "natural" order.
Class superclass.set.func, directly.
signature(object = "Mobius.set.func")
signature(object =
"Mobius.set.func")
signature(object =
"Mobius.set.func")
signature(object = "Mobius.set.func")
signature(object = "Mobius.set.func")
signature(object = "Mobius.set.func")
signature(object = "Mobius.set.func")
signature(object = "Mobius.set.func")
signature(object = "Mobius.set.func", k =
"numeric")
signature(object = "Mobius.set.func")
signature(object = "Mobius.set.func",
k = "numeric")
signature(object = "Mobius.set.func")
signature(object = "Mobius.set.func")
signature(object = "Mobius.set.func")
set.func-class,
Mobius.set.func,
as.Mobius.card.set.func-methods,
as.card.set.func-methods,
as.set.func-methods,
as.Mobius.game-methods,
as.Mobius.capacity-methods,
interaction.indices-methods,
is.cardinal-methods,
is.kadditive-methods,
is.monotone-methods,
k.truncate.Mobius-methods,
Shapley.value-methods,
to.data.frame-methods,
zeta-methods.
## the Mobius transform of a set function directly a <- Mobius.set.func(1:16,4,4) ## the attributes of the object a@n a@k a@data a@subsets ## a set function mu <- set.func(7:-8) ## and its Mobius transform a <- Mobius(mu) ## some conversions that cannot work ## as.game(a) ## as.capacity(a) ## as.card.set.func(a) ## some tests is.cardinal(a) is.kadditive(a,2) is.monotone(a) ## some transformations zeta(a) k.truncate.Mobius(a,2) ## summary Shapley.value(a) interaction.indices(a) # the same summary(a) ## save the Mobius transform to a file d <- to.data.frame(a) ## Not run: write.table(d,"my.Mobius.set.func.csv",sep="\t") # finally, some conversions that should work mu <- set.func(c(0,1,1,1,2,2,2,3)) a <- Mobius(mu) as.Mobius.game(a) as.Mobius.capacity(a) as.Mobius.card.set.func(a)## the Mobius transform of a set function directly a <- Mobius.set.func(1:16,4,4) ## the attributes of the object a@n a@k a@data a@subsets ## a set function mu <- set.func(7:-8) ## and its Mobius transform a <- Mobius(mu) ## some conversions that cannot work ## as.game(a) ## as.capacity(a) ## as.card.set.func(a) ## some tests is.cardinal(a) is.kadditive(a,2) is.monotone(a) ## some transformations zeta(a) k.truncate.Mobius(a,2) ## summary Shapley.value(a) interaction.indices(a) # the same summary(a) ## save the Mobius transform to a file d <- to.data.frame(a) ## Not run: write.table(d,"my.Mobius.set.func.csv",sep="\t") # finally, some conversions that should work mu <- set.func(c(0,1,1,1,2,2,2,3)) a <- Mobius(mu) as.Mobius.game(a) as.Mobius.capacity(a) as.Mobius.card.set.func(a)
Returns the normalized version of a capacity. The capacity
can be given either under the form of an object of class
capacity, card.capacity or Mobius.capacity. In
the case of objects of class capacity and card.capacity,
the normalization is performed by dividing each coefficient of the
capacity by the value of the capacity on the universe. In the case of
objects of class Mobius.capacity, the normalization is
performed by dividing each coefficient of the Möbius transform by the
sum of all the coefficients.
Returns an object of class Mobius.capacity.
Returns an object of class capacity.
Returns an object of class card.capacity.
capacity-class,
Mobius.capacity-class,
card.capacity-class,
Mobius-methods,
is.normalized-methods.
## a capacity mu <- capacity(0:15) ## normalize it is.normalized(mu) normalize(mu) ## a similar example with a Mobius.capacity object a <- Mobius(mu) is.normalized(a) normalize(a) zeta(normalize(a)) ## a similar example with a card.capacity object mu <- card.capacity(0:6) is.normalized(mu) normalize(mu) Mobius(normalize(mu))## a capacity mu <- capacity(0:15) ## normalize it is.normalized(mu) normalize(mu) ## a similar example with a Mobius.capacity object a <- Mobius(mu) is.normalized(a) normalize(a) zeta(normalize(a)) ## a similar example with a card.capacity object mu <- card.capacity(0:6) is.normalized(mu) normalize(mu) Mobius(normalize(mu))
Computes the orness degree of a Choquet integral from the
underlying normalized capacity. The capacity can be given either under the form
of an object of class capacity, card.capacity or
Mobius.capacity.
The orness degree is computed from the Möbius transform of a capacity.
The orness degree is computed directly from a capacity.
The orness degree is computed from a cardinal capacity.
J.-L. Marichal (2000), Behavioral analysis of aggregation in multicriteria decision aid, in Preferences and Decisions under Incomplete Knowledge, J. Fodor and B. De Baets and P. Perny Eds, Physica-Verlag, pages 153-178, 2000.
capacity-class,
Mobius.capacity-class,
card.capacity-class,
Mobius-methods.
## the upper capacity mu <- capacity(c(0,rep(1,15))) ## the Choquet integral w.r.t mu behaves like the maximum operator f <- c(0.1,0.1,0,0.9) Choquet.integral(mu,f) ## its orness is 1 orness(mu) ## the same example with a Mobius.capacity object a <- Mobius(mu) Choquet.integral(a,f) orness(a) ## the same example with a card.capacity object mu <- upper.capacity(4) Choquet.integral(mu,f) orness(mu)## the upper capacity mu <- capacity(c(0,rep(1,15))) ## the Choquet integral w.r.t mu behaves like the maximum operator f <- c(0.1,0.1,0,0.9) Choquet.integral(mu,f) ## its orness is 1 orness(mu) ## the same example with a Mobius.capacity object a <- Mobius(mu) Choquet.integral(a,f) orness(a) ## the same example with a card.capacity object mu <- upper.capacity(4) Choquet.integral(mu,f) orness(mu)
Methods for computing the probability density and cumulative distribution functions of the Choquet integral with respect to a game for evaluations uniformly distributed on the unit hypercube.
Returns the value of the
p.d.f. or the c.d.f. at y.
J-L. Marichal and I. Kojadinovic (2007), The distribution of linear combinations of lattice polynomials from the uniform distribution, submitted.
## a capacity mu <- capacity(c(0,0.1,0.6,rep(0.9,4),1)) ## the cdf of the Choquet integral at 0.7 cdf.Choquet.unif(mu,0.7) ## the same but empirically m <- 10000 ch <- numeric(m) for (i in 1:m) { f <- runif(3) ch[i] <- Choquet.integral(mu,f) } sum(ifelse(ch<=0.7,1,0))/m## a capacity mu <- capacity(c(0,0.1,0.6,rep(0.9,4),1)) ## the cdf of the Choquet integral at 0.7 cdf.Choquet.unif(mu,0.7) ## the same but empirically m <- 10000 ch <- numeric(m) for (i in 1:m) { f <- runif(3) ch[i] <- Choquet.integral(mu,f) } sum(ifelse(ch<=0.7,1,0))/m
Rounds the coefficients of a set function to the specified number of decimal places (default 0).
Returns an object of the same class as
x whose data attribute is rounded.
## a capacity mu <- capacity(0:15/15) mu rnd(mu,2) ## a similar example with a Mobius.capacity object a <- Mobius(mu) a rnd(a,1) ## a similar example with a card.capacity object mu <- uniform.capacity(6) mu rnd(mu)## a capacity mu <- capacity(0:15/15) mu rnd(mu,2) ## a similar example with a Mobius.capacity object a <- Mobius(mu) a rnd(a,1) ## a similar example with a card.capacity object mu <- uniform.capacity(6) mu rnd(mu)
These functions create objects of class set.func,
game, or capacity from objects of class numeric.
set.func(object) game(object) capacity(object)set.func(object) game(object) capacity(object)
object |
An object of class |
Return objects of class set.func, game, or capacity.
capacity-class,
game-class,
set.func-class.
set.func(-12:3) game(c(0,rep(-1,15))) capacity(0:15)set.func(-12:3) game(c(0,rep(-1,15))) capacity(0:15)
Class representing a set function.
Objects can be created by calls to the function set.func.
n:Object of class numeric of length 1 equal to
the number of elements of the set on which the set function is defined.
subsets:Object of class numeric of length
2^n containing the power set of the underlying set in
"natural" order. The subsets are coded as integers.
data:Object of class numeric of length
2^n containing the coefficients of the set function in binary order.
Class superclass.set.func, directly.
signature(object = "set.func")
signature(object = "set.func")
signature(object = "set.func")
signature(object = "set.func")
signature(object = "set.func")
signature(object = "set.func")
signature(object = "set.func")
signature(object = "set.func")
signature(object = "set.func")
signature(object = "set.func", k = "numeric")
signature(object = "set.func")
signature(object = "set.func", k =
"numeric")
signature(object = "set.func")
signature(object = "set.func")
signature(object = "set.func")
set.func,
as.game-methods,
as.capacity-methods,
as.card.set.func-methods,
as.Mobius.set.func-methods,
as.Mobius.card.set.func-methods,
conjugate-methods,
interaction.indices-methods,
is.cardinal-methods,
is.kadditive-methods,
is.monotone-methods,
k.truncate.Mobius-methods,
Mobius-methods,
Shapley.value-methods,
to.data.frame-methods.
## a set function mu <- set.func(c(1:8,8:1)/8) ## the attributes of the object mu@n mu@data mu@subsets ## some conversions that cannot work ## Not run: as.game(mu) ## Not run: as.capacity(mu) ## Not run: as.card.set.func(mu) ## some tests is.cardinal(mu) is.kadditive(mu,2) is.monotone(mu) ## some transformations conjugate(mu) Mobius(mu) k.truncate.Mobius(mu,2) ## summary Shapley.value(mu) interaction.indices(mu) # the same summary(mu) ## save the set function to a file d <- to.data.frame(mu) ## Not run: write.table(d,"my.set.func.csv",sep="\t") # finally, some conversions that should work mu <- set.func(c(0,1,1,1,2,2,2,3)) as.game(mu) as.capacity(mu) as.card.set.func(mu)## a set function mu <- set.func(c(1:8,8:1)/8) ## the attributes of the object mu@n mu@data mu@subsets ## some conversions that cannot work ## Not run: as.game(mu) ## Not run: as.capacity(mu) ## Not run: as.card.set.func(mu) ## some tests is.cardinal(mu) is.kadditive(mu,2) is.monotone(mu) ## some transformations conjugate(mu) Mobius(mu) k.truncate.Mobius(mu,2) ## summary Shapley.value(mu) interaction.indices(mu) # the same summary(mu) ## save the set function to a file d <- to.data.frame(mu) ## Not run: write.table(d,"my.set.func.csv",sep="\t") # finally, some conversions that should work mu <- set.func(c(0,1,1,1,2,2,2,3)) as.game(mu) as.capacity(mu) as.card.set.func(mu)
Computes the Shapley value (n indices) of a set
function. The set function can be given either under the form of an
object of class set.func, card.set.func or Mobius.set.func.
The Shapley value is computed from the Möbius transform of a set function.
The Shapley value is computed from a cardinal set function.
The Shapley value is computed from a general set function.
L.S. Shapley (1953), A value for n-person games,
Contributions to the theory of games, vol. 2, Annals of Mathematics
Studies, no. 28, pages 307-317, Princeton University Press, Princeton,
N. J. .
Mobius.set.func-class,
card.set.func-class,
set.func-class,
Mobius-methods.
## a set function mu <- set.func(c(0:13/13,1,1)) ## the Shapley value Shapley.value(mu) ## the efficiency property should be satisfied sum(Shapley.value(mu)) ## a similar example using a Mobius.set.func object a <- Mobius(mu) Shapley.value(a) ## a similar example using a card.set.func object mu <- upper.capacity(6) Shapley.value(mu) ## the efficiency property should be satisfied Shapley.value(mu)*6## a set function mu <- set.func(c(0:13/13,1,1)) ## the Shapley value Shapley.value(mu) ## the efficiency property should be satisfied sum(Shapley.value(mu)) ## a similar example using a Mobius.set.func object a <- Mobius(mu) Shapley.value(a) ## a similar example using a card.set.func object mu <- upper.capacity(6) Shapley.value(mu) ## the efficiency property should be satisfied Shapley.value(mu)*6
Displays the contents of an object.
Generic show method for superclass.set.func.
Displays a set.func object.
Displays a Mobius.set.func object.
Displays a summary.superclass.set.func object.
Displays a
summary.superclass.capacity object.
superclass.set.func-class,
set.func-class,
Mobius.set.func-class,
summary.superclass.set.func-class,
summary.superclass.capacity-class.
## a set function mu <- set.func(0:15/15) show(mu) ## the same mu ## a Mobius transform a <- Mobius.set.func(0:10,4,2) show(a) a ## a cardinal capacity mu <- lower.capacity(5) show(mu) mu## a set function mu <- set.func(0:15/15) show(mu) ## the same mu ## a Mobius transform a <- Mobius.set.func(0:10,4,2) show(a) a ## a cardinal capacity mu <- lower.capacity(5) show(mu) mu
Computes the Sipos integral (also called symmetric Choquet
integral) of a real-valued function with respect to a game. The game can be
given either under the form of an object of class game,
card.game or Mobius.game.
The Sipos or symmetric Choquet integral of f
is computed from a game.
The Sipos or symmetric Choquet integral of
f is computed from the Möbius transform of a game.
The Sipos or symmetric Choquet integral of
f is computed from a cardinal game.
M. Grabisch and Ch. Labreuche (2002), The symmetric and asymmetric Choquet integrals on finite spaces for decision making, Statistical Papers 43, pages 37-52.
game-class,
Mobius.game-class,
card.game-class.
## a normalized capacity mu <- capacity(c(0:13/13,1,1)) ## and its Mobius transform a <- Mobius(mu) ## a discrete function f f <- c(0.1,-0.9,-0.3,0.8) ## the Sugeno integral of f w.r.t mu Sipos.integral(mu,f) Sipos.integral(a,f) ## a similar example with a cardinal capacity mu <- uniform.capacity(4) Sipos.integral(mu,f)## a normalized capacity mu <- capacity(c(0:13/13,1,1)) ## and its Mobius transform a <- Mobius(mu) ## a discrete function f f <- c(0.1,-0.9,-0.3,0.8) ## the Sugeno integral of f w.r.t mu Sipos.integral(mu,f) Sipos.integral(a,f) ## a similar example with a cardinal capacity mu <- uniform.capacity(4) Sipos.integral(mu,f)
Computes the Sugeno integral of a non negative function with
respect to a game. Moreover, if the game is a capacity, the range of the function must be contained into
the range of the capacity. The game can be given either under the form of an
object of class game, card.game or Mobius.game.
The Sugeno integral of
f is computed from the Möbius transform of a game.
The Sugeno integral of f
is computed from a game.
The Sugeno integral of
f is computed from a cardinal game.
M. Sugeno (1974), Theory of fuzzy integrals and its applications, Tokyo Institute of Technology, Tokyo, Japan.
J-L. Marichal (2000), On Sugeno integral as an aggregation function, Fuzzy Sets and Systems 114, pages 347-365.
J-L. Marichal (2001), An axiomatic approach of the discrete Sugeno integral as a tool to aggregate interacting criteria in a qualitative framework, IEEE Transactions on Fuzzy Systems 9:1, pages 164-172.
T. Murofushi and M. Sugeno (2000), Fuzzy measures and fuzzy integrals, in: M. Grabisch, T. Murofushi, and M. Sugeno Eds, Fuzzy Measures and Integrals: Theory and Applications, Physica-Verlag, pages 3-41.
game-class,
Mobius.game-class,
card.game-class.
## a normalized capacity mu <- capacity(c(0:13/13,1,1)) ## and its Mobius transform a <- Mobius(mu) ## a discrete function f f <- c(0.1,0.9,0.3,0.8) ## the Sugeno integral of f w.r.t mu Sugeno.integral(mu,f) Sugeno.integral(a,f) ## a similar example with a cardinal capacity mu <- uniform.capacity(4) Sugeno.integral(mu,f)## a normalized capacity mu <- capacity(c(0:13/13,1,1)) ## and its Mobius transform a <- Mobius(mu) ## a discrete function f f <- c(0.1,0.9,0.3,0.8) ## the Sugeno integral of f w.r.t mu Sugeno.integral(mu,f) Sugeno.integral(a,f) ## a similar example with a cardinal capacity mu <- uniform.capacity(4) Sugeno.integral(mu,f)
Computes indices that can be used to summarize a set function.
Returns an object of class summary.superclass.capacity.
Returns an object of class summary.superclass.set.func.
summary.superclass.capacity-class,
summary.superclass.set.func-class.
Class containing most of the indices that can be used to summarize an object of class superclass.capacity.
Objects are created by calls of the form summary(...) on objects of class superclass.capacity.
Shapley.value:Object of class numeric containing the Shapley value of a set function.
interaction.indices:Object of class matrix containing the Shapley interaction indices of a set function.
orness:Object of class numeric containg the orness degree of the Choquet integral corresponding to the underlying capacity.
veto:Object of class numeric containing the veto indices of the Choquet integral corresponding to the underlying capacity.
favor:Object of class numeric containing the favor indices of the Choquet integral corresponding to the underlying capacity.
variance:Object of class numeric containing the variance of the underlying capacity.
entropy:Object of class numeric containing the variance of the underlying capacity.
signature(object = "summary.superclass.capacity"): ...
superclass.capacity-class, summary-methods,
Shapley.value-methods, interaction.indices-methods,
orness-methods, veto-methods,
favor-methods, variance-methods,
entropy-methods.
## a capacity mu <- capacity(c(0:13,13,13)/13) a <- Mobius(mu) ## its summary summary(mu) summary(a)## a capacity mu <- capacity(c(0:13,13,13)/13) a <- Mobius(mu) ## its summary summary(mu) summary(a)
Class containing most of the indices that can be used to summarize an object of class superclass.set.func and not of class superclass.capacity.
Objects are created by calls of the form summary(...) on objects of class superclass.set.func and not of class superclass.capacity.
Shapley.value:Object of class numeric containing the Shapley value of a set function.
interaction.indices:Object of class matrix containing the Shapley interaction indices of a set function.
signature(object = "summary.superclass.set.func")
superclass.set.func-class, superclass.capacity-class,
summary-methods,
show-methods, Shapley.value-methods,
interaction.indices-methods.
## a capacity mu <- set.func(c(0:13,13,13)/13) a <- Mobius(mu) ## its summary summary(mu) summary(a)## a capacity mu <- set.func(c(0:13,13,13)/13) a <- Mobius(mu) ## its summary summary(mu) summary(a)
Virtual class, superclass of all *.capacity classes. Used to define a common summary method for *.capacity classes. Contains no slots.
A virtual Class: No objects may be created from it.
signature(object = "superclass.capacity")
summary-methods,
capacity-class, Mobius.capacity-class,
card.capacity-class.
## three capacities mu1 <- uniform.capacity(5) mu2 <- capacity(c(0,0,0:13)) a <- Mobius(mu2) ## compute indices to summarize them summary(mu1) summary(mu2) summary(a)## three capacities mu1 <- uniform.capacity(5) mu2 <- capacity(c(0,0,0:13)) a <- Mobius(mu2) ## compute indices to summarize them summary(mu1) summary(mu2) summary(a)
Virtual class, superclass of all *.set.func classes. Used to define common show and summary methods for *.set.func classes.
A virtual Class: No objects may be created from it.
n:Object of class numeric of length 1 equal
to the number of elements of the set on which the
set function is defined.
data:Object of class numeric containing the
coefficients of the set function.
signature(object = "superclass.set.func")
signature(x = "superclass.set.func", digits = "numeric")
signature(object = "superclass.set.func")
show-methods,
rnd-methods,
summary-methods,
set.func-class,
Mobius.set.func-class,
card.set.func-class,
Mobius.card.set.func-class.
## three set functions mu1 <- card.set.func(-2:4) mu2 <- set.func(c(-2,-2,-2:11/11)) mu3 <- Mobius.set.func(c(-7:6,6,6),4,4) ## print mu1 show(mu1) ## the same mu1 ## the others mu2 mu3 ## round mu2 rnd(mu2,2) ## compute indices to summarize them summary(mu1) summary(mu2) summary(mu3)## three set functions mu1 <- card.set.func(-2:4) mu2 <- set.func(c(-2,-2,-2:11/11)) mu3 <- Mobius.set.func(c(-7:6,6,6),4,4) ## print mu1 show(mu1) ## the same mu1 ## the others mu2 mu3 ## round mu2 rnd(mu2,2) ## compute indices to summarize them summary(mu1) summary(mu2) summary(mu3)
Puts a set function under the form of a
data.frame. This function can be used to write a set function to a
file.
Returns a data.frame.
Returns a data.frame.
Returns a data.frame.
Returns a data.frame.
## the Mobius representation of set function a <- Mobius.set.func(-1:-16,4,4) ## to data.frame d <- to.data.frame(a) ## Not run: write.table(d,"my.set.func.csv",sep="\t")## the Mobius representation of set function a <- Mobius.set.func(-1:-16,4,4) ## to data.frame d <- to.data.frame(a) ## Not run: write.table(d,"my.set.func.csv",sep="\t")
Computes the normalized variance of a capacity. The
capacity can be given either under the form of an object of class capacity, a card.capacity or Mobius.capacity.
The normalized variance is computed from the Möbius transform of a capacity.
The normalized variance is computed directly from a capacity.
The normalized variance is computed from a cardinal capacity.
I. Kojadinovic (2005), Minimum variance capacity identification, European Journal of Operational Research, in press.
capacity-class, Mobius.capacity-class,
card.capacity-class, Mobius-methods.
## a capacity mu <- capacity(c(0,0,0,0:12)/12) ## its Mobius transform a <- Mobius(mu) ## their normalized variance variance(mu) variance(a) ## similar examples with card.capacity objects mu <- lower.capacity(4) variance(mu) mu <- uniform.capacity(4) variance(mu)## a capacity mu <- capacity(c(0,0,0,0:12)/12) ## its Mobius transform a <- Mobius(mu) ## their normalized variance variance(mu) variance(a) ## similar examples with card.capacity objects mu <- lower.capacity(4) variance(mu) mu <- uniform.capacity(4) variance(mu)
Computes the veto indices of a Choquet integral from the
underlying normalized capacity. The capacity can be given either under the form
of an object of class capacity, card.capacity or Mobius.capacity.
The veto indices are computed from the Möbius transform of a capacity.
The veto indices are computed directly from a capacity.
The veto indices are computed from a cardinal capacity.
J.-L. Marichal (2000), Behavioral analysis of aggregation in multicriteria decision aid, in: Preferences and Decisions under Incomplete Knowledge, J. Fodor and B. De Baets and P. Perny Eds, Physica-Verlag, pages 153-178.
J.-L. Marichal (2004), Tolerant or intolerant character of interacting criteria in aggregation by the Choquet integral, European Journal of Operational Research 155:3, pages 771-791.
capacity-class, Mobius.capacity-class,
card.capacity-class, Mobius-methods.
## a capacity mu <- capacity(c(0:13,13,13)/13) ## its Mobius transform a <- Mobius(mu) ## their veto indices veto(mu) veto(a) ## the same with a card.capacity object mu <- lower.capacity(4) veto(mu)## a capacity mu <- capacity(c(0:13,13,13)/13) ## its Mobius transform a <- Mobius(mu) ## their veto indices veto(mu) veto(a) ## the same with a card.capacity object mu <- lower.capacity(4) veto(mu)
Computes the zeta transform of a set function given under the form of its Möbius transform. The zeta transform is the inverse of the Möbius transform.
Returns an object of class capacity.
Returns an object of class card.set.func.
Returns an object of class game.
Returns an object of class set.func.
G-C. Rota (1964), On the foundations of combinatorial theory. I. Theory of Möbius functions, Z. Wahrscheinlichkeitstheorie und Verw. Gebiete 2, pages 340-368.
A. Chateauneuf and J-Y. Jaffray (1989), Some characterizations of lower probabilities and other monotone capacities through the use of Möbius inversion, Mathematical Social Sciences 17, pages 263-283.
M. Grabisch, J-L. Marichal and M. Roubens (2000), Equivalent representations of set functions, Mathematics of Operations Research 25:2, pages 157-178.
capacity-class,
card.set.func-class,
game-class,
set.func-class,
Mobius.capacity-class,
Mobius.card.set.func-class,
Mobius.game-class,
Mobius.set.func-class,
Mobius-methods.
## the Mobius transform of a capacity a <- Mobius.capacity(c(rep(0,15),1),4,4) a ## its zeta transform zeta(a) ## let us check Mobius(zeta(a)) ## a similar example with a Mobius.card.set.func object mu <- card.set.func(-3:4) a <- Mobius(mu) zeta(a)## the Mobius transform of a capacity a <- Mobius.capacity(c(rep(0,15),1),4,4) a ## its zeta transform zeta(a) ## let us check Mobius(zeta(a)) ## a similar example with a Mobius.card.set.func object mu <- card.set.func(-3:4) a <- Mobius(mu) zeta(a)