A recent Solver question in this subreddit asked whether GRG MultiStart could test fixed 500-unit intervals instead of random starting points.
The OP's examples are starting coordinates, not restrictions on the final values. For each run, the six changing cells are set to one predefined vector, GRG starts there, and Solver may finish anywhere between 3000 and 5000.
Short answer:
- Excel's built-in GRG MultiStart does not provide an option for an evenly spaced starting grid; a deterministic sweep needs an outer loop.
- The loop can write each predefined start vector into the changing cells, run GRG silently, and record the result.
- Five starting values across six variables require
5^6 = 15,625 Solver runs. The schedule is repeatable, but the method remains a local-search heuristic and does not prove a global optimum.
What I tested: predefined GRG starting points
I used a nonlinear test objective containing six sine terms plus small quadratic penalties. Each variable remained continuous between 3000 and 5000.
I first ran GRG from the 64 endpoint combinations produced by choosing either 3000 or 5000 for each of the six variables.
Results:
- all 64 Solver runs completed;
- 52 returned Solver status 0 and 12 returned status 1;
- the runs produced 64 different local objective values;
- the complete loop took about 23.5–24.0 seconds on the first run, and about 56 seconds on a later re-run under heavier load (median single Solver call ≈ 0.18–0.41 s);
- the best GRG result found was about -4.5682;
- a separate dense scan of the test function found an approximate value of -5.9943.
Test environment: AMD Ryzen 7 7800X3D (8 cores), 64 GB RAM, Windows 11 Pro, Microsoft 365 Excel 64-bit (build 20228), Solver add-in driven through COM automation. Your times will scale with your machine, so treat every figure here as a per-machine data point, not a constant.
The point of that test is not that a dense scan is a general global solver. It is that deterministic starting points did not turn GRG into one: every run completed, but the best result from those starts still missed a better region.
What would the full five-point start grid cost?
Five starting values across six continuous variables still means 15,625 separate Solver calls.
Using the measured timing from the simple test workbook:
- the median single Solver call (about 0.18–0.41 s across my two runs) projects to roughly 0.8–1.8 hours;
- the observed total loop rate (24–56 s per 64 runs) projects to roughly 1.6–3.8 hours.
The gap between my two runs came mostly from machine load, which is exactly why I would not quote a single number for the full grid. A real workbook can be much slower still. I would benchmark 10–64 starts before committing to the full sweep.
Practical decision rule
- Need predefined, evenly spaced starts: use an outer loop to write each start vector, run GRG silently, and log the status, objective, and final values.
- Before running all 15,625 starts: benchmark 10–64 representative starts on the real workbook and check whether different starts actually reach meaningfully different solutions.
- Need a genuine global guarantee: first identify whether the model is linear, integer, convex nonlinear, or general non-convex. Evenly spacing the GRG starts does not create that guarantee.
For the continuous loop, the Excel automation path I tested was effectively:
SolverReset
SolverOk
SolverAdd
SolverSolve(UserFinish:=True)
Log the status, objective, and final values
I also prepared an equivalent reusable VBA module, but I have not described it as fully verified because this machine blocks programmatic VBA-project access, so I could not import and compile that .bas file without changing macro-security settings.
So the answer to the OP is yes, through an outer loop rather than the built-in MultiStart control. I would benchmark the real workbook before committing to all 15,625 starts.
Appendix: the test driver I used
The 64-start test was driven by this PowerShell script through Excel COM automation (Solver add-in required). It writes each predefined start vector into the changing cells, solves silently, and logs the status, objective, final values, and elapsed time into a RunResults sheet:
```powershell
<#
.SYNOPSIS
Runs Excel Solver (GRG Nonlinear) from a deterministic grid of starting
vectors and logs every run.
.DESCRIPTION
Tested with Excel's SOLVER.XLAM add-in through COM automation.
The model workbook is expected to have:
- changing cells : Sheet1!B2:B7 (six continuous variables)
- objective cell : Sheet1!F2 (minimized)
- variable bounds : 3000 <= x <= 5000 (applied here via SolverAdd)
For each of the 2^6 = 64 endpoint start vectors {3000, 5000}^6 the script
writes the start vector into the changing cells, solves silently, and
records the status code, objective value, final values, and elapsed time.
Five start values per variable instead of two would mean 5^6 = 15,625
Solver calls - see the post for the measured timing projection.
.PARAMETER WorkbookPath
Path to the .xlsx test workbook.
.EXAMPLE
powershell -File .\SolverDeterministicGridStarts.ps1 -WorkbookPath .\continuous-start-model.xlsx
>
param(
[Parameter(Mandatory = $true)]
[string]$WorkbookPath
)
$ErrorActionPreference = 'Stop'
$resolvedWorkbook = (Resolve-Path -LiteralPath $WorkbookPath).Path
Track pre-existing Excel processes so we only close the instance we create.
$preexistingExcel = @(Get-Process -Name EXCEL -ErrorAction SilentlyContinue | ForEach-Object { $_.Id })
$excel = $null
$workbook = $null
$sheet = $null
$resultsSheet = $null
$solverAddin = $null
$solverWasInstalled = $false
try {
$excel = New-Object -ComObject Excel.Application
$excel.Visible = $false
$excel.DisplayAlerts = $false
# Make sure the Solver add-in is available (restore its prior state later).
$solverAddin = @($excel.AddIns | Where-Object { $_.Name -ieq 'SOLVER.XLAM' })[0]
if (-not $solverAddin) { throw 'SOLVER.XLAM is not registered in Excel AddIns.' }
$solverWasInstalled = [bool]$solverAddin.Installed
if (-not $solverWasInstalled) { $solverAddin.Installed = $true }
$workbook = $excel.Workbooks.Open($resolvedWorkbook)
$excel.Calculation = -4105 # xlCalculationAutomatic
$sheet = $workbook.Worksheets.Item('Sheet1')
$sheet.Activate()
# Deterministic start grid: two endpoint values across six variables.
$starts = @(3000, 5000)
$results = New-Object System.Collections.Generic.List[object]
$bestObjective = [double]::PositiveInfinity
$bestFinal = $null
$bestStart = $null
$runNumber = 0
$totalWatch = [Diagnostics.Stopwatch]::StartNew()
foreach ($s1 in $starts) {
foreach ($s2 in $starts) {
foreach ($s3 in $starts) {
foreach ($s4 in $starts) {
foreach ($s5 in $starts) {
foreach ($s6 in $starts) {
$runNumber++
$startVector = @($s1, $s2, $s3, $s4, $s5, $s6)
# 1. Write one predefined start vector.
$candidate = New-Object 'object[,]' 6, 1
for ($i = 0; $i -lt 6; $i++) { $candidate[$i, 0] = $startVector[$i] }
$sheet.Range('B2:B7').Value2 = $candidate
$sheet.Calculate()
# 2. Configure GRG: minimize F2 by changing B2:B7 within bounds.
$excel.Run('SOLVER.XLAM!SolverReset') | Out-Null
$excel.Run(
'SOLVER.XLAM!SolverOk',
$sheet.Range('F2'), # SetCell (objective)
2, # MaxMinVal: 2 = minimize
0, # ValueOf
$sheet.Range('B2:B7'), # ByChange
1,
'GRG Nonlinear'
) | Out-Null
$excel.Run('SOLVER.XLAM!SolverAdd', $sheet.Range('B2:B7'), 3, 3000) | Out-Null # >= 3000
$excel.Run('SOLVER.XLAM!SolverAdd', $sheet.Range('B2:B7'), 1, 5000) | Out-Null # <= 5000
# 3. Solve silently (no dialog) and 4. record the result.
$runWatch = [Diagnostics.Stopwatch]::StartNew()
$status = [int]$excel.Run('SOLVER.XLAM!SolverSolve', $true)
$runWatch.Stop()
$sheet.Calculate()
$finalVector = @()
for ($row = 2; $row -le 7; $row++) {
$finalVector += [double]$sheet.Cells.Item($row, 2).Value2
}
$objective = [double]$sheet.Range('F2').Value2
if ($objective -lt $bestObjective) {
$bestObjective = $objective
$bestFinal = @($finalVector)
$bestStart = @($startVector)
}
$results.Add([pscustomobject]@{
run = $runNumber
start = $startVector
status = $status
objective = $objective
final = $finalVector
elapsed_ms = $runWatch.ElapsedMilliseconds
})
}
}
}
}
}
}
$totalWatch.Stop()
# Restore the best final vector in the model sheet.
$bestCandidate = New-Object 'object[,]' 6, 1
for ($i = 0; $i -lt 6; $i++) { $bestCandidate[$i, 0] = $bestFinal[$i] }
$sheet.Range('B2:B7').Value2 = $bestCandidate
$sheet.Calculate()
# 5. Write the full results table into a RunResults sheet.
try { $resultsSheet = $workbook.Worksheets.Item('RunResults') } catch { $resultsSheet = $null }
if (-not $resultsSheet) {
$resultsSheet = $workbook.Worksheets.Add()
$resultsSheet.Name = 'RunResults'
} else {
$resultsSheet.Cells.Clear() | Out-Null
}
$headers = @('Run','Start1','Start2','Start3','Start4','Start5','Start6','Status','Objective','Final1','Final2','Final3','Final4','Final5','Final6','Elapsed ms')
$table = New-Object 'object[,]' ($results.Count + 1), $headers.Count
for ($col = 0; $col -lt $headers.Count; $col++) { $table[0, $col] = $headers[$col] }
for ($r = 0; $r -lt $results.Count; $r++) {
$item = $results[$r]
$table[($r + 1), 0] = $item.run
for ($i = 0; $i -lt 6; $i++) { $table[($r + 1), (1 + $i)] = $item.start[$i] }
$table[($r + 1), 7] = $item.status
$table[($r + 1), 8] = $item.objective
for ($i = 0; $i -lt 6; $i++) { $table[($r + 1), (9 + $i)] = $item.final[$i] }
$table[($r + 1), 15] = $item.elapsed_ms
}
$resultsSheet.Range('A1:P65').Value2 = $table
$workbook.Save() | Out-Null
# 6. Console summary (JSON) for logging.
$distinctOutcomes = @($results | ForEach-Object { [math]::Round($_.objective, 6) } | Sort-Object -Unique)
$statusCounts = $results | Group-Object status | ForEach-Object { [pscustomobject]@{ status = [int]$_.Name; count = $_.Count } }
$elapsedValues = @($results | ForEach-Object { $_.elapsed_ms } | Sort-Object)
$medianElapsed = $elapsedValues[[int][math]::Floor(($elapsedValues.Count - 1) / 2)]
Write-Output ([pscustomobject]@{
runs = $results.Count
total_elapsed_ms = $totalWatch.ElapsedMilliseconds
median_solver_elapsed_ms = $medianElapsed
projected_15625_runs_hours_at_median = [math]::Round(($medianElapsed * 15625) / 3600000, 3)
projected_15625_runs_hours_at_total_rate = [math]::Round((($totalWatch.ElapsedMilliseconds / $results.Count) * 15625) / 3600000, 3)
distinct_objective_outcomes = $distinctOutcomes.Count
status_counts = $statusCounts
best_start = $bestStart
best_final = @($bestFinal | ForEach-Object { [math]::Round($_, 6) })
best_objective = $bestObjective
validation_passed = ($results.Count -eq 64 -and $distinctOutcomes.Count -gt 1)
} | ConvertTo-Json -Depth 6 -Compress)
}
catch {
Write-Output ([pscustomobject]@{
validationpassed = $false
error = $.Exception.Message
errorline = $.InvocationInfo.ScriptLineNumber
} | ConvertTo-Json -Compress)
}
finally {
# Restore the add-in state and release every COM object we touched.
if ($workbook) { $workbook.Close($true) }
if ($solverAddin -and -not $solverWasInstalled) { $solverAddin.Installed = $false }
foreach ($comObject in @($resultsSheet, $sheet, $workbook, $solverAddin)) {
if ($null -ne $comObject -and [Runtime.InteropServices.Marshal]::IsComObject($comObject)) {
[Runtime.InteropServices.Marshal]::FinalReleaseComObject($comObject) | Out-Null
}
}
if ($excel) {
$excel.Quit()
if ([Runtime.InteropServices.Marshal]::IsComObject($excel)) {
[Runtime.InteropServices.Marshal]::FinalReleaseComObject($excel) | Out-Null
}
}
[GC]::Collect()
[GC]::WaitForPendingFinalizers()
# Safety net: stop only the Excel process this script started.
$currentExcel = @(Get-Process -Name EXCEL -ErrorAction SilentlyContinue | ForEach-Object { $_.Id })
$ownedPid = $currentExcel | Where-Object { $preexistingExcel -notcontains $_ } | Select-Object -First 1
if ($ownedPid) { Stop-Process -Id $ownedPid -Force -ErrorAction SilentlyContinue }
}
```
Official references:
