quantitivecalc/dist/RiskAndVolatilityAnalysis/calculateBeta.js

A TypeScript library providing advanced quantitative finance functions for risk analysis, performance metrics, and technical indicators. (Currently in development)

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.calculateBeta = calculateBeta;
/**
 * Calculates the rolling beta of an asset relative to a benchmark over a specified window size.
 * Beta is computed as the covariance of asset and benchmark returns divided by the variance of benchmark returns.
 *
 * @param data - Array of objects containing asset and benchmark returns.
 * @param assetReturnsColumn - The key in each data object for the asset returns.
 * @param benchmarkReturnsColumn - The key in each data object for the benchmark returns.
 * @param resultColumn - The key in each data object where the calculated beta will be stored.
 * @param windowSize - The number of periods to use for the rolling window (default is 252, typically one year of daily data).
 * @returns A new array of objects with the calculated beta values in the specified result column. If insufficient data is available for a window, beta is set to `null`.
 */
function calculateBeta(data, assetReturnsColumn, benchmarkReturnsColumn, resultColumn, windowSize = 252) {
    if (!data || data.length === 0) {
        return [];
    }
    const result = data.map(row => ({ ...row }));
    for (let i = 0; i < result.length; i++) {
        if (i < windowSize - 1) {
            result[i][resultColumn] = null;
        }
        else {
            const assetReturns = [];
            const benchmarkReturns = [];
            // Collect returns for the window
            for (let j = i - windowSize + 1; j <= i; j++) {
                const assetReturn = result[j][assetReturnsColumn];
                const benchmarkReturn = result[j][benchmarkReturnsColumn];
                if (typeof assetReturn === 'number' &&
                    !isNaN(assetReturn) &&
                    typeof benchmarkReturn === 'number' &&
                    !isNaN(benchmarkReturn)) {
                    assetReturns.push(assetReturn);
                    benchmarkReturns.push(benchmarkReturn);
                }
            }
            if (assetReturns.length > 10) {
                // Calculate beta using covariance / variance formula
                const n = assetReturns.length;
                const assetMean = assetReturns.reduce((sum, val) => sum + val, 0) / n;
                const benchmarkMean = benchmarkReturns.reduce((sum, val) => sum + val, 0) / n;
                // Calculate covariance
                let covariance = 0;
                for (let k = 0; k < n; k++) {
                    covariance += (assetReturns[k] - assetMean) * (benchmarkReturns[k] - benchmarkMean);
                }
                covariance = covariance / (n - 1);
                // Calculate benchmark variance
                let benchmarkVariance = 0;
                for (let k = 0; k < n; k++) {
                    benchmarkVariance += Math.pow(benchmarkReturns[k] - benchmarkMean, 2);
                }
                benchmarkVariance = benchmarkVariance / (n - 1);
                // Beta = Covariance(asset, benchmark) / Variance(benchmark)
                const beta = benchmarkVariance > 0 ? covariance / benchmarkVariance : 0;
                result[i][resultColumn] = beta;
            }
            else {
                result[i][resultColumn] = null;
            }
        }
    }
    return result;
}