Skip to content

Main content

Risk-Parity Portfolio Calculator Source Code

Browse the implementation files for Risk-Parity Portfolio Calculator.
tool.ts typescript
const parseCovariance = (input: unknown): number[][] | null => {
	if (typeof input !== 'string') return null;
	try {
		const matrix = JSON.parse(input) as unknown;
		if (
			!Array.isArray(matrix) ||
			matrix.length === 0 ||
			matrix.some(
				(row) =>
					!Array.isArray(row) ||
					row.length !== matrix.length ||
					row.some(
						(value) =>
							typeof value !== 'number' ||
							!Number.isFinite(value)
					)
			)
		)
			return null;
		for (let row = 0; row < matrix.length; row += 1)
			for (let column = 0; column < matrix.length; column += 1)
				if (
					Math.abs(matrix[row][column] - matrix[column][row]) >
					1e-9
				)
					return null;
		return matrix as number[][];
	} catch {
		return null;
	}
};

export const calculateRiskParity = (
	covarianceInput: unknown,
	iterationsInput: unknown = 500
): string => {
	const covariance = parseCovariance(covarianceInput);
	const iterations = Number(iterationsInput);
	if (
		!covariance ||
		!Number.isSafeInteger(iterations) ||
		iterations < 1 ||
		iterations > 100_000 ||
		covariance.some((row, index) => row[index] <= 0)
	)
		return '';
	const count = covariance.length;
	let weights = Array(count).fill(1 / count) as number[];
	for (
		let iteration = 0;
		iteration < iterations;
		iteration += 1
	) {
		const marginal = covariance.map((row) =>
			row.reduce(
				(sum, value, index) => sum + value * weights[index],
				0
			)
		);
		const variance = weights.reduce(
			(sum, weight, index) => sum + weight * marginal[index],
			0
		);
		if (!(variance > 0)) return '';
		const contributions = weights.map(
			(weight, index) => (weight * marginal[index]) / variance
		);
		if (contributions.some((value) => !(value > 0))) return '';
		weights = weights.map(
			(weight, index) =>
				weight * Math.sqrt(1 / count / contributions[index])
		);
		const total = weights.reduce(
			(sum, weight) => sum + weight,
			0
		);
		weights = weights.map((weight) => weight / total);
	}
	const marginal = covariance.map((row) =>
		row.reduce(
			(sum, value, index) => sum + value * weights[index],
			0
		)
	);
	const variance = weights.reduce(
		(sum, weight, index) => sum + weight * marginal[index],
		0
	);
	const riskContributions = weights.map(
		(weight, index) => (weight * marginal[index]) / variance
	);
	return JSON.stringify(
		{
			riskContributions: riskContributions.map((value) =>
				Number(value.toPrecision(8))
			),
			weights: weights.map((value) =>
				Number(value.toPrecision(8))
			)
		},
		null,
		2
	);
};

export const Tool: TypeTool = {
	name: 'Risk-Parity Portfolio Calculator',
	slug: 'finance/risk-parity',
	intro:
		'Estimate long-only equal-risk-contribution weights from a covariance matrix.',
	tool: calculateRiskParity,
	i: [
		{
			example: '[[0.04,0.006],[0.006,0.09]]',
			label: 'Covariance Matrix',
			placeholder: 'Symmetric covariance matrix as JSON',
			render: 'textarea',
			type: 'text'
		},
		{
			example: '500',
			label: 'Iterations',
			placeholder: 'Solver iterations',
			type: 'number'
		}
	],
	o: [
		{
			example: '{ "weights": [0.6, 0.4] }',
			label: 'Risk-Parity Allocation',
			placeholder: 'Weights will appear here...',
			render: 'textarea',
			type: 'text'
		}
	]
};
export default Tool;

Description

Browse the implementation files for Risk-Parity Portfolio Calculator.

References

  1. Tool.io on GitHub
  2. Tool.io TypeScript tools library

Similar or alternative tools