Bookmark this: tool.io/optimization/non-convex-multistart/source-code
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.