SFL: Optimization using Shuffled Frog Leaping Algorithm
In metaheuristicOpt: Metaheuristic for Optimization

Description Usage Arguments Details Value References See Also Examples

This is the internal function that implements Shuffled Frog Leaping Algorithm. It is used to solve continuous optimization tasks. Users do not need to call it directly, but just use metaOpt.

1
2
3

SFL(FUN, optimType = "MIN", numVar, numPopulation = 40,
  maxIter = 500, rangeVar, numMemeplex = as.integer(numPopulation/3),
  frogLeapingIteration = as.integer(10))

`FUN`	an objective function or cost function,
`optimType`	a string value that represent the type of optimization. There are two option for this arguments: `"MIN"` and `"MAX"`. The default value is `"MIN"`, which the function will do minimization. Otherwise, you can use `"MAX"` for maximization problem. The default value is `"MIN"`.
`numVar`	a positive integer to determine the number variables.
`numPopulation`	a positive integer to determine the number populations. The default value is 40.
`maxIter`	a positive integer to determine the maximum number of iterations. The default value is 500.
`rangeVar`	a matrix (2 \times n) containing the range of variables, where n is the number of variables, and first and second rows are the lower bound (minimum) and upper bound (maximum) values, respectively. If all variable have equal upper bound, you can define `rangeVar` as matrix (2 \times 1).
`numMemeplex`	a positive integer (as.integer()) between 0 and numVar to determine number of memeplexes (see details). The default value is `as.integer(numPopulation/3)`.
`frogLeapingIteration`	a positive integer (as.integer()) to determine number of iterations for each memeplex. The default value is `as.integer(10)`.

This algorithm was proposed by (Eusuff, Lansey & Pasha, 2006). The main inspiration for SFL algorithm originates from how swarm of frogs finding foods.

In order to find the optimal solution, the algorithm follow the following steps.

initialize population randomly.
separate population into "numMemeplex" memeplexes.
update worst candidate solution using best candidate solution on each memeplex as much as "frogLeaping Iteration".
Shuffled back each memeplexes into population.
Sort population based on fitness.
If a termination criterion (a maximum number of iterations or a sufficiently good fitness) is met, exit the loop, else back to separate population into memeplexes.

Vector [v1, v2, ..., vn] where n is number variable and vn is value of n-th variable.

Eusuff, M., Lansey, K., & Pasha, F. (2006). Shuffled frog-leaping algorithm: a memetic meta-heuristic for discrete optimization. Engineering Optimization, 38(2), 129–154.

metaOpt

##################################
## Optimizing the quartic with noise function

# define Quartic with noise function as objective function
quartic <- function(x){
    dim <- length(x)
    result <- sum(c(1:dim)*(x^4))+runif(1)
    return(result)
}

## Define parameter
numVar <- 5
rangeVar <- matrix(c(-1.28, 1.28), nrow=2)

## calculate the optimum solution shuffled frog leaping algorithm
resultSFL <- SFL(quartic, optimType="MIN", numVar, numPopulation=20,
                 maxIter=100, rangeVar)

## calculate the optimum value using quartic with noise function
optimum.value <- quartic(resultSFL)