Description Usage Arguments Details Note Author(s) References See Also Examples

Functions that calculate effective style weights and display the results in a bar chart. `chart.Style`

calculates and displays style weights calculated over a single period. `chart.RollingStyle`

calculates and displays those weights in rolling windows through time. `style.fit`

manages the calculation of the weights by method. `style.QPfit`

calculates the specific constraint case that requires quadratic programming.

1 2 3 4 5 6 7 | ```
chart.Style(R.fund, R.style, method = c("constrained", "unconstrained", "normalized"), leverage = FALSE, main = NULL, ylim = NULL, unstacked=TRUE, ...)
chart.RollingStyle(R.fund, R.style, method = c("constrained","unconstrained","normalized"), leverage = FALSE, width = 12, main = NULL, space = 0, ...)
style.fit(R.fund, R.style, model=FALSE, method = c("constrained", "unconstrained", "normalized"), leverage = FALSE, selection = c("none", "AIC"), ...)
style.QPfit(R.fund, R.style, model = FALSE, leverage = FALSE, ...)
``` |

`R.fund` |
matrix, data frame, or zoo object with fund returns to be analyzed |

`R.style` |
matrix, data frame, or zoo object with style index returns. Data object must be of the same length and time-aligned with R.fund |

`method` |
specify the method of calculation of style weights as "constrained", "unconstrained", or "normalized". For more information, see |

`leverage` |
logical, defaults to 'FALSE'. If 'TRUE', the calculation of weights assumes that leverage may be used. For more information, see |

`model` |
logical. If 'model' = TRUE in |

`selection` |
either "none" (default) or "AIC". If "AIC", then the function uses a stepwise regression to identify find the model with minimum AIC value. See |

`unstacked` |
logical. If set to 'TRUE' |

`space` |
the amount of space (as a fraction of the average bar width) left before each bar, as in |

`main` |
set the chart title, same as in |

`width` |
number of periods or window to apply rolling style analysis over |

`ylim` |
set the y-axis limit, same as in |

`...` |
for the charting functions, these are arguments to be passed to |

These functions calculate style weights using an asset class style model as described in detail in Sharpe (1992). The use of quadratic programming to determine a fund's exposures to the changes in returns of major asset classes is usually refered to as "style analysis".

The "unconstrained" method implements a simple factor model for style analysis, as in:

*R_i = b_{i1}F_1+b_{i2}F_2+…+b_{in}F_n +e_i*

where *R_i* represents the return on asset i, *F_j* represents each factor, and *e_i* represents the "non-factor" component of the return on i. This is simply a multiple regression analysis with fund returns as the dependent variable and asset class returns as the independent variables. The resulting slope coefficients are then interpreted as the fund's historic exposures to asset class returns. In this case, coefficients do not sum to 1.

The "normalized" method reports the results of a multiple regression analysis similar to the first, but with one constraint: the coefficients are required to add to 1. Coefficients may be negative, indicating short exposures. To enforce the constraint, coefficients are normalized.

The "constrained" method includes the constraint that the coefficients sum to 1, but adds
that the coefficients must lie between 0 and 1. These inequality constraints require a
quadratic programming algorithm using `solve.QP`

from the 'quadprog' package,
and the implementation is discussed under `style.QPfit`

. If set to TRUE,
"leverage" allows the sum of the coefficients to exceed 1.

According to Sharpe (1992), the calculation for the constrained case is represented as:

*min σ(R_f - ∑{w_i * R_s_i}) = min σ(F - w*S)*

* s.t. ∑{w_i} = 1; w_i > 0*

Remembering that:

*σ(aX + bY) = a^2 σ(X) + b^2 σ(Y) + 2ab cov(X,Y) = σ(R.f) + w'*V*w - 2*w'*cov(R.f,R.s)*

we can drop *σ(R_f)* as it isn't a function of weights, multiply both sides by 1/2:

*= min (1/2) w'*V*w - C'w*

* s.t. w'*e = 1, w_i > 0*

Which allows us to use `solve.QP`

, which is specified as:

*min(-d' b + 1/2 b' D b)*

and the constraints

* A' b >= b_0 *

so: b is the weight vector, D is the variance-covariance matrix of the styles d is the covariance vector between the fund and the styles

The chart functions then provide a graphical summary of the results. The underlying
function, `style.fit`

, provides the outputs of the analysis and more
information about fit, including an R-squared value.

Styles identified in this analysis may be interpreted as an average of potentially
changing exposures over the period covered. The function `chart.RollingStyle`

may be useful for examining the behavior of a manager's average exposures to asset classes over time, using a rolling-window analysis.

The chart functions plot a column chart or stacked column chart of the resulting style weights to the current device. Both `style.fit`

and `style.QPfit`

produce a list of data frames containing 'weights' and 'R.squared' results. If 'model' = TRUE in `style.QPfit`

, the full result set is shown from the output of `solve.QP`

.

None of the functions `chart.Style`

, `style.fit`

, and `style.QPfit`

make any attempt to align the two input data series. The `chart.RollingStyle`

, on the other hand, does merge the two series and manages the calculation over common periods.

Peter Carl

Sharpe, W. Asset Allocation: Management Style and Performance Measurement Journal of Portfolio Management, 1992, 7-19. See http://www.stanford.edu/~wfsharpe/art/sa/sa.htm

1 2 3 4 5 | ```
data(edhec)
data(managers)
style.fit(managers[97:132,2,drop=FALSE],edhec[85:120,], method="constrained", leverage=FALSE)
chart.Style(managers[97:132,2,drop=FALSE],edhec[85:120,], method="constrained", leverage=FALSE, unstack=TRUE, las=3)
chart.RollingStyle(managers[,2,drop=FALSE],edhec[,1:11], method="constrained", leverage=FALSE, width=36, cex.legend = .7, colorset=rainbow12equal, las=1)
``` |

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.