PortfolioAnalytics

https://www.rdocumentation.org/packages/PortfolioAnalytics
Admin
PortfolioAnalytics is an R package for portfolio optimization and analysis that integrates CVXR...
Tokens:56,181
Snippets:461
Trust Score:9.8
Update:6 months ago
Show doc for...
Tokens:
Raw
### Example: Monthly Rebalancing with Rolling Window

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/optimize.portfolio.rebalancing

Illustrates monthly rebalancing with a 5-year training period and a 4-year rolling window using the 'ROI' optimization method. This example requires the 'edhec' dataset and pre-defined portfolio constraints.

```R
# Monthly rebalancing with 5 year training period and 4 year rolling window
bt.opt2 <- optimize.portfolio.rebalancing(R, portf,
optimize_method="ROI",
rebalance_on="months",
training_period=60,
rolling_window=48)
```

--------------------------------

### Example call of trailingFUN

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/trailingFUN

An example demonstrating how to call trailingFUN with a sequence of numbers and a mean function.

```R
trailingFUN(seq(1:100), weights=NULL, n=12, FUN='mean',FUNargs=list())
```

--------------------------------

### Add box constraints to portfolio specification

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/box_constraint

Examples demonstrating how to add box constraints to a portfolio specification using default, scalar, and per-asset values.

```R
data(edhec)
ret <- edhec[, 1:4]

pspec <- portfolio.spec(assets=colnames(ret))

# defaults to min=0 and max=1
pspec <- add.constraint(pspec, type="box")

# specify box constraints as a scalar
pspec <- add.constraint(pspec, type="box", min=0.05, max=0.45)

# specify box constraints per asset
pspec <- add.constraint(pspec, 
                        type="box", 
                        min=c(0.05, 0.10, 0.08, 0.06), 
                        max=c(0.45, 0.55, 0.35, 0.65))
```

--------------------------------

### Add turnover constraint to portfolio specification

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/turnover_constraint

Example demonstrating how to initialize a portfolio specification and add a turnover constraint using the add.constraint function.

```R
data(edhec)
ret <- edhec[, 1:4]

pspec <- portfolio.spec(assets=colnames(ret))

pspec <- add.constraint(portfolio=pspec, type="turnover", turnover_target=0.6)
```

--------------------------------

### Example: Quarterly Rebalancing with Training Period

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/optimize.portfolio.rebalancing

Demonstrates quarterly rebalancing with a 5-year training period using the 'ROI' optimization method. Ensure 'edhec' dataset is loaded and appropriate portfolio constraints are set.

```R
data(edhec)
R <- edhec[,1:4]
funds <- colnames(R)

portf <- portfolio.spec(funds)
portf <- add.constraint(portf, type="full_investment")
portf <- add.constraint(portf, type="long_only")
portf <- add.objective(portf, type="risk", name="StdDev")

# Quarterly rebalancing with 5 year training period
bt.opt1 <- optimize.portfolio.rebalancing(R, portf,
optimize_method="ROI",
rebalance_on="quarters",
training_period=60)
```

--------------------------------

### Apply group constraints to a portfolio

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/group_constraint

Examples demonstrating how to add group constraints to a portfolio specification, including single and multi-level grouping scenarios.

```R
data(edhec)
ret <- edhec[, 1:4]

pspec <- portfolio.spec(assets=colnames(ret))

# Assets 1 and 3 are groupA
# Assets 2 and 4 are groupB
pspec <- add.constraint(portfolio=pspec, 
                        type="group", 
                        groups=list(groupA=c(1, 3),
                                    groupB=c(2, 4)),
                        group_min=c(0.15, 0.25),
                        group_max=c(0.65, 0.55))

# 2 levels of grouping (e.g. by sector and geography)
pspec <- portfolio.spec(assets=5)
# Assets 1, 3, and 5 are Tech
# Assets 2 and 4 are Oil
# Assets 2, 4, and 5 are UK
# Assets 1 and are are US
group_list <- list(group1=c(1, 3, 5),
                   group2=c(2, 4),
                   groupA=c(2, 4, 5),
                   groupB=c(1, 3))

pspec <- add.constraint(portfolio=pspec, 
                        type="group", 
                        groups=group_list,
                        group_min=c(0.15, 0.25, 0.2, 0.1),
                        group_max=c(0.65, 0.55, 0.5, 0.4))
```

--------------------------------

### Adding Objectives to a Portfolio

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/add.objective

Examples demonstrating how to add various types of objectives like quadratic utility, mean, risk, and risk budget to a portfolio specification.

```R
data(edhec)
returns <- edhec[,1:4]
fund.names <- colnames(returns)
portf <- portfolio.spec(assets=fund.names)
# Add some basic constraints
portf <- add.constraint(portf, type="full_investment")
portf <- add.constraint(portf, type="long_only")

# Creates a new portfolio object using portf and adds a quadratic utility
# objective. This will add two objectives to the portfolio object; 1) mean and
# 2) var. The risk aversion parameter is commonly referred to as lambda in the
# quadratic utility formulation that controls how much the portfolio variance 
# is penalized.
portf.maxQU <- add.objective(portf, type="quadratic_utility", 
                             risk_aversion=0.25)

# Creates a new portfolio object using portf and adds mean as an objective
portf.maxMean <- add.objective(portf, type="return", name="mean")

# Creates a new portfolio object using portf and adds StdDev as an objective
portf.minStdDev <- add.objective(portf, type="risk", name="StdDev")

# Creates a new portfolio object using portf and adds ES as an objective. 
# Note that arguments to ES are passed in as a named list.
portf.minES <- add.objective(portf, type="risk", name="ES", 
                             arguments=list(p=0.925, clean="boudt"))

# Creates a new portfolio object using portf.minES and adds a risk budget 
# objective with limits on component risk contribution. 
# Note that arguments to ES are passed in as a named list.
portf.RiskBudgetES <- add.objective(portf.minES, type="risk_budget", name="ES", 
                             arguments=list(p=0.925, clean="boudt"),
                             min_prisk=0, max_prisk=0.6)

# Creates a new portfolio object using portf.minES and adds a risk budget 
# objective with equal component risk contribution. 
# Note that arguments to ES are passed in as a named list.
portf.EqRiskES <- add.objective(portf.minES, type="risk_budget", name="ES", 
                                    arguments=list(p=0.925, clean="boudt"),
                                    min_concentration=TRUE)

# Creates a new portfolio object using portf and adds a weight_concentration 
# objective. The conc_aversion parameter controls how much concentration is
# penalized. The portfolio concentration is defined as the Herfindahl Hirschman
# Index of the weights.
portf.conc <- add.objective(portf, type="weight_concentration", 
                            name="HHI", conc_aversion=0.01)
```

--------------------------------

### Add position limit constraints to a portfolio

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/position_limit_constraint

Examples of adding position limit constraints to a portfolio specification object.

```R
data(edhec)
ret <- edhec[, 1:4]

pspec <- portfolio.spec(assets=colnames(ret))

pspec <- add.constraint(portfolio=pspec, type="position_limit", max_pos=3)
pspec <- add.constraint(portfolio=pspec, type="position_limit", max_pos_long=3, max_pos_short=1)
```

--------------------------------

### Add Diversification Constraint to Portfolio

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/diversification_constraint

This example demonstrates how to add a diversification constraint to a portfolio specification. Ensure you have loaded the edhec dataset and defined a portfolio specification object.

```R
data(edhec)
ret <- edhec[, 1:4]

pspec <- portfolio.spec(assets=colnames(ret))

pspec <- add.constraint(portfolio=pspec, type="diversification", div_target=0.7)

```

--------------------------------

### Add Leverage Exposure Constraint to Portfolio Specification

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/leverage_exposure_constraint

This example demonstrates how to add a leverage exposure constraint to a portfolio specification using the add.constraint function. The leverage is set to 1.6, meaning the sum of the absolute values of the weights cannot exceed 1.6.

```R
data(edhec)
ret <- edhec[, 1:4]

pspec <- portfolio.spec(assets=colnames(ret))

pspec <- add.constraint(portfolio=pspec, type="leverage_exposure", leverage=1.6)

```

--------------------------------

### regime.portfolios

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/regime.portfolios

Constructs a regime.portfolios object to support regime switching optimization.

```APIDOC
## regime.portfolios

### Description
Construct a `regime.portfolios` object that contains a time series of regimes and portfolios corresponding to the regimes. This object is used to support regime switching optimization in `optimize.portfolio`.

### Usage
`regime.portfolios(regime, portfolios)`

### Arguments
- **regime** (xts or zoo object) - Required - Specifies the regime portfolios.
- **portfolios** (list) - Required - List of portfolios created by `combine.portfolios` with corresponding regimes.

### Value
A `regime.portfolios` object containing:
- **regime**: An xts object of the regime portfolio.
- **portfolios**: List of portfolios corresponding to the regime.
```

--------------------------------

### Initialize Portfolio Specification

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/portfolio.spec

Use portfolio.spec to create a portfolio object. Specify the assets by their column names from a data matrix or by the number of assets.

```R
data(edhec)
pspec <- portfolio.spec(assets=colnames(edhec))
```

```R
pspec <- portfolio.spec(assets=10, weight_seq=generatesequence())
```

--------------------------------

### Display opt.outputMvo function arguments

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/opt.outputMvo

Use this command to inspect the function signature and default arguments for opt.outputMvo.

```R
args(opt.outputMvo)
```

--------------------------------

### Summarize optimize.portfolio Output

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/summary.optimize.portfolio

Use the summary method to view a summary of the results from an optimize.portfolio object. This is a standard S3 method.

```R
# S3 method for optimize.portfolio
summary(object, ...)
```

--------------------------------

### Add Transaction Cost Constraint to Portfolio

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/transaction_cost_constraint

Example of adding a transaction cost constraint to a portfolio specification. Ensure 'edhec' dataset is loaded and 'ret' is defined.

```R
data(edhec)
ret <- edhec[, 1:4]

pspec <- portfolio.spec(assets=colnames(ret))

pspec <- add.constraint(portfolio=pspec, type="transaction_cost", ptc=0.01)

```

--------------------------------

### Extract Covariance from Statistical Factor Model

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/extractCovariance

Use this function to get the covariance matrix estimate from a statistical factor model. Ensure the model has been estimated using `statistical.factor.model`.

```r
extractCovariance(model, ...)
```

--------------------------------

### print.summary.optimize.portfolio

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/print.summary.optimize.portfolio

Prints the summary output for an object of class summary.optimize.portfolio.

```APIDOC
## print.summary.optimize.portfolio

### Description
Print method for objects of class summary.optimize.portfolio.

### Usage
print(x, ...)

### Parameters
#### Arguments
- **x** (summary.optimize.portfolio) - Required - An object of class summary.optimize.portfolio.
- **...** (dots) - Optional - Any other passthru parameters. Currently not used.
```

--------------------------------

### Print summary.optimize.portfolio.rebalancing S3 method

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/print.summary.optimize.portfolio.rebalancing

Usage syntax for the print method for objects of class summary.optimize.portfolio.rebalancing.

```R
# S3 method for summary.optimize.portfolio.rebalancing
print(x, ..., digits = 4)
```

--------------------------------

### trailingFUN: Apply a function over a configurable trailing period

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/trailingFUN

The trailingFUN function is designed for use with portfolio functions to apply a specified function over a trailing period of data. It can be used with asset returns and weights, and is also applicable for other use cases as demonstrated in the examples.

```APIDOC
## trailingFUN /apply a function over a configurable trailing period

### Description
This function is primarily designed for use with portfolio functions passing 'x' or 'R' and weights, but may be usable for other things as well, see Example for a vector example.

### Usage
trailingFUN(R, weights, n = 0, FUN, FUNargs = NULL, ...)

### Arguments
#### R
An xts, vector, matrix, data frame, timeSeries or zoo object of asset returns.

#### weights
A vector of weights to test.

#### n
Numeric number of trailing periods.

#### FUN
String describing the function to be called.

#### FUNargs
List describing any additional arguments.

#### ...
Any other passthru parameters.

### Details
Called with e.g.
trailingFUN(seq(1:100), weights=NULL, n=12, FUN='mean',FUNargs=list())

### Example
```R
# Example usage of trailingFUN
# Create a sample time series of returns
returns <- xts(matrix(rnorm(100), ncol = 2), order.by = seq(as.Date('2020-01-01'), by = 'day', length.out = 100))

# Calculate the trailing mean of the first column with a trailing period of 10 days
trailing_mean <- trailingFUN(R = returns[, 1], n = 10, FUN = 'mean')

# Print the result
print(trailing_mean)

# Example with weights
weights_vector <- c(0.5, 0.5)
trailing_weighted_mean <- trailingFUN(R = returns, weights = weights_vector, n = 20, FUN = 'mean')
print(trailing_weighted_mean)
```
```

--------------------------------

### Preview and Summarize 'indexes' Dataset in R

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/indexes

Provides functions to preview the first few rows and generate summary statistics for the 'indexes' dataset. Ensure the 'indexes' dataset is loaded before running.

```r
#preview the data
head(indexes)

#summary period statistics
summary(indexes)
```

--------------------------------

### rp_sample: Generate random portfolios

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/rp_sample

Generates random portfolios based on an idea by Pat Burns, supporting various constraints.

```APIDOC
## rp_sample: Generate random portfolios using the sample method

### Description
This function generates random portfolios based on an idea by Pat Burns.

### Usage
```R
rp_sample(portfolio, permutations, max_permutations = 200)
```

### Arguments
* **portfolio** (portfolio) - an object of type "portfolio" specifying the constraints for the optimization, see `portfolio.spec`
* **permutations** (integer) - number of unique constrained random portfolios to generate
* **max_permutations** (integer) - maximum number of iterations to try for a valid portfolio, default 200

### Details
The 'sample' method to generate random portfolios is based on an idea pioneerd by Pat Burns. This is the most flexible method, but also the slowest, and can generate portfolios to satisfy leverage, box, group, and position limit constraints.

### Value
a matrix of random portfolio weights
```

--------------------------------

### plot.optimize.portfolio.DEoptim

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/plot.optimize.portfolio.DEoptim

Generates a scatter and weights chart for portfolio optimizations run with DEoptim when trace=TRUE.

```APIDOC
## plot.optimize.portfolio.DEoptim

### Description
Scatter and weights chart for portfolio optimizations run with trace=TRUE

### Method
plot

### Endpoint
N/A (S3 method)

### Parameters
#### Arguments
- **x** (object) - set of portfolios created by `optimize.portfolio`
- **...** (any) - any other passthru parameters
- **return.col** (string) - name of column to use for returns (vertical axis)
- **risk.col** (string) - name of column to use for risk (horizontal axis)
- **chart.assets** (boolean) - TRUE/FALSE to include risk-return scatter of assets
- **neighbors** (numeric/matrix) - set of 'neighbor portfolios to overplot
- **main** (string) - an overall title for the plot: see `title`
- **xlim** (numeric) - set the limit on coordinates for the x-axis
- **ylim** (numeric) - set the limit on coordinates for the y-axis

### Request Example
```R
# Example usage (assuming 'opt_results' is an object of class optimize.portfolio.DEoptim)
plot(opt_results)
```

### Response
Generates a plot. No specific return object is detailed.
```

--------------------------------

### Usage of summary method for portfolio

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/summary.portfolio

Displays the S3 method signature for summarizing a portfolio object.

```R
# S3 method for portfolio
summary(object, ...)
```

--------------------------------

### Generate Random Portfolios with rp_sample

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/rp_sample

Use rp_sample to generate random portfolios based on an existing portfolio object and constraints. Specify the number of permutations and the maximum iterations to find valid portfolios.

```R
rp_sample(portfolio, permutations, max_permutations = 200)
```

--------------------------------

### print.optimize.portfolio.rebalancing

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/print.optimize.portfolio.rebalancing

Printing output of optimize.portfolio.rebalancing. This is the S3 method for optimize.portfolio.rebalancing objects.

```APIDOC
## print.optimize.portfolio.rebalancing

### Description
Printing output of optimize.portfolio.rebalancing

### Method
S3 method

### Endpoint
N/A (R function)

### Arguments
- **x** (object) - an object used to select a method
- **...** (passthru) - any other passthru parameters
- **digits** (numeric) - the number of significant digits to use when printing.
```

--------------------------------

### summary.optimize.portfolio

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/summary.optimize.portfolio

Provides a summary of the output from the optimize.portfolio function.

```APIDOC
## summary.optimize.portfolio

### Description
Summary method for class `optimize.portfolio`.

### Usage
```R
# S3 method for optimize.portfolio
summary(object, ...)
```

### Arguments
* `object` (optimize.portfolio) - An object of class `optimize.portfolio`.
* `...` - Any other passthru parameters. Currently not used.

### Author
Ross Bennett

### See Also
`optimize.portfolio`
```

--------------------------------

### Construct a return_objective object

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/return_objective

Use this constructor to define a return objective for portfolio optimization. If a target is provided, the function penalizes shortfalls; otherwise, it attempts to maximize the return metric.

```R
return_objective(
  name,
  target = NULL,
  arguments = NULL,
  multiplier = -1,
  enabled = TRUE,
  ...
)
```

--------------------------------

### generatesequence

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/generatesequence

Creates a sequence of possible weights for random or brute force portfolios.

```APIDOC
## generatesequence

### Description
This function creates the sequence of min<->max weights for use by random or brute force optimization engines. The sequence created is not constrained by asset.

### Usage
generatesequence(min = 0.01, max = 1, by = min/max, rounding = 3)

### Parameters
- **min** (numeric) - Optional - minimum value of the sequence
- **max** (numeric) - Optional - maximum value of the sequence
- **by** (numeric) - Optional - number to increment the sequence by
- **rounding** (integer) - Optional - how many decimals should we round to

### Authors
Peter Carl, Brian G. Peterson
```

--------------------------------

### summary.optimize.portfolio.rebalancing

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/summary.optimize.portfolio.rebalancing

Provides a summary of the optimize.portfolio.rebalancing object.

```APIDOC
## summary.optimize.portfolio.rebalancing

### Description
summary method for optimize.portfolio.rebalancing

### Method
summary

### Endpoint
N/A (R function)

### Arguments
- **object** (optimize.portfolio.rebalancing) - The object to summarize.
- **...** - Any other passthru parameters.
```

--------------------------------

### Load and Access indexes Dataset

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/indexes

Instructions on how to load the indexes dataset into the R environment and perform basic analysis.

```APIDOC
## Load Dataset

### Description
Loads the monthly economic indexes dataset (US Bonds, US Equities, International Equities, Commodities, US T-Bills, and Inflation) into the current R session.

### Usage
```r
data(indexes)
```

### Format
CSV converted into an xts object with monthly observations.

### Examples
```r
# Load the data
data(indexes)

# Preview the data
head(indexes)

# Summary period statistics
summary(indexes)
```
```

--------------------------------

### objective Constructor

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/objective

Constructs an objective object for portfolio optimization.

```APIDOC
## objective Constructor

### Description
Typically called as a sub-function by the user function `add.objective`. See main documentation there.

### Usage
```R
objective(
  name,
  target = NULL,
  arguments,
  enabled = TRUE,
  ...,
  multiplier = 1,
  objclass = "objective"
)
```

### Arguments
- **name** (character) - Name of the objective which will be used to call a function, like 'ES', 'VaR', 'mean'.
- **target** (numeric/NULL) - Univariate target for the objective, default NULL.
- **arguments** (list) - Default arguments to be passed to an objective function when executed.
- **enabled** (logical) - TRUE/FALSE.
- **...** - Any other passthrough parameters.
- **multiplier** (numeric) - Multiplier to apply to the objective, usually 1 or -1.
- **objclass** (character) - String class to apply, default 'objective'.

### Author
Brian G. Peterson

### See Also
`add.objective`, `portfolio.spec`
```

--------------------------------

### Generate random portfolios with rp_grid

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/rp_grid

Generates a matrix of random portfolio weights based on specified constraints.

```R
rp_grid(portfolio, permutations = 2000, normalize = TRUE)
```

--------------------------------

### Portfolio Construction and Optimization Functions

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics

Functions for creating, combining, and optimizing portfolios.

```APIDOC
## Portfolio Construction and Optimization

### Description
This section covers functions related to the creation, manipulation, and optimization of investment portfolios.

### Functions
- **`combine.portfolios`**: Combine a list of portfolio objects.
- **`create.EfficientFrontier`**: Create an efficient frontier.
- **`equal.weight`**: Create an equal weight portfolio.
- **`gmv_opt`**: GMV/QU QP Optimization.
- **`gmv_opt_leverage`**: GMV/QU QP Optimization with Turnover Constraint.
- **`gmv_opt_ptc`**: GMV/QU QP Optimization with Proportional Transaction Cost Constraint.
- **`gmv_opt_toc`**: GMV/QU QP Optimization with Turnover Constraint.
- **`inverse.volatility.weight`**: Create an inverse volatility weighted portfolio.
- **`maxret_opt`**: Maximum Return LP Optimization.
- **`mult.portfolio.spec`**: Multiple Layer Portfolio Specification.
- **`optimize.portfolio`**: (Implicitly used by other functions like `gmv_opt`, `maxret_opt`, etc.) Optimize a portfolio based on specified objectives and constraints.
- **`optimize.portfolio.rebalancing`**: (Implicitly used) Optimize a portfolio with rebalancing.
- **`plot.optimize.portfolio.DEoptim`**: Plot method for objects of class `optimize.portfolio`.
- **`combine.optimizations`**: Combine objects created by `optimize.portfolio`.
```

--------------------------------

### rp_simplex: Generate random portfolios

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/rp_simplex

Generates random portfolios using the simplex method, ensuring weights sum to 1 while respecting box constraints.

```APIDOC
## rp_simplex

### Description
Generates random portfolios based on the simplex method outlined in the Shaw paper. This method is useful for generating portfolios with full investment constraints (sum of weights = 1) and minimum box constraints.

### Usage
`rp_simplex(portfolio, permutations, fev = 0:5)`

### Arguments
- **portfolio** (object) - An object of class 'portfolio' specifying the constraints for the optimization.
- **permutations** (integer) - Number of unique constrained random portfolios to generate.
- **fev** (scalar or vector) - Value for Face-Edge-Vertex (FEV) biasing.

### Value
A matrix of random portfolio weights.
```

--------------------------------

### Construct a minmax_objective object

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/minmax_objective

Use this constructor to define an objective with min and max constraints for portfolio optimization.

```R
minmax_objective(
  name,
  target = NULL,
  arguments = NULL,
  multiplier = 1,
  enabled = TRUE,
  ...,
  min,
  max
)
```

--------------------------------

### Print Summary Output of optimize.portfolio

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/print.summary.optimize.portfolio

This is the S3 method for printing summary objects generated by optimize.portfolio. It takes an object of class summary.optimize.portfolio and any other passthru parameters.

```R
# S3 method for summary.optimize.portfolio
print(x, ...)
```

--------------------------------

### plot.optimize.portfolio

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/plot.optimize.portfolio.DEoptim

Default plot method for portfolio optimizations.

```APIDOC
## plot.optimize.portfolio

### Description
Default plot method for portfolio optimizations.

### Method
plot

### Endpoint
N/A (S3 method)

### Parameters
#### Arguments
- **x** (object) - set of portfolios created by `optimize.portfolio`
- **...** (any) - any other passthru parameters
- **return.col** (string) - name of column to use for returns (vertical axis)
- **risk.col** (string) - name of column to use for risk (horizontal axis)
- **chart.assets** (boolean) - TRUE/FALSE to include risk-return scatter of assets
- **neighbors** (numeric/matrix) - set of 'neighbor portfolios to overplot
- **xlim** (numeric) - set the limit on coordinates for the x-axis
- **ylim** (numeric) - set the limit on coordinates for the y-axis
- **main** (string) - an overall title for the plot: see `title`

### Request Example
```R
# Example usage (assuming 'opt_results' is an object of class optimize.portfolio)
plot(opt_results)
```

### Response
Generates a plot. No specific return object is detailed.
```

--------------------------------

### plot.optimize.portfolio.pso

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/plot.optimize.portfolio.DEoptim

Generates a scatter and weights chart for portfolio optimizations run with PSO.

```APIDOC
## plot.optimize.portfolio.pso

### Description
Scatter and weights chart for portfolio optimizations run with PSO

### Method
plot

### Endpoint
N/A (S3 method)

### Parameters
#### Arguments
- **x** (object) - set of portfolios created by `optimize.portfolio`
- **...** (any) - any other passthru parameters
- **return.col** (string) - name of column to use for returns (vertical axis)
- **risk.col** (string) - name of column to use for risk (horizontal axis)
- **chart.assets** (boolean) - TRUE/FALSE to include risk-return scatter of assets
- **cex.axis** (numeric) - magnification for axis annotation relative to `cex`
- **element.color** (string) - color for drawing less-important chart elements
- **neighbors** (numeric/matrix) - set of 'neighbor portfolios to overplot
- **main** (string) - an overall title for the plot: see `title`
- **xlim** (numeric) - set the limit on coordinates for the x-axis
- **ylim** (numeric) - set the limit on coordinates for the y-axis

### Request Example
```R
# Example usage (assuming 'opt_results' is an object of class optimize.portfolio.pso)
plot(opt_results)
```

### Response
Generates a plot. No specific return object is detailed.
```

--------------------------------

### Construct constraint objects

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/constraint_v1

Use these functions to define constraints for portfolio optimization. constraint_v1 is provided for backwards compatibility.

```R
constraint_v1(
  assets = NULL,
  ...,
  min,
  max,
  min_mult,
  max_mult,
  min_sum = 0.99,
  max_sum = 1.01,
  weight_seq = NULL
)
constraint(type, enabled = TRUE, ..., constrclass = "v2_constraint")
```

--------------------------------

### Print optimize.portfolio.rebalancing Output

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/print.optimize.portfolio.rebalancing

S3 method for printing the output of optimize.portfolio.rebalancing. Use this to display the results of portfolio rebalancing optimizations.

```R
# S3 method for optimize.portfolio.rebalancing
print(x, ..., digits = 4)
```

--------------------------------

### Generate random portfolios with rp_simplex

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/rp_simplex

Use this function to create a matrix of random portfolio weights based on specified constraints and FEV biasing parameters.

```R
rp_simplex(portfolio, permutations, fev = 0:5)
```

--------------------------------

### POST /add.objective

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics

General interface for adding optimization objectives, including risk, return, and risk budget.

```APIDOC
## POST /add.objective

### Description
Adds an objective to the portfolio specification for optimization.

### Method
POST

### Endpoint
/add.objective
```

--------------------------------

### Generate weight sequence in PortfolioAnalytics

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/generatesequence

Creates a sequence of weights for optimization engines. The sequence is not constrained by asset.

```R
generatesequence(min = 0.01, max = 1, by = min/max, rounding = 3)
```

--------------------------------

### Call gmv_opt_leverage Function

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/gmv_opt_leverage

This is the usage signature for the gmv_opt_leverage function. It takes asset returns, constraints, moments, risk aversion parameter, target return, solver, and solver control parameters as input.

```R
gmv_opt_leverage(
  R,
  constraints,
  moments,
  lambda,
  target,
  solver = "quadprog",
  control = NULL
)
```

--------------------------------

### print.summary.optimize.portfolio.rebalancing

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/print.summary.optimize.portfolio.rebalancing

Provides the print method for objects of class summary.optimize.portfolio.rebalancing.

```APIDOC
## print.summary.optimize.portfolio.rebalancing

### Description

Print method for objects of class `summary.optimize.portfolio.rebalancing`.

### Usage

```R
# S3 method for summary.optimize.portfolio.rebalancing
print(x, ..., digits = 4)
```

### Arguments

* **x** (summary.optimize.portfolio.rebalancing) - An object of class `summary.optimize.portfolio.rebalancing`.
* **...** - Any other passthru parameters.
* **digits** (number) - Number of digits used for printing.
```

--------------------------------

### Construct a portfolio_risk_objective object

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/portfolio_risk_objective

Use this constructor to define a risk objective. If the target argument is set to NULL, the function defaults to minimizing the specified risk metric.

```R
portfolio_risk_objective(
  name,
  target = NULL,
  arguments = NULL,
  multiplier = 1,
  enabled = TRUE,
  ...
)
```

--------------------------------

### Generate random portfolios with random_portfolios

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/random_portfolios

Usage syntax for the random_portfolios function to generate an arbitrary number of constrained random portfolios.

```R
random_portfolios(
  portfolio,
  permutations = 100,
  rp_method = "sample",
  eliminate = TRUE,
  ...
)
```

--------------------------------

### Function: opt.outputMvo

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/opt.outputMvo

Converts output of optimize.portfolio to a list of the portfolio weights, mean, volatility and Sharpe Ratio.

```APIDOC
## opt.outputMvo

### Description
Converts output of `optimize.portfolio` to a list of the portfolio weights, mean, volatility and Sharpe Ratio.

### Parameters
- **opt** (List) - Required - Output of `optimize.portfolio`
- **returns** (xts) - Required - Multivariate xts object of portfolio assets returns
- **digits** (Integer) - Optional - Number of significant digits (default NULL)
- **annualize** (Logical) - Optional - Whether to annualize (default TRUE)
- **frequency** (String) - Optional - Returns frequency: "monthly", "weekly" or "daily" (default "monthly")
- **rf** (Numeric) - Optional - Risk-free rate (default 0.0)

### Response
- **List** - Contains portfolio numeric weights, mean value, volatility, and Sharpe Ratio.
```

--------------------------------

### plot.optimize.portfolio.ROI

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/plot.optimize.portfolio.DEoptim

Generates a scatter and weights chart for portfolio optimizations run with ROI.

```APIDOC
## plot.optimize.portfolio.ROI

### Description
Scatter and weights chart for portfolio optimizations run with ROI

### Method
plot

### Endpoint
N/A (S3 method)

### Parameters
#### Arguments
- **x** (object) - set of portfolios created by `optimize.portfolio`
- **...** (any) - any other passthru parameters
- **rp** (boolean) - TRUE/FALSE to plot feasible portfolios generated by `random_portfolios`
- **risk.col** (string) - name of column to use for risk (horizontal axis)
- **return.col** (string) - name of column to use for returns (vertical axis)
- **chart.assets** (boolean) - TRUE/FALSE to include risk-return scatter of assets
- **element.color** (string) - color for drawing less-important chart elements
- **neighbors** (numeric/matrix) - set of 'neighbor portfolios to overplot
- **main** (string) - an overall title for the plot: see `title`
- **xlim** (numeric) - set the limit on coordinates for the x-axis
- **ylim** (numeric) - set the limit on coordinates for the y-axis

### Request Example
```R
# Example usage (assuming 'opt_results' is an object of class optimize.portfolio.ROI)
plot(opt_results, rp = TRUE)
```

### Response
Generates a plot. No specific return object is detailed.
```

--------------------------------

### return_constraint constructor

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/return_constraint

Constructor function to create a return constraint object for portfolio optimization.

```APIDOC
## return_constraint

### Description
The return_constraint function specifies a target mean return value. This function is called by add.constraint when type="return" is specified.

### Usage
return_constraint(type = "return", return_target, enabled = TRUE, message = FALSE, ...)

### Arguments
- **type** (character) - Required - The type of the constraint.
- **return_target** (numeric) - Required - The target return value.
- **enabled** (logical) - Optional - TRUE/FALSE, default is TRUE.
- **message** (logical) - Optional - TRUE/FALSE, default is FALSE. Display messages if TRUE.
- **...** (dots) - Optional - Any other passthru parameters.

### Value
Returns an object of class 'return_constraint'.
```

--------------------------------

### applyFUN: Apply a risk or return function to a set of weights

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/applyFUN

Calculates risk or return metrics given a matrix of weights and an xts object of asset returns.

```APIDOC
## applyFUN

### Description
This function is used to calculate risk or return metrics given a matrix of weights and is primarily used as a convenience function used in chart.Scatter functions.

### Usage
applyFUN(R, weights, FUN = "mean", arguments)

### Parameters
- **R** (xts object) - Required - xts object of asset returns
- **weights** (matrix) - Required - a matrix of weights generated from random_portfolios or optimize.portfolio
- **FUN** (string) - Required - name of a function
- **arguments** (list) - Optional - named list of arguments to FUN
```

--------------------------------

### constraint_ROI Constructor

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/constraint_ROI

Use this constructor to create an ROI constraint object. Specify the number of assets, the optimization problem object, the desired solver, and an optional sequence of weights.

```R
constraint_ROI(
  assets = NULL,
  op.problem,
  solver = c("glpk", "quadprog"),
  weight.seq = NULL
)
```

--------------------------------

### Summary Method for Portfolio Rebalancing

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/summary.optimize.portfolio.rebalancing

This is the S3 method for summarizing the results of portfolio rebalancing optimization. It takes an object of type optimize.portfolio.rebalancing and any additional passthru parameters.

```R
# S3 method for optimize.portfolio.rebalancing
summary(object, ...)
```

--------------------------------

### Constructor: risk_budget_objective

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/risk_budget_objective

Creates an object of class 'risk_budget_objective' used for defining risk budget constraints in portfolio optimization.

```APIDOC
## risk_budget_objective

### Description
Constructor for class risk_budget_objective.

### Usage
risk_budget_objective(assets, name, target = NULL, arguments = NULL, multiplier = 1, enabled = TRUE, ..., min_prisk, max_prisk, min_concentration = FALSE, min_difference = FALSE)

### Arguments
- **assets** (vector) - Required - Vector of assets to use, should come from constraints object.
- **name** (string) - Required - Name of the objective, should correspond to a function.
- **target** (numeric) - Optional - Univariate target for the objective.
- **arguments** (list) - Optional - Default arguments to be passed to an objective function when executed.
- **multiplier** (numeric) - Optional - Multiplier to apply to the objective, usually 1 or -1.
- **enabled** (boolean) - Optional - TRUE/FALSE status.
- **...** (dots) - Optional - Any other passthru parameters.
- **min_prisk** (numeric) - Required - Minimum percentage contribution to risk.
- **max_prisk** (numeric) - Required - Maximum percentage contribution to risk.
- **min_concentration** (boolean) - Optional - TRUE/FALSE whether to minimize concentration, default FALSE, always TRUE if min_prisk and max_prisk are NULL.
- **min_difference** (boolean) - Optional - TRUE/FALSE whether to minimize difference between concentration, default FALSE.

### Value
- **object** (risk_budget_objective) - Returns an object of class 'risk_budget_objective'.
```

--------------------------------

### Add Weight Sum Constraints to Portfolio Specification

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/weight_sum_constraint

Demonstrates how to add different types of weight sum constraints to a portfolio specification using the add.constraint function. This includes basic weight sum, full investment, dollar neutral, and active constraints.

```R
data(edhec)
ret <- edhec[, 1:4]

pspec <- portfolio.spec(assets=colnames(ret))

# min_sum and max_sum can be specified with type="weight_sum" or type="leverage"
pspec <- add.constraint(pspec, type="weight_sum", min_sum=1, max_sum=1)

# Specify type="full_investment" to set min_sum=1 and max_sum=1
pspec <- add.constraint(pspec, type="full_investment")

# Specify type="dollar_neutral" or type="active" to set min_sum=0 and max_sum=0
pspec <- add.constraint(pspec, type="dollar_neutral")
pspec <- add.constraint(pspec, type="active")
```

--------------------------------

### optimize.portfolio.rebalancing

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/optimize.portfolio.rebalancing

Performs portfolio optimization with support for rebalancing periods, useful for out-of-sample testing and backtesting.

```APIDOC
## optimize.portfolio.rebalancing

### Description
Portfolio optimization with support for rebalancing periods for out-of-sample testing (i.e. backtesting).

### Usage
```R
optimize.portfolio.rebalancing_v1(
  R,
  constraints,
  optimize_method = c("DEoptim", "random", "ROI"),
  search_size = 20000,
  trace = FALSE,
  ...,
  rp = NULL,
  rebalance_on = NULL,
  training_period = NULL,
  rolling_window = NULL
)
optimize.portfolio.rebalancing(
  R,
  portfolio = NULL,
  constraints = NULL,
  objectives = NULL,
  optimize_method = c("DEoptim", "random", "ROI", "CVXR"),
  search_size = 20000,
  trace = FALSE,
  ...,
  rp = NULL,
  rebalance_on = NULL,
  training_period = NULL,
  rolling_window = NULL
)
```

### Arguments
* **R** (xts, vector, matrix, data frame, timeSeries or zoo object) - Asset returns.
* **constraints** (list, default NULL) - A list of constraint objects.
* **optimize_method** (character string) - One of "DEoptim", "random", "pso", "GenSA", or "ROI".
* **search_size** (integer, default 20000) - How many portfolios to test.
* **trace** (logical, default FALSE) - If TRUE, will attempt to return additional information on the path or portfolios searched.
* **...** - Any other passthru parameters to `optimize.portfolio`.
* **rp** (any) - A set of random portfolios passed into the function to prevent recalculation.
* **rebalance_on** (character string, default NULL) - Period to rebalance on. See `endpoints` for valid names.
* **training_period** (integer, default NULL) - Number of periods to use as a training data in the front of the returns data.
* **rolling_window** (integer, default NULL) - Width (i.e. number of periods) of the rolling window. If NULL, uses data from inception.
* **portfolio** (object of type "portfolio", default NULL) - Specifies the constraints and objectives for the optimization.
* **objectives** (list, default NULL) - A list of objective objects.

### Value
A list containing the following elements:
* **portfolio**: The portfolio object.
* **R**: The asset returns.
* **call**: The function call.
* **elapsed_time**: The amount of time that elapses while the optimization is run.
* **opt_rebalancing**: A list of `optimize.portfolio` objects computed at each rebalancing period.

### Details
Runs portfolio optimization with periodic rebalancing at specified time periods. This can help refine constraints and objectives by evaluating out-of-sample performance based on historical data. If both `training_period` and `rolling_window` are `NULL`, `training_period` defaults to 36. If `training_period` is `NULL` and `rolling_window` is specified, `training_period` is set to the value of `rolling_window`. The user should be aware of the behavior when both are specified and have different values, affecting the window size used in optimizations.

This function is a wrapper around `optimize.portfolio` and requires the 'foreach' package. Parallel backend registration is suggested.

### Author
Kris Boudt, Peter Carl, Brian G. Peterson

### See Also
`portfolio.spec`, `optimize.portfolio`

### Examples
```R
if (FALSE) {
data(edhec)
R <- edhec[,1:4]
funds <- colnames(R)

portf <- portfolio.spec(funds)
portf <- add.constraint(portf, type="full_investment")
portf <- add.constraint(portf, type="long_only")
portf <- add.objective(portf, type="risk", name="StdDev")

# Quarterly rebalancing with 5 year training period
bt.opt1 <- optimize.portfolio.rebalancing(R, portf,
optimize_method="ROI",
rebalance_on="quarters",
training_period=60)

# Monthly rebalancing with 5 year training period and 4 year rolling window
bt.opt2 <- optimize.portfolio.rebalancing(R, portf,
optimize_method="ROI",
rebalance_on="months",
training_period=60,
rolling_window=48)
}
```
```

--------------------------------

### plot.optimize.portfolio.GenSA

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/plot.optimize.portfolio.DEoptim

Generates a scatter and weights chart for portfolio optimizations run with GenSA.

```APIDOC
## plot.optimize.portfolio.GenSA

### Description
Scatter and weights chart for portfolio optimizations run with GenSA

### Method
plot

### Endpoint
N/A (S3 method)

### Parameters
#### Arguments
- **x** (object) - set of portfolios created by `optimize.portfolio`
- **...** (any) - any other passthru parameters
- **rp** (boolean) - TRUE/FALSE to plot feasible portfolios generated by `random_portfolios`
- **return.col** (string) - name of column to use for returns (vertical axis)
- **risk.col** (string) - name of column to use for risk (horizontal axis)
- **chart.assets** (boolean) - TRUE/FALSE to include risk-return scatter of assets
- **cex.axis** (numeric) - magnification for axis annotation relative to `cex`
- **element.color** (string) - color for drawing less-important chart elements
- **neighbors** (numeric/matrix) - set of 'neighbor portfolios to overplot
- **main** (string) - an overall title for the plot: see `title`
- **xlim** (numeric) - set the limit on coordinates for the x-axis
- **ylim** (numeric) - set the limit on coordinates for the y-axis

### Request Example
```R
# Example usage (assuming 'opt_results' is an object of class optimize.portfolio.GenSA)
plot(opt_results, rp = TRUE)
```

### Response
Generates a plot. No specific return object is detailed.
```

--------------------------------

### POST /add.constraint

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics

General interface for adding and/or updating optimization constraints to a portfolio specification.

```APIDOC
## POST /add.constraint

### Description
Adds or updates optimization constraints for a portfolio object.

### Method
POST

### Endpoint
/add.constraint
```

--------------------------------

### POST /create.EfficientFrontier

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/create.EfficientFrontier

Constructs an efficient frontier for a given portfolio based on specified constraints and objectives.

```APIDOC
## POST /create.EfficientFrontier

### Description
Creates an efficient frontier object containing objective measures and weights of portfolios along the frontier.

### Method
POST

### Parameters
#### Request Body
- **R** (xts object) - Required - Asset returns.
- **portfolio** (object) - Required - Object of class 'portfolio' specifying constraints and objectives.
- **type** (string) - Required - Type of efficient frontier (e.g., "mean-var", "mean-ES", "DEoptim", "random").
- **optimize_method** (string) - Optional - The optimization method, default is "CVXR".
- **n.portfolios** (numeric) - Optional - Number of portfolios to calculate along the frontier.
- **risk_aversion** (vector) - Optional - Vector of risk aversion values.
- **match.col** (string) - Optional - Column to match when extracting the frontier.
- **search_size** (numeric) - Optional - Search size for DEoptim or random methods.

### Response
#### Success Response (200)
- **efficient.frontier** (object) - An object containing objective measures and weights of portfolios along the efficient frontier.
```

--------------------------------

### summary.portfolio Method

Source: https://www.rdocumentation.org/packages/PortfolioAnalytics/versions/2.1.1/topics/summary.portfolio

Provides a summary of a portfolio specification object.

```APIDOC
## summary.portfolio

### Description
summary method for class `portfolio` created with `portfolio.spec`

### Usage
```R
# S3 method for portfolio
summary(object, ...)
```

### Arguments
* `object` (portfolio) - an object of class `portfolio`
* `...` - any other passthru parameters

### Author
Ross Bennett

### See Also
`portfolio.spec`
```
Tokens:
Raw