Skip to content

Main content

Non-Convex Multistart Solver Source Code

Browse the implementation files for Non-Convex Multistart Solver.
tool.ts typescript
import { parseFiniteNumber } from '../../parse/number/tool';
import { parseInteger } from '../../parse/integer/tool';

const functions = {
	'double-well': {
		gradient: (x: number) => 4 * x * (x * x - 1),
		value: (x: number) => (x * x - 1) ** 2
	},
	'rastrigin-1d': {
		gradient: (x: number) =>
			2 * x + 20 * Math.PI * Math.sin(2 * Math.PI * x),
		value: (x: number) =>
			x * x - 10 * Math.cos(2 * Math.PI * x) + 10
	}
};
export const solveNonConvexMultistart = (
	functionInput: unknown,
	minimumInput: unknown,
	maximumInput: unknown,
	startsInput: unknown,
	iterationsInput: unknown,
	learningRateInput: unknown
): string => {
	const definition =
		typeof functionInput === 'string'
			? functions[functionInput as keyof typeof functions]
			: undefined;
	const minimum = parseFiniteNumber(minimumInput);
	const maximum = parseFiniteNumber(maximumInput);
	const starts = parseInteger(startsInput);
	const iterations = parseInteger(iterationsInput);
	const learningRate = parseFiniteNumber(learningRateInput);
	if (
		!definition ||
		minimum === null ||
		maximum === null ||
		minimum >= maximum ||
		starts === null ||
		starts < 2 ||
		starts > 10_000 ||
		iterations === null ||
		iterations < 1 ||
		iterations > 100_000 ||
		starts * iterations > 10_000_000 ||
		learningRate === null ||
		learningRate <= 0
	)
		return '';
	let bestX = minimum;
	let bestValue = Infinity;
	for (let start = 0; start < starts; start += 1) {
		let x =
			minimum + (start / (starts - 1)) * (maximum - minimum);
		for (
			let iteration = 0;
			iteration < iterations;
			iteration += 1
		) {
			const next = x - learningRate * definition.gradient(x);
			if (!Number.isFinite(next)) return '';
			x = Math.min(maximum, Math.max(minimum, next));
		}
		const value = definition.value(x);
		if (!Number.isFinite(value)) return '';
		if (value < bestValue) {
			bestValue = value;
			bestX = x;
		}
	}
	return JSON.stringify(
		{
			function: functionInput,
			minimum: Number(bestValue.toPrecision(12)),
			x: Number(bestX.toPrecision(12))
		},
		null,
		2
	);
};

export const Tool: TypeTool = {
	name: 'Non-Convex Multistart Solver',
	slug: 'optimization/non-convex-multistart',
	intro:
		'Run bounded multistart gradient descent on a selected one-dimensional non-convex benchmark.',
	tool: solveNonConvexMultistart,
	i: [
		{
			example: 'double-well',
			label: 'Function',
			options: [
				{ text: 'Double well', value: 'double-well' },
				{ text: 'Rastrigin 1D', value: 'rastrigin-1d' }
			],
			placeholder: 'Benchmark function',
			type: 'select'
		},
		{
			example: '-3',
			label: 'Minimum X',
			placeholder: 'Lower bound',
			type: 'number'
		},
		{
			example: '3',
			label: 'Maximum X',
			placeholder: 'Upper bound',
			type: 'number'
		},
		{
			example: '21',
			label: 'Starting Points',
			placeholder: 'Number of starts',
			type: 'number'
		},
		{
			example: '200',
			label: 'Iterations',
			placeholder: 'Iterations per start',
			type: 'number'
		},
		{
			example: '0.01',
			label: 'Learning Rate',
			placeholder: 'Positive step size',
			type: 'number'
		}
	],
	o: [
		{
			example: '{ "x": -1, "minimum": 0 }',
			label: 'Best Solution',
			placeholder: 'Solution will appear here...',
			render: 'textarea',
			type: 'text'
		}
	],
	cite: [
		{
			title: 'Non-convex optimization - Wikipedia',
			url: 'https://en.wikipedia.org/wiki/Non-convex_optimization'
		}
	]
};
export default Tool;

Description

Browse the implementation files for Non-Convex Multistart Solver.

References

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

Similar or alternative tools