FOLP_Ordering: Solves a fuzzy objective linear programming problem using...

Description Usage Arguments Value References See Also Examples

Description

The goal is to solve a linear programming problem having Trapezoidal Fuzzy Numbers as coefficients in the objective function (f(x)=c1*x1+…+cn*xn).

Max f(x) or Min f(x)

s.t.: Ax<=b

FOLP.ordFun uses ordering functions to compare Fuzzy Numbers.

Usage

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
FOLP.ordFun(
  objective,
  A,
  dir,
  b,
  maximum = TRUE,
  ordf = c("Yager1", "Yager3", "Adamo", "Average", "Custom"),
  ...,
  FUN = NULL
)

Arguments

objective

A vector (c1, c2, ..., cn) of Trapezoidal Fuzzy Numbers with the objective function coefficients f(x)=c1*x1+…+cn*xn. Note that any of the coefficients may also be Real Numbers.

A

Technological matrix of Real Numbers.

dir

Vector of strings with the direction of the inequalities, of the same length as b. Each element of the vector must be one of "=", ">=", "<=", "<" or ">".

b

Vector with the right hand side of the constraints.

maximum

TRUE to maximize the objective function, FALSE to minimize the objective function.

ordf

Ordering function to be used, ordf must be one of "Yager1", "Yager3", "Adamo", "Average" or "Custom". The "Custom" option allows to use a custom linear ordering function that must be placed as FUN argument. If a non linear function is used the solution may not be optimal.

...

Additional parameters to the ordering function if needed.

  • Yager1 doesn't need any parameters.

  • Yager3 doesn't need any parameters.

  • Adamo needs a alpha parameter which must be in the interval [0,1].

  • Average needs two parameters, lambda must be in the interval [0,1] and t that must be greater than 0.

  • If Custom function needs parameters, put them here. Although not required, it is recommended to name the parameters.

FUN

Custom linear ordering function to be used if the value of ordf is "Custom". If any of the coefficients of the objective function are Real Numbers, the user must assure that the function FUN works well not only with Trapezoidal Fuzzy Numbers but also with Real Numbers.

Value

FOLP.ordFun returns the solution if the solver has found it or NULL if not.

References

Gonzalez, A. A studing of the ranking function approach through mean values. Fuzzy Sets and Systems, 35:29-41, 1990.

Cadenas, J.M. and Verdegay, J.L. Using Fuzzy Numbers in Linear Programming. IEEE Transactions on Systems, Man, and Cybernetics-Part B: Cybernetics, vol. 27, No. 6, December 1997.

Tanaka, H., Ichihashi, H. and Asai, F. A formulation of fuzzy linear programming problems based a comparison of fuzzy numbers. Control and Cybernetics, 13:185-194, 1984.

See Also

FOLP.multiObj, FOLP.interv, FOLP.strat, FOLP.posib

Examples

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
## maximize:   [0,2,3]*x1 + [1,3,4,5]*x2
## s.t.:         x1 + 3*x2 <= 6
##               x1 +   x2 <= 4
##               x1, x2 are non-negative real numbers

obj <- c(FuzzyNumbers::TrapezoidalFuzzyNumber(0,2,2,3), 
        FuzzyNumbers::TrapezoidalFuzzyNumber(1,3,4,5))
A<-matrix(c(1, 1, 3, 1), nrow = 2)
dir <- c("<=", "<=")
b <- c(6, 4)
max <- TRUE

FOLP.ordFun(obj, A, dir, b, maximum = max, ordf="Yager1")
FOLP.ordFun(obj, A, dir, b, maximum = max, ordf="Yager3")
FOLP.ordFun(obj, A, dir, b, maximum = max, ordf="Adamo", 0.5)
FOLP.ordFun(obj, A, dir, b, maximum = max, ordf="Average", lambda=0.8, t=3)

# Define a custom linear function
av <- function(tfn) {mean(FuzzyNumbers::core(tfn))}
FOLP.ordFun(obj, A, dir, b, maximum = max, ordf="Custom", FUN=av)

# Define a custom linear function
avp <- function(tfn, a) {a*mean(FuzzyNumbers::core(tfn))}
FOLP.ordFun(obj, A, dir, b, maximum = max, ordf="Custom", FUN=avp, a=2)

Example output

     x1 x2 objective
[1,] 3  1  ?        
     x1 x2 objective
[1,] 3  1  ?        
     x1 x2 objective
[1,] 3  1  ?        
     x1 x2 objective
[1,] 3  1  ?        
     x1 x2 objective
[1,] 3  1  ?        
     x1 x2 objective
[1,] 3  1  ?        

FuzzyLP documentation built on April 11, 2021, 5:06 p.m.