The provided R function `getStrategyWeights` computes and returns the weights...

July 1, 2025 at 07:05 AM

getStrategyWeights <- function(strat.params)
{	
	# get the data headers part
	#tradedparams.tbl <- getDataParams(params=strat.params, value.row="SECURITY", name.column="TYPE", value.column="TRADED");
	tradedparams.tbl <- lookupDataParam(params=strat.params, value.row="SECURITY");#made this change because we have changed the input xml;updated by kyle on 1/20/2012
	
	# first factor out the different weight schemes
	#wt.factors.vec <- factor(tradedparams.tbl[,"WT"], levels=tradedparams.tbl[,"WT"]);
	#wt.levels.vec <- levels(wt.factors.vec); 
	wt.levels.vec <- unique(tradedparams.tbl[,"WTPARAMS"]);
	rebal.params <- lookupDataParam(strat.params, "REBAL_PARAMS");
	wt.mat <- NULL;
	
	# for each scheme, we calculate the weights.  For now just has ONE scheme...
	for (i in 1:length(wt.levels.vec))
	{
		wt.param.str <- wt.levels.vec[i];	
		datakeys <- tradedparams.tbl[tradedparams.tbl[,"WTPARAMS"]==wt.param.str,];		
		wt.scheme.str <- datakeys[1,"WT"];
		wt.scheme.vec <- lookupDataParam(strat.params, wt.param.str);

		source(wt.scheme.str~".r");
		temp.wts <- getSchemeWeights(wt.scheme.vec,datakeys.tbl=datakeys);

		# check if we need to add in rebalance weights
		if (length(rebal.params) > 0)  {
			rebal.dates <- truncDtVec(rebal.params["STARTDATE"], rebal.params["ENDDATE"], nthBusDay(wt.scheme.vec["CDR"],as.numeric(rebal.params["REBAL_DAY"])));
			rebal.dates <- rebal.dates[seq(from=1,to=length(rebal.dates),by=as.numeric(rebal.params["REBAL_FREQ"]))];
			temp.wts <- getRebalancedWeights(rebal.params, wts=temp.wts, rebal.dates);
		}
		wt.mat <- cbind(wt.mat, temp.wts);
	}
	
	# add the portfolio target weights
	folio.wts = matrix(1,nrow=nrow(wt.mat),ncol=ncol(wt.mat));
	folio.params <- lookupDataParam(strat.params, "PORTFOLIO_PARAMS");
	if (length(folio.params) > 0) {
		wtscheme.params <- lookupDataParam(strat.params, folio.params["WTPARAMS"]);
		source(folio.params["WT"] ~ ".r");
		folio.wts <- getSchemeWeights(wt.scheme.vec=wtscheme.params, datakeys.tbl=tradedparams.tbl, wt.mode="PORTFOLIO");
		
		#if (length(rebal.params) > 0)  {
		#	rebal.dates <- truncDtVec(rebal.params["STARTDATE"], rebal.params["ENDDATE"], nthBusDay("NYC",as.numeric(rebal.params["REBAL_DAY"])));
		#	rebal.dates <- rebal.dates[seq(from=1,to=length(rebal.dates),by=as.numeric(rebal.params["REBAL_FREQ"]))];
		#	folio.wts <- getRebalancedWeights(rebal.params, folio.wts, rebal.dates);
		#}
	}	
	list(tickers=wt.mat, folio=folio.wts, combined=wt.mat*folio.wts);
}

The provided R function getStrategyWeights computes and returns the weights for a financial strategy or portfolio based on certain input parameters (strat.params). Here’s a breakdown of what this function does:

1. Input:

strat.params: Input configuration parameters (likely in a structured format like a list or XML) describing strategies and weights.

2. Key Operations:

Step 1: Extract Important Data

Extraction of 'traded' parameters:
- The function extracts trade-related parameter data (e.g., securities, weight schemes) using the helper function lookupDataParam. This determines the securities (in column SECURITY) and weight scheme parameters (WTPARAMS).

Step 2: Identify Weight Layers

Unique weight schemes: A unique set of weight schemes (WTPARAMS) is identified for further processing.
Rebalance parameters: Rebalancing configuration is fetched, if any (REBAL_PARAMS).

Step 3: Calculate Weights for Each Scheme

The function loops through each weight scheme:

Retrieves the associated weight scheme (WT) and its parameters.
Dynamically sources or fetches a script/file (e.g., WT.r) to calculate weights using the helper function getSchemeWeights.
Adds rebalancing weights if configured:
- Rebalance dates are computed using parameters like STARTDATE, ENDDATE, REBAL_DAY, and REBAL_FREQ.
- Rebalance weights are applied using getRebalancedWeights.

The weights are consolidated into a matrix (wt.mat).

Step 4: Portfolio-Level Target Weights

If portfolio-level parameters (PORTFOLIO_PARAMS) exist:
- The corresponding scheme and weights are retrieved.
- The function calculates the portfolio-level weights using getSchemeWeights for mode "PORTFOLIO".
- Optionally, rebalancing logic for the portfolio's weights is commented out (ready to be used if needed).

Step 5: Output Combined Weights

The function combines the weight matrix (wt.mat) with the portfolio-level weights (folio.wts) and prepares the result as:
- tickers: The calculated weights for tickers.
- folio: The portfolio weight layer.
- combined: The product of ticker weights and portfolio weights.

3. Return Value:

The function returns a named list containing:

tickers: The weights matrix for the tickers or securities.
folio: The portfolio’s target weights.
combined: The combined product of ticker and portfolio weights.

4. Purpose of the Code:

The function is designed to compute the multidimensional weight structure for financial strategies or portfolios, including both security-level and portfolio-level weights. It accounts for rebalancing and allows dynamic sourcing of weight schemes.

5. Dependencies:

Several helper functions like lookupDataParam, getSchemeWeights, getRebalancedWeights, and nthBusDay.
External scripts/files for specific weight schemes (dynamically sourced).

6. Comment on Changes Noted:

The comment indicates the input XML format has changed (on 1/20/2012, updated by "Kyle"), prompting modifications in the logic (e.g., replacing getDataParams with lookupDataParam).

Conclusion:

This function automates the calculation of financial strategy weights from input parameters, supports rebalancing logic, and produces combined weights for both tickers and the portfolio. It relies on external data and helper functions to complete its processing.

Generate your own explanations

Download our vscode extension

Read other generated explanations

Built by @thebuilderjr