Skip to content

Main content

Robust Minimax Optimization Solver Source Code

Browse the implementation files for Robust Minimax Optimization Solver.
tool.ts typescript
import { parseFiniteNumber } from '../../parse/number/tool';

type Scenario = { coefficient: number; target: number };
export const solveRobustMinimax = (
	scenariosInput: unknown,
	minimumInput: unknown,
	maximumInput: unknown,
	stepInput: unknown
): string => {
	const minimum = parseFiniteNumber(minimumInput);
	const maximum = parseFiniteNumber(maximumInput);
	const step = parseFiniteNumber(stepInput);
	if (
		minimum === null ||
		maximum === null ||
		step === null ||
		minimum > maximum ||
		step <= 0 ||
		(maximum - minimum) / step > 1_000_000 ||
		typeof scenariosInput !== 'string'
	)
		return '';
	let scenarios: unknown;
	try {
		scenarios = JSON.parse(scenariosInput);
	} catch {
		return '';
	}
	if (
		!Array.isArray(scenarios) ||
		!scenarios.length ||
		scenarios.some(
			(scenario) =>
				typeof scenario !== 'object' ||
				scenario === null ||
				!Number.isFinite((scenario as Scenario).coefficient) ||
				!Number.isFinite((scenario as Scenario).target)
		)
	)
		return '';
	let bestDecision = minimum;
	let bestWorstLoss = Infinity;
	const count = Math.floor((maximum - minimum) / step) + 1;
	for (let index = 0; index < count; index += 1) {
		const decision = Math.min(maximum, minimum + index * step);
		const worstLoss = Math.max(
			...(scenarios as Scenario[]).map(
				({ coefficient, target }) =>
					(coefficient * decision - target) ** 2
			)
		);
		if (worstLoss < bestWorstLoss) {
			bestWorstLoss = worstLoss;
			bestDecision = decision;
		}
	}
	return JSON.stringify(
		{
			decision: Number(bestDecision.toPrecision(12)),
			evaluatedPoints: count,
			worstCaseLoss: Number(bestWorstLoss.toPrecision(12))
		},
		null,
		2
	);
};

export const Tool: TypeTool = {
	name: 'Robust Minimax Optimization Solver',
	slug: 'optimization/robust-minimax',
	intro:
		'Find a one-dimensional decision that minimizes the worst squared loss across supplied scenarios using a bounded grid search.',
	tool: solveRobustMinimax,
	i: [
		{
			example:
				'[{"coefficient":1,"target":2},{"coefficient":2,"target":3}]',
			label: 'Scenarios',
			placeholder: 'JSON coefficient and target scenarios',
			render: 'textarea',
			type: 'text'
		},
		{
			example: '0',
			label: 'Minimum Decision',
			placeholder: 'Lower bound',
			type: 'number'
		},
		{
			example: '5',
			label: 'Maximum Decision',
			placeholder: 'Upper bound',
			type: 'number'
		},
		{
			example: '0.01',
			label: 'Grid Step',
			placeholder: 'Positive search resolution',
			type: 'number'
		}
	],
	o: [
		{
			example: '{ "decision": 1.67 }',
			label: 'Robust Solution',
			placeholder: 'Solution will appear here...',
			render: 'textarea',
			type: 'text'
		}
	]
};
export default Tool;

Description

Browse the implementation files for Robust Minimax Optimization Solver.

References

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

Similar or alternative tools