Review Questions and Exercises

1. Maxima and minima for a function of several variables

   For a function of several variables, such as the probable value, at any given time, of a financial investment portfolio of many stocks, bonds, and so on, the value of the portfolio at any given time is, therefore, a function of many variables. Mathematically, the value of this portfolio may be expressed as a function of future time. With respect to this portfolio value,

   1. Describe mathematically, what is meant by its
      1. local maximum and local minimum
      2. global maximum and global minimum of the portfolio function.
   2. How may each of these values be determined?
2. Optimization methodologies in probabilistic calculus for financial engineering

   This subject encompasses a very wide field of applied mathematics – as different approaches may measure risks that may not be robust, other measures include the CVAR (conditional value at risk). Other approaches often consider portfolio optimization in two stages: optimizing weights of asset classes to hold and optimizing weights of assets within the same asset class. An example of the former would be selecting the proportions in bonds versus stocks, while an example of the latter would be choosing the proportions of the stock subportfolio placed in stocks A, B, C,…, Z. Bonds and shares have different financial characteristics. These important differences call for diversification of optimization approaches for different classes of investments. With this introduction in mind, write an outline to form a practical optimization methodology for a portfolio which is invested in the following portfolio that consists of each of the following assets:

   1. Cash (including cash loans from financial institutions)
   2. Termed fixed interest deposits
   3. Portfolio of mixed equities of stocks and high-yield corporate bonds in the United States
   4. Same as (3), but with extensions to overseas financial products
   5. Private companies in the construction of retirement homes for special markets, such as the retiring “Baby Boomers”
   6. Cash income producing real estates: private and commercial
   7. Noncash income producing real estates: private and commercial
   8. Commodities and precious metals
   9. Collectibles
   10. American, European, and Asian options
3. The following paper, available on the Internet, provides a number of models for global optimization:
   1. The standard Markowitz model
   2. A model with risk-free asset (Tobin model)
   3. A multiobjective model for portfolio optimization
   4. A model based on Minkowski absolute metric of risk estimation
   5. A model based on Minkowski semiabsolute metric of risk estimation
   6. A model based on Chebyshev metric of risk estimation (maxmin and minimax models)
   7. The Sharpe model with fractional criteria
   8. Linear models of returns
   9. A model with limited number assets (cardinality constrained)
   10. A model with buy-in thresholds
   11. Models with transaction costs
   12. Models with integral (lot) assets
   13. Models with submodular constraints of diversification of risks
   14. Models using fuzzy expected return

   Study the following paper on this survey – available at

   http://www.math.uni-magdeburg.de/∼girlich/preprints/preprint0906.pdf

   Consider other available survey papers on this subject, and comment on your findings.

   Some further remarks on optimization methodologies in probabilistic calculus for financial engineering are as follows:

   1. The package PortfolioAnalytics provides a numerical solution of the portfolio with complex constraints and objective functions.
   2. Following that, the numerical optimization may then be performed either with the differential evolution optimizer in the package DEoptim or randomly.
   3. Carefully study the next two examples selected from the CRAN package: Portfolio Optimization Using the CRAN Package and Portfolio Optimization Using the CRAN Packages

Portfolio Optimization Using the CRAN Package PortfolioAnalytics: ac.ranking for Portfolio Optimization with Asset Ranking

The following is a description of this CRAN package: PortfolioAnalytics: Portfolio Analysis, Including Numerical Methods for Optimization of Portfolios

Portfolio optimization and analysis routines and graphics.

Downloads:

Within this CRAN package, consider the following function program: ac.ranking. This function computes the estimated centroid vector from a single complete sort using the analytical approximation as described in Almgren and Chriss, “Portfolios from Sorts”. The centroid is estimated and then scaled such that it is on a scale similar to the asset returns. By default, the centroid vector is scaled according to the median of the asset mean returns.

This program is described further:

ac.ranking                  Asset Ranking

Description

Compute the first moment from a single complete sort.

Usage

ac.ranking(R, order, ...)

Arguments

R            xts object of asset returns
order    a vector of indexes of the relative ranking of expected asset returns in ascending order.  For example, order = c(2, 3, 1, 4) means that the expected returns of R[,2] < R[,3], < R[,1] < R[,4].
...         any other passthrough parameters

Details

This function computes the estimated centroid vector from a single complete sort using the analytical approximation as described in Almgren and Chriss, Portfolios from Sorts. The centroid is estimated and then scaled such that it is on a scale similar to the asset returns. By default, the centroid vector is scaled according to the median of the asset mean returns.

Value

The estimated first moments based on ranking views

See Also

centroid.complete.mc centroid.sectors centroid.sign centroid.buckets

Examples

**
data(edhec)
R <- edhec[,1:4]
ac.ranking(R, c(2, 3, 1, 4))
#
data(edhec)
R <- edhec[,1:10]
ac.ranking(R,  c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))

Portfolio Optimization Using the CRAN Packages DEoptim:DEoptim-methods for Portfolio Optimization Using the DEoptim Approach

1. DEoptim: Global optimization by differential evolution
2. DEoptim-methods: DEoptim-methods

A) DEoptim: Global optimization by differential evolution

This introduction to the R package DEoptim is an abbreviated version of the manuscript published in the Journal of Statistical Software. DEoptim implements the Differential Evolution algorithm for global optimization of a real-valued function of a real-valued parameter vector. The implementation of differential evolution in DEoptim interfaces with C code for efficiency. Moreover, the package is self-contained and does not depend on any other packages.

Implements the differential evolution algorithm for global optimization of a real-valued function of a real-valued parameter vector.

Downloads:

Reverse Dependencies:

Examples from CRAN:

Use the following two examples, in R, to illustrate the use of the aforementioned approach in portfolio optimization:

DEoptim    Differential Evolution Optimization

Description

Performs evolutionary global optimization via the differential evolution algorithm.

Usage

DEoptim(fn, lower, upper, control = DEoptim.control(), ...,            
                                                    fnMap=NULL)

Arguments

fn                       the function to be optimized (minimized). The function should have as its first argument the vector of real-valued parameters to optimize, and return a scalar real result. NA and NaN values are not allowed.
lower, upper   two vectors specifying scalar real lower and upper bounds on each parameter to be optimized, so that the i-th element of lower and upper applies to the ith parameter.  The implementation searches between lower and upper for the global optimum (minimum) of fn.
control            a list of control parameters; see DEoptim.control.
fnMap                an optional function that will be run after each population is created, but before the population is passed to the objective function. This allows the user to impose integer/cardinality constriants.
...                     further arguments to be passed to fn.

Details

DEoptim performs optimization (minimization) of fn.

The control argument is a list; see the help file for DEoptim.control for details.

The R implementation of DE, DEoptim, was first published on the Comprehensive R Archive Network (CRAN) in 2005 by David Ardia. Early versions were written in pure R. Since version 2.0-0 (published on CRAN in 2009), the package has relied on an interface to a C implementation of DE, which is significantly faster on most problems as compared to the implementation in pure R. The C interface is in many respects similar to the MS Visual C++ v5.0 implementation of the differential evolution algorithm distributed with the book Differential Evolution – A Practical Approach to Global Optimization by Price et al. and found online at http://www1.icsi.berkeley.edu/∼storn/code.html. Since version 2.0-3, the C implementation dynamically allocates the memory required to store the population, removing limitations on the number of members in the population and length of the parameter vectors that may be optimized. Since version 2.2-0, the package allows for parallel operation, so that the evaluations of the objective function may be performed using all available cores. This is accomplished using either the built-in parallel package or the foreach package. If parallel operation is desired, the user should set parallelType and make sure that the arguments and packages needed by the objective function are available; see DEoptim.control, the example below and examples in the sandbox directory for details.

Since becoming publicly available, the package DEoptim has been used by several authors to solve optimization problems arising in diverse domains.

To perform a maximization (instead of minimization) of a given function, simply define a new function which is the opposite of the function to maximize and apply DEoptim to it.

To integrate additional constraints (other than box constraints) on the parameters x of fn(x), for instance x[1] + x[2]^2 < 2, integrate the constraint within the function to optimize, for instance:

fn <- function(x){
if (x[1] + x[2]^2 >= 2){
r <- Inf
else{
...
}
return(r)
}

This simplistic strategy usually does not work all that well for gradient-based or Newton-type methods. It is likely to be alright when the solution is in the interior of the feasible region, but when the solution is on the boundary, optimization algorithm would have a difficult time converging. Furthermore, when the solution is on the boundary, this strategy would make the algorithm converge to an inferior solution in the interior. However, for methods such as DE that are not gradient based, this strategy might not be that bad.

Note that DEoptim stops if any NA or NaN value is obtained. You have to redefine your function to handle these values (for instance, set NA to Inf in your objective function).

It is important to emphasize that the result of DEoptim is a random variable, that is, different results may be obtained when the algorithm is run repeatedly with the same settings. Hence, the user should set the random seed if they want to reproduce the results, for example, by setting set.seed(1234) before the call of DEoptim.

DEoptim relies on repeated evaluation of the objective function in order to move the population toward a global minimum. Users interested in making DEoptim run as fast as possible should consider using the package in parallel mode (so that all CPUs available are used), and also ensure that evaluation of the objective function is as efficient as possible (e.g., by using vectorization in pure R code, or writing parts of the objective function in a lower level language like C or Fortran).

Further details and examples of the R package DEoptim can be found in Mullen et al. (2011) and Ardia et al. (2011a, 2011b) or look at the package's vignette by typing vignette("DEoptim"). Also, an illustration of the package usage for a high-dimensional nonlinear portfolio optimization problem is available by typing vignette("DEoptimPortfolioOptimization").

Please cite the package in publications. Use citation("DEoptim").

Value

The output of the function DEoptim is a member of the S3 class DEoptim. More precisely, this is a list (of length 2) containing the following elements:

optim, a list containing the following elements:

• bestmem: the best set of parameters found.
• bestval: the value of fn corresponding to bestmem.
• nfeval: number of function evaluations.
• iter: number of procedure iterations.

member, a list containing the following elements:

• lower: the lower boundary.
• upper: the upper boundary.
• bestvalit: the best value of fn at each iteration.
• bestmemit: the best member at each iteration.
• pop: the population generated at the last iteration.
• storepop: a list containing the intermediate populations.

Members of the class DEoptim have a plot method that accepts the argument plot.type.

plot.type = "bestmemit" results in a plot of the parameter values that represent the lowest value of the objective function in each generation.

plot.type = "bestvalit" plots the best value of the objective function in each generation. Finally,

plot.type = "storepop" results in a plot of stored populations (which are only available if these have been saved by setting the control argument of DEoptim appropriately). Storing intermediate populations allows us to examine the progress of the optimization in detail. A summary method also exists and returns the best parameter vector, the best value of the objective function, the number of generations optimization ran, and the number of times the objective function was evaluated.

Note

DE is a search heuristic introduced by Storn and Price (1997). Its remarkable performance as a global optimization algorithm on continuous numerical minimization problems has been extensively explored. DE belongs to the class of genetic algorithms that use biology-inspired operations of crossover, mutation, and selection on a population in order to minimize an objective function over the course of successive generations. As with other evolutionary algorithms, DE solves optimization problems by evolving a population of candidate solutions using alteration and selection operators. DE uses floating-point instead of bit string encoding of population members, and arithmetic operations instead of logical operations in mutation. DE is particularly well suited to find the global optimum of a real-valued function of real-valued parameters, and does not require that the function be either continuous or differentiable.

Let NP denote the number of parameter vectors (members) x ∈ R^d in the population. In order to create the initial generation, NP guesses for the optimal value of the parameter vector are made, either using random values between lower and upper bounds (defined by the user) or using values given by the user. Each generation involves creation of a new population from the current population members {x_i | i = 1,…, NP}, where i indexes the vectors that make up the population. This is accomplished using differential mutation of the population members. An initial mutant parameter vector v_i is created by choosing three members of the population, x_r0, x_r1, and x_r2, at random. Then v_i is generated as

where F is the differential weighting factor, effective values for which are typically between 0 and 1. After the first mutation operation, mutation is continued until d mutations have been made, with a crossover probability CR ∈ [0, 1]. The crossover probability CR controls the fraction of the parameter values that are copied from the mutant. If an element of the trial parameter vector is found to violate the bounds after mutation and crossover, it is reset in such a way that the bounds are respected (with the specific protocol depending on the implementation). Then, the objective function values associated with the children are determined. If a trial vector has equal or lower objective function value than the previous vector, it replaces the previous vector in the population; otherwise the previous vector remains. Variations of this scheme have also been proposed.

Intuitively, the effect of the scheme is that the shape of the distribution of the population in the search space is converging with respect to size and direction toward areas with high fitness. The closer the population gets to the global optimum, the more the distribution will shrink and, therefore, reinforce the generation of smaller difference vectors.

As a general advice regarding the choice of NP, F, and CR, Storn et al. (2006) state the following:

Set the number of parents NP to 10 times the number of parameters, select differential weighting factor F = 0.8 and crossover constant CR = 0.9. Make sure that you initialize your parameter vectors by exploiting their full numerical range, that is, if a parameter is allowed to exhibit values in the range [−100, 100], it is a good idea to pick the initial values from this range instead of unnecessarily restricting diversity. If you experience misconvergence in the optimization process you usually have to increase the value for NP, but often you only have to adjust F to be a little lower or higher than 0.8. If you increase NP and simultaneously lower F a little, convergence is more likely to occur but generally takes longer, that is, DE is getting more robust (there is always a convergence speed/robustness trade-off).

DE is much more sensitive to the choice of F than it is to the choice of CR. CR is more like a fine tuning element. High values of CR, like CR = 1, give faster convergence if convergence occurs. Sometimes, however, you have to go down as much as CR = 0 to make DE robust enough for a particular problem. For more details on the DE strategy, we refer the reader to Storn and Price (1997) and Price et al. (2006).

Author(s)

David Ardia, Katharine Mullen <[email protected]>, Brian Peterson, and Joshua Ulrich.

See Also

DEoptim.control for control arguments, DEoptim-methods for methods on DEoptim objects, including some examples in plotting the results; optim or constrOptim for alternative optimization algorithms.

Examples

## Rosenbrock Banana function
## The function has a global minimum f(x)=0 at the point (1,1).
## Note that the vector of parameters to be optimized must be ## the first argument of the objective function passed to 
## DEoptim.
Rosenbrock <- function(x){

x1 <- x[1]
x2 <- x[2]
100 * (x2 - x1 * x1)^2 + (1 - x1)^2
}
## DEoptim searches for minima of the objective function 
## between lower and upper bounds on each parameter to be ## optimized. Therefore in the call to DEoptim we specify vectors ## that comprise the lower and upper bounds; these vectors are ## the same length as the parameter vector.
lower <- c(-10,-10)
upper <- -lower
## run DEoptim and set a seed first for replicability
set.seed(1234)
DEoptim(Rosenbrock, lower, upper)
## increase the population size
DEoptim(Rosenbrock, lower, upper, DEoptim.control(NP = 100))
## change other settings and store the output
outDEoptim <- DEoptim(Rosenbrock, lower, upper,   
                                    DEoptim.control(NP = 80,
                                     itermax = 400, F = 1.2, CR = 0.7))
## plot the output
plot(outDEoptim)
## 'Wild' function, global minimum at about -15.81515
Wild <- function(x)
10 * sin(0.3 * x) * sin(1.3 * x^2) +
    0.00001 * x^4 + 0.2 * x + 80
plot(Wild, -50, 50, n = 1000, main = "'Wild function'")
outDEoptim <- DEoptim(Wild, lower = -50, upper = 50,
                                control = DEoptim.control(trace = FALSE))
plot(outDEoptim)
DEoptim(Wild, lower = -50, upper = 50,
             control = DEoptim.control(NP = 50))
## The below examples shows how the call to DEoptim can be
## parallelized.
## Note that if your objective function requires packages to be
## loaded or has arguments supplied via code{...}, these 
## should be specified using the code{packages} and 
## code{parVar} arguments
## in control.
## Not run:
Genrose <- function(x) {
## One generalization of the Rosenbrock banana valley function ## (n parameters)
n <- length(x)
## make it take some time ...
Sys.sleep(.001)
1.0 + sum (100 * (x[-n]^2 - x[-1])^2 + (x[-1] - 1)^2)
}
# get some run-time on simple problems
maxIt <- 250
n <- 5
oneCore <- system.time( DEoptim(fn=Genrose, lower=rep(-25, n), upper=rep(25, n),
control=list(NP=10*n, itermax=maxIt)))
withParallel <- system.time( DEoptim(fn=Genrose, lower=rep(-25, n), upper=rep(25, n),
control=list(NP=10*n, itermax=maxIt, parallelType=1)))
## Compare timings
(oneCore)
(withParallel)
## End(Not run)

B) DEoptim-methods DEoptim-methods

Description

Methods for DEoptim objects.

Usage

## S3 method for class 'DEoptim'
summary(object, ...)
## S3 method for class 'DEoptim'
plot(x, plot.type = c("bestmemit", "bestvalit", "storepop"), ...)

Arguments

object        an object of class DEoptim; usually, a result of a call to DEoptim.
x                  an object of class DEoptim; usually, a result of a call to DEoptim.
plot.type  should we plot the best member at each iteration, the best value at each iteration or the intermediate populations?
...                further arguments passed to or from other methods.

Details

Members of the class DEoptim have a plot method that accepts the argument plot.type.
plot.type = "bestmemit" results in a plot of the parameter values that represent the lowest value of the objective function each generation.
plot.type = "bestvalit" plots the best value of the objective function each generation. Finally,
plot.type = "storepop" results in a plot of stored populations (which are only available if these have been saved by setting the control argument of DEoptim appropriately).  Storing intermediate populations allows us to examine the progress of the optimization in detail.  A summary method also exists and returns the best parameter vector, the best value of the objective function, the number of generations optimization ran, and the number of times the objective function was evaluated.

Note

Further details and examples of the R package DEoptim can be found in Mullen et al. (2011) and Ardia et al. (2011a, 2011b) or look at the package's vignette by typing vignette(“DEoptim”).

Please cite the package in publications. Use citation(“DEoptim”).

Author(s)

David Ardia, Katharine Mullen <[email protected]>, Brian Peterson, and Joshua Ulrich.

See Also

DEoptim and DEoptim.control.

Examples

## Rosenbrock Banana function
## The function has a global minimum f(x)=0 at the point (1,1).
## Note that the vector of parameters to be optimized must be ## the first argument of the objective function passed to 
## DEoptim.
Rosenbrock <- function(x){
x1 <- x[1]
x2 <- x[2]
100 * (x2 - x1 * x1)^2 + (1 - x1)^2
}
lower <- c(-10, -10)
upper <- -lower
set.seed(1234)
outDEoptim <- DEoptim(Rosenbrock, lower, upper)
## print output information
summary(outDEoptim)
## plot the best members
plot(outDEoptim, type = 'b')
## plot the best values
dev.new()
plot(outDEoptim, plot.type = "bestvalit", type = 'b', col = 'blue')
## rerun the optimization, and store intermediate populations
outDEoptim <- DEoptim(Rosenbrock, lower, upper,
DEoptim.control(itermax = 500,
storepopfrom = 1, storepopfreq = 2))
summary(outDEoptim)
## plot intermediate populations
dev.new()
plot(outDEoptim, plot.type = "storepop")
## Wild function
Wild <- function(x)
10 * sin(0.3 * x) * sin(1.3 * x^2) +
0.00001 * x^4 + 0.2 * x + 80
outDEoptim = DEoptim(Wild, lower = -50, upper = 50,
DEoptim.control(trace = FALSE, storepopfrom = 50,
storepopfreq = 1))
plot(outDEoptim, type = 'b')
dev.new()
plot(outDEoptim, plot.type = "bestvalit", type = 'b')
## Not run:
## an example with a normal mixture model: requires package ## mvtnorm
library(mvtnorm)
## neg value of the density function
negPdfMix <- function(x) {
tmp <- 0.5 * dmvnorm(x, c(-3, -3)) + 0.5 * dmvnorm(x, c(3, 3))
-tmp
}
## wrapper plotting function
plotNegPdfMix <- function(x1, x2)
negPdfMix(cbind(x1, x2))
## contour plot of the mixture
x1 <- x2 <- seq(from = -10.0, to = 10.0, by = 0.1)
thexlim <- theylim <- range(x1)
z <- outer(x1, x2, FUN = plotNegPdfMix)
contour(x1, x2, z, nlevel = 20, las = 1, col = rainbow(20),
xlim = thexlim, ylim = theylim)
set.seed(1234)
outDEoptim <- DEoptim(negPdfMix, c(-10, -10), c(10, 10),
   DEoptim.control(NP = 100, itermax = 100, storepopfrom = 1,
   storepopfreq = 5))
## convergence plot
dev.new()
plot(outDEoptim)
## the intermediate populations indicate the bi-modality of the ## function
dev.new()
plot(outDEoptim, plot.type = "storepop")
## End(Not run)

The CRAN Package PortfolioAnalytics

In the R domain:

> 
> install.packages("PortfolioAnalytics")
Installing package into ‘C:/Users/Bert/Documents/R/win-library/3.3’
(as ‘lib’ is unspecified)
--- Please select a CRAN mirror for use in this session ---

A CRAN mirror is selected.

also installing the dependencies ‘iterators’, ‘foreach’
> library(PortfolioAnalytics)
Attaching package: ‘PerformanceAnalytics’
>
> ls("package:PortfolioAnalytics")
 [1] "ac.ranking"                               	"add.constraint"                   
 [3] "add.objective"                           	"add.objective_v1"                 
 [5] "add.objective_v2"                      	"add.sub.portfolio"                
 [7] "applyFUN"                                 	"black.litterman"                  
 [9] "box_constraint" 	"CCCgarch.MM"                      
[11] "center"                                  	"centroid.buckets"                 
[13] "centroid.complete.mc"                	"centroid.sectors"                 
[15] "centroid.sign"                             	"chart.Concentration"              
[17] "chart.EF.Weights"                       	"chart.EfficientFrontier"          
[19] "chart.EfficientFrontierOverlay"	"chart.GroupWeights"               
[21] "chart.RiskBudget"                       	"chart.RiskReward"                 
[23] "chart.Weights"                           	"combine.optimizations"            
[25] "combine.portfolios"                     	"constrained_objective"            
[27] "constrained_objective_v1"          	"constrained_objective_v2"         
[29] "constraint"                                	"constraint_ROI"                   
[31] "create.EfficientFrontier"              	"diversification"                  
[33] "diversification_constraint"          	"EntropyProg"                      
[35] "equal.weight"                            	"extractCokurtosis"                
[37] "extractCoskewness"                   	"extractCovariance"                
[39] "extractEfficientFrontier"              	"extractGroups"                    
[41] "extractObjectiveMeasures"         	"extractStats"                     
[43] "extractWeights"                       	"factor_exposure_constraint"       
[45] "fn_map"                                  	"generatesequence"                 
[47] "group_constraint"                     	"HHI"                              
[49] "insert_objectives"                     	"inverse.volatility.weight"        
[51] "is.constraint"                            	"is.objective"                     
[53] "is.portfolio"                         	"leverage_exposure_constraint"     
[55] "meanetl.efficient.frontier"         	"meanvar.efficient.frontier"       
[57] "meucci.moments"                    	"meucci.ranking"                   
[59] "minmax_objective"                   	"mult.portfolio.spec"              
[61] "objective"                                	"optimize.portfolio"               
[63] "optimize.portfolio.parallel"  	 "optimize.portfolio.rebalancing"
[65] "optimize.portfolio.rebalancing_v1" "optimize.portfolio_v1"
[67] "optimize.portfolio_v2"              	"portfolio.spec"                   
[69] "portfolio_risk_objective"           	"pos_limit_fail"                   
[71] "position_limit_constraint"         	"quadratic_utility_objective"
[73] "random_portfolios"                  	"random_portfolios_v1"             
[75] "random_portfolios_v2"            	"random_walk_portfolios"           
[77] "randomize_portfolio"               	"randomize_portfolio_v1"           
[79] "randomize_portfolio_v2"          	"regime.portfolios"                
[81] "return_constraint"                   	"return_objective"                 
[83] "risk_budget_objective"            	"rp_grid"                          
[85] "rp_sample"                             	"rp_simplex"                       
[87] "rp_transform"                         	"scatterFUN"                       
[89] "set.portfolio.moments"            	"statistical.factor.model"         
[91] "trailingFUN"                            	"transaction_cost_constraint"      
[93] "turnover"                               	"turnover_constraint"              
[95] "turnover_objective"                	"update_constraint_v1tov2"         
[97] "var.portfolio"                    	"weight_concentration_objective"   
[99] "weight_sum_constraint"            
>
> ac.ranking
function (R, order, ...) 
{
    if (length(order) != ncol(R)) 
        stop("The length of the order vector must equal the number of assets")
    nassets <- ncol(R)
    if (hasArg(max.value)) {
        max.value <- match.call(expand.dots = TRUE)$max.value
    }
    else {
        max.value <- median(colMeans(R))
    }
    c_hat <- scale.range(centroid(nassets), max.value)
    out <- vector("numeric", nassets)
    out[rev(order)] <- c_hat
    return(out)
}
<environment: namespace:PortfolioAnalytics>
> 
> # Run 1
> data(edhec)
> R <- edhec[,1:4]
> ac.ranking(R, c(2, 3, 1, 4)) # Outputting:
[1]  0.01432457 -0.05000000 -0.01432457  0.05000000
>
> # Run 2
> data(edhec)
> R <- edhec[,1:10]
> ac.ranking(R, c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)) # Outputting:
 [1] -0.050000000 -0.032377611 -0.021216605 -0.012155458 -0.003968706
 [6]  0.003968706   0.012155458  0.021216605  0.032377611   0.050000000
>

The CRAN Package DEoptim Portfolio Optimization Using the CRAN Packages: DEoptim:DEoptim-methods for Portfolio Optimization using the DEoptim approach. DEoptim: Global Optimization by Differential Evolution

In the R domain:

> 
> install.packages("DEoptim")

Installing package into ‘C:/Users/Bert/Documents/R/win-library/3.3’
(as ‘lib’ is unspecified)
--- Please select a CRAN mirror for use in this session ---

A CRAN mirror is selected.

trying URL 'https://cran.ism.ac.jp/bin/windows/contrib/3.3/DEoptim_2.2-4.zip'
Content type 'application/zip' length 680535 bytes (664 KB)
downloaded 664 KB
package ‘DEoptim’ successfully unpacked and MD5 sums checked
The downloaded binary packages are in
C:UsersBertAppDataLocalTempRtmpkPO86Kdownloaded_packages
> library(DEoptim)
Loading required package: parallel
DEoptim package
Differential Evolution algorithm in R
Authors: D. Ardia, K. Mullen, B. Peterson and J. Ulrich
> ls("package:DEoptim")
[1] "DEoptim"         "DEoptim.control"
> DEoptim
function (fn, lower, upper, control = DEoptim.control(), ..., 
    fnMap = NULL) 
{
    if (length(lower) != length(upper)) 
        stop("'lower' and 'upper' are not of same length")
    if (!is.vector(lower)) 
        lower <- as.vector(lower)
    if (!is.vector(upper)) 
        upper <- as.vector(upper)
    if (any(lower > upper)) 
        stop("'lower' > 'upper'")
    if (any(lower == "Inf")) 
        warning("you set a component of 'lower' to 'Inf'. May imply 'NaN' results", 
            immediate. = TRUE)
    if (any(lower == "-Inf")) 
        warning("you set a component of 'lower' to '-Inf'. May imply 'NaN' results", 
            immediate. = TRUE)
    if (any(upper == "Inf")) 

        warning("you set a component of 'upper' to 'Inf'. May imply 'NaN' results", 
            immediate. = TRUE)
    if (any(upper == "-Inf")) 
        warning("you set a component of 'upper' to '-Inf'. May imply 'NaN' results", 
            immediate. = TRUE)
    if (!is.null(names(lower))) 
        nam <- names(lower)
    else if (!is.null(names(upper)) & is.null(names(lower))) 
        nam <- names(upper)
    else nam <- paste("par", 1:length(lower), sep = "")
    ctrl <- do.call(DEoptim.control, as.list(control))
    ctrl$npar <- length(lower)
    if (is.na(ctrl$NP)) 
        ctrl$NP <- 10 * length(lower)
    if (ctrl$NP < 4) {
        warning("'NP' < 4; set to default value 10*length(lower)
", 
            immediate. = TRUE)
        ctrl$NP <- 10 * length(lower)
    }
    if (ctrl$NP < 10 * length(lower)) 
        warning("For many problems it is best to set 'NP' (in 'control') to be at least ten times the length of the parameter vector. 
", 
            immediate. = TRUE)
    if (!is.null(ctrl$initialpop)) {
        ctrl$specinitialpop <- TRUE
        if (!identical(as.numeric(dim(ctrl$initialpop)), as.numeric(c(ctrl$NP, 
            ctrl$npar)))) 
            stop("Initial population is not a matrix with dim. NP x length(upper).")
    }
    else {
        ctrl$specinitialpop <- FALSE
        ctrl$initialpop <- 0
    }
    ctrl$trace <- as.numeric(ctrl$trace)
    ctrl$specinitialpop <- as.numeric(ctrl$specinitialpop)
    ctrl$initialpop <- as.numeric(ctrl$initialpop)
    if (!is.null(ctrl$cluster)) {
        if (!inherits(ctrl$cluster, "cluster")) 
            stop("cluster is not a 'cluster' class object")
        parallel::clusterExport(cl, ctrl$parVar)
        fnPop <- function(params, ...) {
            parallel::parApply(cl = ctrl$cluster, params, 1, 
                fn, ...)
        }
    }
    else if (ctrl$parallelType == 2) {
        if (!foreach::getDoParRegistered()) {
            foreach::registerDoSEQ()
        }
        args <- ctrl$foreachArgs
        fnPop <- function(params, ...) {
            my_chunksize <- ceiling(NROW(params)/foreach::getDoParWorkers())
            my_iter <- iterators::iter(params, by = "row", chunksize = my_chunksize)
            args$i <- my_iter
            args$.combine <- c
            if (!is.null(args$.export)) 
                args$.export = c(args$.export, "fn")
            else args$.export = "fn"
            if (is.null(args$.errorhandling)) 
                args$.errorhandling = c("stop", "remove", "pass")
            if (is.null(args$.verbose)) 
                args$.verbose = FALSE
            if (is.null(args$.inorder)) 
                args$.inorder = TRUE
            if (is.null(args$.multicombine)) 
                args$.multicombine = FALSE
            foreach::"%dopar%"(do.call(foreach::foreach, args), 
                apply(i, 1, fn, ...))
        }
    }
    else if (ctrl$parallelType == 1) {
        cl <- parallel::makeCluster(parallel::detectCores())
        packFn <- function(packages) {
            for (i in packages) library(i, character.only = TRUE)
        }
        parallel::clusterCall(cl, packFn, ctrl$packages)
        parallel::clusterExport(cl, ctrl$parVar)
        fnPop <- function(params, ...) {
            parallel::parApply(cl = cl, params, 1, fn, ...)<
        }
    }
    else {
        fnPop <- function(params, ...) {
            apply(params, 1, fn, ...)
        }
    }
    if (is.null(fnMap)) {
        fnMapC <- function(params, ...) params
    }
    else {
        fnMapC <- function(params, ...) {
            mappedPop <- t(apply(params, 1, fnMap))
            if (all(dim(mappedPop) != dim(params))) 
                stop("mapping function did not return an object with ", 
                  "dim NP x length(upper).")
            dups <- duplicated(mappedPop)
            np <- NCOL(mappedPop)
            tries <- 0
            while (tries < 5 && any(dups)) {
                nd <- sum(dups)
                newPop <- matrix(runif(nd * np), ncol = np)
                newPop <- rep(lower, each = nd) + newPop * rep(upper - 
                  lower, each = nd)
                mappedPop[dups,]  <- t(apply(newPop, 1, fnMap))
                dups <- duplicated(mappedPop)
                tries <- tries + 1
            }
            if (tries == 5) 
                warning("Could not remove ", sum(dups), " duplicates from the mapped ", 
                  "population in 5 tries. Evaluating population with duplicates.", 
                  call. = FALSE, immediate. = TRUE)
            storage.mode(mappedPop) <- "double"
            mappedPop
        }
    }
    outC <- .Call("DEoptimC", lower, upper, fnPop, ctrl, new.env(), 
        fnMapC, PACKAGE = "DEoptim")
    if (ctrl$parallelType == 1) 
        parallel::stopCluster(cl)

    if (length(outC$storepop) > 0) {
        nstorepop <- floor((outC$iter - ctrl$storepopfrom)/ctrl$storepopfreq)
        storepop <- list()
        cnt <- 1
        for (i in 1:nstorepop) {
            idx <- cnt:((cnt - 1) + (ctrl$NP * ctrl$npar))
            storepop[[i]] <- matrix(outC$storepop[idx], nrow = ctrl$NP, 
                ncol = ctrl$npar, byrow = TRUE)
            cnt <- cnt + (ctrl$NP * ctrl$npar)
            dimnames(storepop[[i]]) <- list(1:ctrl$NP, nam)
        }
    }
    else {
        storepop = NULL
    }
    names(outC$bestmem) <- nam
    iter <- max(1, as.numeric(outC$iter))
    names(lower) <- names(upper) <- nam
    bestmemit <- matrix(outC$bestmemit[1:(iter * ctrl$npar)], 
        nrow = iter, ncol = ctrl$npar, byrow = TRUE)
    dimnames(bestmemit) <- list(1:iter, nam)
    storepop <- as.list(storepop)
    outR <- list(optim = list(bestmem = outC$bestmem, bestval = outC$bestval, 
        nfeval = outC$nfeval, iter = outC$iter), member = list(lower = lower, 
        upper = upper, bestmemit = bestmemit, bestvalit = outC$bestvalit, 
        pop = t(outC$pop), storepop = storepop))
    attr(outR, "class") <- "DEoptim"
    return(outR)
}
<environment: namespace:DEoptim>
> ## Rosenbrock Banana function
> ## The function has a global minimum f(x) = 0 at the point 
+ ## (1,1).
> ## Note that the vector of parameters to be optimized must be 
> ## the first
> ## argument of the objective function passed to DEoptim.
> Rosenbrock <- function(x){
+ x1 <- x[1]
+ x2 <- x[2]
+ 100 * (x2 - x1 * x1)^2 + (1 - x1)^2
+ }
>  
> ## DEoptim searches for minima of the objective function 
> ## between
> ## lower and upper bounds on each parameter to be 
> ## optimized. Therefore
> ## in the call to DEoptim we specify vectors that comprise the
> ## lower and upper bounds; these vectors are the same length 
> ## as the
> ## parameter vector.
> lower <- c(-10,-10)
> upper <- -lower
>  
> ## run DEoptim and set a seed first for replicability
> set.seed(1234)
> DEoptim(Rosenbrock, lower, upper)
Iteration: 1 bestvalit: 231.182756 bestmemit:    2.298807    6.799427
Iteration: 2 bestvalit: 147.937835 bestmemit:   -2.864559    7.052430
Iteration: 3 bestvalit: 147.937835 bestmemit:   -2.864559    7.052430
………………………………
Iteration: 199 bestvalit: 0.000000 bestmemit:    1.000000    1.000000
Iteration: 200 bestvalit: 0.000000 bestmemit:    1.000000    1.000000
$optim
$optim$bestmem
par1 par2 
   1    1 
$optim$bestval
[1] 3.010666e-16
$optim$nfeval
[1] 402
$optim$iter
[1] 200
$member
$member$lower
par1 par2 
 -10  -10 
$member$upper
par1 par2 
  10   10 
$member$bestmemit
          par1       par2
1    2.8062121 6.21197105
2    2.2988072 6.79942674
3   -2.8645593 7.05243041
……………
199  1.0000000 0.99999997
200  1.0000000 0.99999997
$member$bestvalit
  [1] 2.797712e+02 2.311828e+02 1.479378e+02 1.479378e+02 1.297662e+01
  [6] 1.297662e+01 7.484302e+00 4.177053e+00 1.522458e+00 1.522458e+00
 [11] 1.522458e+00 1.522458e+00 1.505673e+00 1.505673e+00 1.505673e+00
………………………………
[191] 7.122327e-16 7.122327e-16 7.122327e-16 7.122327e-16 7.122327e-16
[196] 3.010666e-16 3.010666e-16 3.010666e-16 3.010666e-16 3.010666e-16
$member$pop
           [,1]            [,2]
 [1,]  1.0000000 1.0000001
 [2,]  1.0000000 0.9999999
 [3,]  1.0000000 0.9999999
 [4,]  1.0000000 1.0000000
 [5,] -1.6667868 2.8245124
 [6,]  1.0000001 1.0000001
 [7,]  1.0000001 1.0000002
 [8,]  1.0000000 1.0000001
 [9,]  1.0000000 1.0000000
[10,]  1.0000000 1.0000000
[11,]  1.0000000 1.0000000
[12,]  1.0000000 1.0000000
[13,]  1.0000000 1.0000000
[14,]  1.0000000 1.0000001
[15,]  1.0000000 1.0000000
[16,]  1.0000000 1.0000001
[17,]  1.0000000 1.0000001
[18,]  0.9999999 0.9999999
[19,]  1.0000000 1.0000000
[20,] -1.6708498 2.9124751
$member$storepop
list()
attr(,"class")
[1] "DEoptim"
> 
> 
> ## increase the population size
> DEoptim(Rosenbrock, lower, upper, DEoptim.control(NP = 100))
Iteration: 1 bestvalit: 0.831267 bestmemit:    0.993395    1.078004
Iteration: 2 bestvalit: 0.831267 bestmemit:    0.993395    1.078004
Iteration: 3 bestvalit: 0.136693 bestmemit:    1.238842    1.506507
……………………………. .
Iteration: 199 bestvalit: 0.000000 bestmemit:    1.000000    1.000000
Iteration: 200 bestvalit: 0.000000 bestmemit:    1.000000    1.000000
$optim
$optim$bestmem
par1 par2 
   1    1 
$optim$bestval
[1] 1.561559e-22
$optim$nfeval
[1] 402
$optim$iter
[1] 200
$member
$member$lower
par1 par2 
 -10  -10 
$member$upper
par1 par2 
  10   10 
$member$bestmemit
      par1               par2
1   -0.05055801 -0.3587592
2    0.99339454  1.0780042
3    0.99339454  1.0780042
……………………………
199  1.00000000  1.0000000
200  1.00000000  1.0000000
$member$bestvalit
  [1] 1.415855e+01 8.312672e-01 8.312672e-01 1.366929e-01 1.366929e-01
  [6] 1.366929e-01 1.366929e-01 1.366929e-01 1.366929e-01 5.009681e-02
……………………………
[196] 1.273210e-21 1.273210e-21 3.241491e-22 3.241491e-22 1.561559e-22

$member$pop
            [,1]     [,2]
  [1,]  1.000000 1.000000
  [2,]  1.000000 1.000000
  [3,]  1.000000 1.000000
  [4,]  1.000000 1.000000
  [5,]  1.000000 1.000000
 ……………………
[100,]  1.000000 1.000000
$member$storepop
list()
attr(,"class")
[1] "DEoptim"
> 
> 
> ## change other settings and store the output
> outDEoptim <- DEoptim(Rosenbrock, lower, upper, 
+ DEoptim.control(NP = 80,
+ itermax = 400, F = 1.2, CR = 0.7))
Iteration: 1 bestvalit: 3.635506 bestmemit:    1.317411    1.547563
Iteration: 2 bestvalit: 3.635506 bestmemit:    1.317411    1.547563
Iteration: 3 bestvalit: 3.635506 bestmemit:    1.317411    1.547563
Iteration: 4 bestvalit: 3.635506 bestmemit:    1.317411    1.547563
Iteration: 5 bestvalit: 3.635506 bestmemit:    1.317411    1.547563
……………………………. .
Iteration: 399 bestvalit: 0.000000 bestmemit:    1.000000    1.000000
Iteration: 400 bestvalit: 0.000000 bestmemit:    1.000000    1.000000
> 
> ## plot the output
> plot(outDEoptim)
> # Outputting: Figure 6.17

> 
> ## 'Wild' function, global minimum at about -15.81515
> Wild <- function(x)
+ 10 * sin(0.3 * x) * sin(1.3 * x^2) +
+ 0.00001 * x^4 + 0.2 * x + 80
> 
> plot(Wild, -50, 50, n = 1000, main = "'Wild function'")
> # Outputting: Figure 6.18

> 
> outDEoptim <- DEoptim(Wild, lower = -50, upper = 50,
+ control = DEoptim.control(trace = FALSE))
> plot(outDEoptim)
> # Outputting: Figure 6.19

> 
> DEoptim(Wild, lower = -50, upper = 50,
+ control = DEoptim.control(NP = 50))
Iteration: 1 bestvalit: 68.834199 bestmemit:  -15.802280
Iteration: 2 bestvalit: 68.834199 bestmemit:  -15.802280
Iteration: 3 bestvalit: 67.562828 bestmemit:  -15.509441
Iteration: 4 bestvalit: 67.562828 bestmemit:  -15.509441
Iteration: 5 bestvalit: 67.562828 bestmemit:  -15.509441
……………………………
Iteration: 199 bestvalit: 67.467735 bestmemit:  -15.815151
Iteration: 200 bestvalit: 67.467735 bestmemit:  -15.815151
$optim
$optim$bestmem
     par1 
-15.81515 
$optim$bestval
[1] 67.46773
$optim$nfeval
[1] 402
$optim$iter
[1] 200
$member
$member$lower
par1 
 -50 
$member$upper
par1 
  50 
$member$bestmemit
         par1
1   -25.66072
2   -15.80228
3   -15.80228
4   -15.50944
5   -15.50944
………………………….
199 -15.81515
200 -15.81515
$member$bestvalit
  [1] 69.34871 68.83420 68.83420 67.56283 67.56283 67.56283 67.48859 67.48859
……………………………
[193] 67.46773 67.46773 67.46773 67.46773 67.46773 67.46773 67.46773 67.46773
$member$pop
           [,1]
 [1,] -15.66161
 [2,] -15.66161
 [3,] -15.81515
……………………….
[49,] -15.66161
[50,] -15.66161
$member$storepop
list()
attr(,"class")
[1] "DEoptim"
> ## The below examples shows how the call to DEoptim can be
> ## parallelized.
> ## Note that if your objective function requires packages to be
> ## loaded or has arguments supplied via code{...}, these should be
> ## specified using the code{packages} and code{parVar} arguments
> ## in control.
> ## Not run:
> Genrose <- function(x) {
+ ## One generalization of the Rosenbrock banana valley function (n parameters)
+ n <- length(x)
+ ## make it take some time ...
+ Sys.sleep(.001)
+ 1.0 + sum (100 * (x[-n]^2 - x[-1])^2 + (x[-1] - 1)^2)
+ }
> 
> # get some run-time on simple problems
> maxIt <- 250
> n <- 5
> oneCore <- system.time( DEoptim(fn=Genrose, lower=rep(-
+ 25, n), upper=rep(25, n),
+ control=list(NP=10*n, itermax=maxIt)))
Iteration: 1 bestvalit: 67180.992768 bestmemit:    0.787009   -4.017866    4.091383   -2.065631   -7.987533
Iteration: 2 bestvalit: 67180.992768 bestmemit:    0.787009   -4.017866    4.091383   -2.065631   -7.987533
Iteration: 3 bestvalit: 67180.992768 bestmemit:    0.787009   -4.017866    4.091383   -2.065631   -7.987533
Iteration: 4 bestvalit: 67180.992768 bestmemit:    0.787009   -4.017866    4.091383   -2.065631   -7.987533
Iteration: 5 bestvalit: 42308.544031 bestmemit:    0.787009   -4.017866    0.493543   -2.065631   -7.987533
……………………………
Iteration: 249 bestvalit: 1.079131 bestmemit:   -1.005728    0.991545    0.993995    1.004214    1.004883
Iteration: 250 bestvalit: 1.079131 bestmemit:   -1.005728    0.991545    0.993995    1.004214    1.004883
> withParallel <- system.time( DEoptim(fn=Genrose, lower=rep(-
+ 25, n), upper=rep(25, n),
+ control=list(NP=10*n, itermax=maxIt, parallelType=1)))
Iteration: 1 bestvalit: 1036700.619060 bestmemit:    8.705266    3.108165   -7.886303   -3.630207   -7.869868
Iteration: 2 bestvalit: 540605.725273 bestmemit:    6.552843   -2.202845    6.752675    6.739165    2.361229
Iteration: 3 bestvalit: 134358.516530 bestmemit:   -0.173169    2.578942   -5.957804    1.230374    3.368074
Iteration: 4 bestvalit: 134358.516530 bestmemit:   -0.173169    2.578942   -5.957804    1.230374    3.368074
Iteration: 5 bestvalit: 40126.427537 bestmemit:    0.397502   -3.122870    1.249653    4.073320   -1.059661
Iteration: 6 bestvalit: 40126.427537 bestmemit:    0.397502   -3.122870    1.249653    4.073320   -1.059661
……………………………. .
Iteration: 249 bestvalit: 2.071510 bestmemit:    0.904367    0.836285    0.691696    0.466066    0.219700
Iteration: 250 bestvalit: 2.071510 bestmemit:    0.904367    0.836285    0.691696    0.466066    0.219700
> ## Compare timings
> (oneCore)
   user  system elapsed 
   0.00    0.00   12.58 
> (withParallel)
   user  system elapsed 
   0.42    0.21    5.86 
>