RunMat
  • Pricing
RunMat
GitHub
GitHub
Sign inTry in browser
DesktopRuntimePhysicsCADAdministrationAgent

Get RunMat updates

New releases, guides and examples.

Product+
  • Runtime
  • GPU
  • Parallel
  • Compile
  • Interop and MEX
  • Simulation
  • MCAD
  • ECAD
  • Enterprise
  • AI integrations
  • Pricing
  • Download
Math+
  • Signal processing
  • Linear algebra
  • Statistics
  • Curve fitting
  • Differential equations
  • Control systems
  • Optimization
  • Finance
  • Data and tables
  • Plotting
Physics+
  • Simulation overview
  • Structural
  • Thermal
  • Electromagnetic
  • Joule heating
  • Thermal stress
  • Acoustics
  • Fluid flow
  • Conjugate heat transfer
  • Fluid–structure
  • What is FEA
Industries+
  • Aerospace
  • Automotive and transportation
  • Defense
  • Electronics and semiconductors
  • Energy
  • Industrial machinery
  • Life sciences
  • Quantitative finance
Learn+
  • Guides
  • Docs
  • Function reference
  • Language reference
  • Migration guide
  • Changelog
  • MATLAB Online
  • MATLAB AI agent
  • For students
Compare+
  • RunMat vs MATLAB
  • RunMat vs Ansys
  • RunMat vs SOLIDWORKS
  • RunMat vs Altium
  • RunMat vs Cadence
  • RunMat vs COMSOL
  • RunMat vs Python
  • RunMat vs Julia
  • RunMat vs Physics AI
  • RunMat vs Octave
  • Benchmarks
  • MATLAB alternatives
  • All comparisons
Company+
  • About
  • Blog
  • Contact
  • Source code↗
  • License
  • Privacy
  • Terms

Product

  • Runtime
  • GPU
  • Parallel
  • Compile
  • Interop and MEX
  • Simulation
  • MCAD
  • ECAD
  • Enterprise
  • AI integrations
  • Pricing
  • Download

Math

  • Signal processing
  • Linear algebra
  • Statistics
  • Curve fitting
  • Differential equations
  • Control systems
  • Optimization
  • Finance
  • Data and tables
  • Plotting

Physics

  • Simulation overview
  • Structural
  • Thermal
  • Electromagnetic
  • Joule heating
  • Thermal stress
  • Acoustics
  • Fluid flow
  • Conjugate heat transfer
  • Fluid–structure
  • What is FEA

Industries

  • Aerospace
  • Automotive and transportation
  • Defense
  • Electronics and semiconductors
  • Energy
  • Industrial machinery
  • Life sciences
  • Quantitative finance

Learn

  • Guides
  • Docs
  • Function reference
  • Language reference
  • Migration guide
  • Changelog
  • MATLAB Online
  • MATLAB AI agent
  • For students

Compare

  • RunMat vs MATLAB
  • RunMat vs Ansys
  • RunMat vs SOLIDWORKS
  • RunMat vs Altium
  • RunMat vs Cadence
  • RunMat vs COMSOL
  • RunMat vs Python
  • RunMat vs Julia
  • RunMat vs Physics AI
  • RunMat vs Octave
  • Benchmarks
  • MATLAB alternatives
  • All comparisons

Company

  • About
  • Blog
  • Contact
  • Source code↗
  • License
  • Privacy
  • Terms
GitHubXLinkedIn

© Dystr, Inc. · RunMat v0.7.1, Nov 17, 2026

RunMat® is a registered trademark of Dystr, Inc. MATLAB® is a registered trademark of The MathWorks, Inc. RunMat is not affiliated with, endorsed by, or sponsored by The MathWorks, Inc.

/
See all docs
Builtin Reference
    • acceptancesa
    • annealingboltz
    • annealingfast
    • coneprog
    • crossoverarithmetic
    • crossoverheuristic
    • crossoverintermediate
    • crossoverlaplace
    • crossoverscattered
    • crossoversinglepoint
    • crossovertwopoint
    • eqnproblem
    • EquationProblem.solve
    • EquationProblem.subsasgn
    • EquationProblem.subsref
    • evaluate
    • fgoalattain
    • fitscalingprop
    • fitscalingrank
    • fitscalingshiftlinear
    • fitscalingtop
    • fminbnd
    • fmincon
    • fminimax
    • fminsearch
    • fminunc
    • fseminf
    • fsolve
    • fzero
    • ga
    • gacreationlinearfeasible
    • gacreationnonlinearfeasible
    • gacreationsobol
    • gacreationuniform
    • gacreationuniformint
    • gaplotbestf
    • gaplotbestindiv
    • gaplotdistance
    • gaplotexpectation
    • gaplotgenealogy
    • gaplotmaxconstr
    • gaplotrange
    • gaplotscorediversity
    • gaplotscores
    • gaplotselection
    • gaplotstopping
    • integerConstraint
    • integral
    • intlinprog
    • linprog
    • lsqcurvefit
    • lsqlin
    • LsqlinWarmStart.subsasgn
    • LsqlinWarmStart.subsref
    • lsqnonlin
    • lsqnonneg
    • mutationadaptfeasible
    • mutationgaussian
    • mutationpositivebasis
    • mutationpower
    • mutationuniform
    • optimexpr
    • optimget
    • OptimizationConstraint.evaluate
    • OptimizationConstraint.subsasgn
    • OptimizationConstraint.subsref
    • OptimizationExitflag.double
    • OptimizationExitflag.eq
    • OptimizationExitflag.ne
    • OptimizationExitflag.string
    • OptimizationExpression.acos
    • OptimizationExpression.acosh
    • OptimizationExpression.acot
    • OptimizationExpression.acoth
    • OptimizationExpression.acsc
    • OptimizationExpression.acsch
    • OptimizationExpression.asec
    • OptimizationExpression.asech
    • OptimizationExpression.asin
    • OptimizationExpression.asinh
    • OptimizationExpression.atan
    • OptimizationExpression.atanh
    • OptimizationExpression.cat
    • OptimizationExpression.cos
    • OptimizationExpression.cosh
    • OptimizationExpression.cot
    • OptimizationExpression.coth
    • OptimizationExpression.csc
    • OptimizationExpression.csch
    • OptimizationExpression.ctranspose
    • OptimizationExpression.cumprod
    • OptimizationExpression.cumsum
    • OptimizationExpression.diag
    • OptimizationExpression.diff
    • OptimizationExpression.dot
    • OptimizationExpression.eq
    • OptimizationExpression.evaluate
    • OptimizationExpression.exp
    • OptimizationExpression.ge
    • OptimizationExpression.horzcat
    • OptimizationExpression.ldivide
    • OptimizationExpression.le
    • OptimizationExpression.log
    • OptimizationExpression.mean
    • OptimizationExpression.minus
    • OptimizationExpression.mldivide
    • OptimizationExpression.mpower
    • OptimizationExpression.mrdivide
    • OptimizationExpression.mtimes
    • OptimizationExpression.norm
    • OptimizationExpression.plus
    • OptimizationExpression.power
    • OptimizationExpression.prod
    • OptimizationExpression.rdivide
    • OptimizationExpression.reshape
    • OptimizationExpression.sec
    • OptimizationExpression.sech
    • OptimizationExpression.sin
    • OptimizationExpression.sinh
    • OptimizationExpression.sqrt
    • OptimizationExpression.subsasgn
    • OptimizationExpression.subsref
    • OptimizationExpression.sum
    • OptimizationExpression.tan
    • OptimizationExpression.tanh
    • OptimizationExpression.times
    • OptimizationExpression.trace
    • OptimizationExpression.transpose
    • OptimizationExpression.uminus
    • OptimizationExpression.uplus
    • OptimizationExpression.vertcat
    • OptimizationExpression.zeros
    • OptimizationExpression.zerosLike
    • OptimizationProblem.solve
    • OptimizationProblem.subsasgn
    • OptimizationProblem.subsref
    • OptimizationVariable.subsasgn
    • OptimizationVariable.subsref
    • optimoptions
    • optimplotconstrviolation
    • optimplotfirstorderopt
    • optimplotfunccount
    • optimplotfval
    • optimplotfvalconstr
    • optimplotmilp
    • optimplotstepsize
    • optimplotx
    • optimproblem
    • optimset
    • optimvar
    • optimwarmstart
    • particleswarm
    • patternsearch
    • psplotbestf
    • psplotbestx
    • psplotfuncount
    • psplotmaxconstr
    • psplotmeshsize
    • pswcreationuniform
    • pswplotbestf
    • quad
    • quadprog
    • QuadprogWarmStart.subsasgn
    • QuadprogWarmStart.subsref
    • saplotbestf
    • saplotbestx
    • saplotf
    • saplotstopping
    • saplottemperature
    • saplotx
    • savemilpsolutions
    • secondordercone
    • selectionremainder
    • selectionroulette
    • selectionstochunif
    • selectiontournament
    • selectionuniform
    • simulannealbnd
    • solve
    • surrogateopt
    • surrogateoptplot
    • temperatureboltz
    • temperatureexp
    • temperaturefast

patternsearch — Minimize a scalar objective by feasible pattern polling and augmented-Lagrangian direct search.

patternsearch(fun,x0) performs derivative-free local search from a nonempty finite real vector. Linear constraints and bounds restrict every evaluated point. Nonlinear inequalities and equalities use slack/equality augmented-Lagrangian subproblems, each solved by feasible generating-set polling. No objective or constraint derivatives are requested.

Syntax

[x,fval,exitflag,output] = patternsearch(fun,x0)
[...] = patternsearch(fun,x0,A,b)
[...] = patternsearch(fun,x0,A,b,Aeq,beq)
[...] = patternsearch(fun,x0,A,b,Aeq,beq,lb,ub)
[...] = patternsearch(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon)
[...] = patternsearch(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon,options)
[...] = patternsearch(problem)

Inputs

fun
Type
Any
Required
Yes
Default
—
Description
Objective function handle or scalar function name; receives the original x0 vector shape and returns one finite real scalar at the initial point.
x0
Type
Any
Required
Yes
Default
—
Description
Nonempty finite real double initial vector, row or column.
A
Type
Any
Required
Yes
Default
—
Description
Real double linear-inequality matrix, dense or sparse; [] means absent with b=[].
b
Type
Any
Required
Yes
Default
—
Description
Real finite column of inequality right-hand sides, A*x<=b.
Aeq
Type
Any
Required
Yes
Default
—
Description
Real double linear-equality matrix, dense or sparse; [] means absent with beq=[].
beq
Type
Any
Required
Yes
Default
—
Description
Real finite column of equality right-hand sides, Aeq*x=beq.
lb
Type
Any
Required
Yes
Default
—
Description
Real lower bounds or []; omitted trailing coordinates are unbounded and emit a warning.
ub
Type
Any
Required
Yes
Default
—
Description
Real upper bounds or []; omitted trailing coordinates are unbounded and emit a warning.
nonlcon
Type
Any
Required
Yes
Default
—
Description
Function handle/name returning c(x)<=0 and ceq(x)=0, or []. Output extents must remain fixed.
options
Type
Any
Required
Yes
Default
—
Description
Selected patternsearch controls or []; use optimoptions('patternsearch',...). Unsupported selected algorithms and execution modes are rejected.
problem
Type
Any
Required
Yes
Default
—
Description
Required objective,x0,Aineq,bineq,Aeq,beq,lb,ub,nonlcon,options,solver='patternsearch'; optional rngstate.
NameTypeRequiredDefaultDescription
funAnyYes—Objective function handle or scalar function name; receives the original x0 vector shape and returns one finite real scalar at the initial point.
x0AnyYes—Nonempty finite real double initial vector, row or column.
AAnyYes—Real double linear-inequality matrix, dense or sparse; [] means absent with b=[].
bAnyYes—Real finite column of inequality right-hand sides, A*x<=b.
AeqAnyYes—Real double linear-equality matrix, dense or sparse; [] means absent with beq=[].
beqAnyYes—Real finite column of equality right-hand sides, Aeq*x=beq.
lbAnyYes—Real lower bounds or []; omitted trailing coordinates are unbounded and emit a warning.
ubAnyYes—Real upper bounds or []; omitted trailing coordinates are unbounded and emit a warning.
nonlconAnyYes—Function handle/name returning c(x)<=0 and ceq(x)=0, or []. Output extents must remain fixed.
optionsAnyYes—Selected patternsearch controls or []; use optimoptions('patternsearch',...). Unsupported selected algorithms and execution modes are rejected.
problemAnyYes—Required objective,x0,Aineq,bineq,Aeq,beq,lb,ub,nonlcon,options,solver='patternsearch'; optional rngstate.

Returns

x
Type
Any
Description
Last accepted real double vector with original x0 shape; an initial unevaluated point on a zero objective budget; [] for proven inconsistent linear constraints/bounds.
fval
Type
Any
Description
Actual objective value at returned x, or [] before any objective evaluation.
exitflag
Type
Any
Description
1 mesh/nonlinear complementarity; 2 measured step; 3 measured objective change; 4 represented step; 0 budget/time; -1 observer; -2 proven linear infeasibility; -4 numerical difficulty.
output
Type
Any
Description
function, problemtype, pollmethod, searchmethod, iterations, funccount, constraintcallcount, meshsize, maxconstraint, rngstate and message.
NameTypeDescription
xAnyLast accepted real double vector with original x0 shape; an initial unevaluated point on a zero objective budget; [] for proven inconsistent linear constraints/bounds.
fvalAnyActual objective value at returned x, or [] before any objective evaluation.
exitflagAny1 mesh/nonlinear complementarity; 2 measured step; 3 measured objective change; 4 represented step; 0 budget/time; -1 observer; -2 proven linear infeasibility; -4 numerical difficulty.
outputAnyfunction, problemtype, pollmethod, searchmethod, iterations, funccount, constraintcallcount, meshsize, maxconstraint, rngstate and message.

Returned values from patternsearch depend on how many outputs the caller requests.

Errors

RunMat:patternsearch:InvalidArgument
When
A selected input, callback result, option carrier or extent is invalid.
Message
patternsearch: invalid argument
IdentifierWhenMessage
RunMat:patternsearch:InvalidArgumentA selected input, callback result, option carrier or extent is invalid.patternsearch: invalid argument

Call forms and problem structures

Positional forms supply fun,x0; optionally A,b; Aeq,beq; lb,ub; nonlcon; and options in that order. Use [] for absent earlier arguments. A*x<=b and Aeq*x=beq use dense or sparse real matrices with one column per variable. Bounds can contain -Inf/Inf. Shorter bound vectors apply to their supplied leading coordinates, warn, and leave the remaining coordinates unbounded. fun and nonlcon are function handles or scalar function names.

The single-structure form requires objective, x0, Aineq, bineq, Aeq, beq, lb, ub, nonlcon, options, and solver='patternsearch'. rngstate is optional. nonlcon returns two fixed-size real vectors c and ceq for c(x)<=0 and ceq(x)=0. The initial objective and constraints must be finite and real. Later numerical NaN/Inf/complex trial values are unsuccessful trials; user exceptions and cancellation stop execution instead.

Classic polling and nonlinear constraints

Algorithm='classic' supports GPSPositiveBasis2N, GPSPositiveBasisNp1, GSSPositiveBasis2N, and GSSPositiveBasisNp1. PollOrderAlgorithm='Consecutive' streams directions without allocating a dense direction matrix. 'Random' draws an unbiased index permutation from the invocation random stream before the poll/search callbacks, without storing a dense direction matrix. rngstate can restore and report the original stream. 'Success' tries the previous winning physical direction first when it remains admissible, followed by consecutive current generators. Identical represented poll points are evaluated once. Coupled active linear rows use a feasible generating cone, including equality directions; an initially infeasible linear point is adjusted before evaluating the objective. Linear infeasibility is reported only after an original-row certificate or inconsistent bounds.

SearchFcn=[] disables the separate search phase. A supported GPS/GSS or LTMADS poll-method name selects a search before polling; identical search and poll methods are not run twice. UseCompleteSearch and UseCompletePoll select best-point evaluation across their complete direction sets; otherwise the first improving point is accepted. A partially evaluated set preserves an actual earlier improvement but cannot justify mesh contraction or convergence.

ScaleMesh uses logarithmic power-of-two coordinate scales, fixed initially for an unconstrained problem and refreshed at accepted constrained generations. Linearly equality-constrained classic search uses unit scaling. MeshRotate applies to minimal positive bases without linear equalities. AccelerateMesh increases contraction for small meshes. GSS and nonlinear subproblem polls use normalized generating directions and a quadratic sufficient-decrease condition.

Nonlinear constraints use the one-partition generating-set augmented-Lagrangian method of Kolda, Lewis, and Torczon, with nonnegative inequality slacks minimized analytically. InitialPenalty defaults to 10 and must be at least 1; PenaltyFactor defaults to 100 and must exceed 1. Multiplier or penalty updates follow a completed inner solve; no additional user callback represents a slack variable. Nonlinear MaxIterations counts completed outer subproblems, while all inner objective calls share MaxFunctionEvaluations. A positive nonlinear mesh exit also checks original feasibility and complementarity.

Mesh-adaptive polling

PollMethod='MADSPositiveBasis2N' or 'MADSPositiveBasisNp1' selects lower-triangular mesh-adaptive direct search (LTMADS). A random nonsingular integer triangular basis is generated for each poll, retaining its distinguished direction at a repeated refinement level. The 2N method adds the negated basis; the Np1 method adds the negative column sum. Random draws use the invocation stream and finish before objective or constraint callbacks.

The mesh starts at min(InitialMeshSize,1) without rounding the supplied positive scale. Successful polling expands it by four, up to one; a completed unsuccessful poll contracts it by four. MeshTolerance compares the poll measure sqrt(meshsize) for 2N and numberOfVariables*sqrt(meshsize) for Np1. StepTolerance, FunctionTolerance, PollOrderAlgorithm, MeshRotate, and AccelerateMesh do not apply to MADS polling. MeshExpansionFactor, MeshContractionFactor, and MaxMeshSize apply only when a selected GPS/GSS poll or search consumes them.

Linear equalities are not supported with an MADS poll or search. Bounds and linear inequalities use an extreme barrier: a full lattice step must satisfy the original rows before any callback. Near-active rows selected by TolBind also supply integer-quantized feasible-cone suggestions on the same mesh, while the full random positive basis remains part of the poll. Nonlinear constraints retain the slack/equality augmented-Lagrangian lifecycle and original feasibility checks. This is a constrained LTMADS variant; a small mesh is not a finite global-optimality certificate.

OrthoMADSPositiveBasis2N and OrthoMADSPositiveBasisNp1 select deterministic adjusted-Halton polling. A Halton direction is scaled and rounded to the last admissible integer direction; its scaled Householder transform supplies the basis. The 2N method adds negated columns, while Np1 adds a negative column sum. The Halton index follows the deepest refinement and otherwise advances beyond previously used indices. No random draws are needed for these frames. The same mesh transitions, original-row checks, equality restriction, selected batching, and nonlinear constraint lifecycle apply.

SearchFcn can select a supported LTMADS or OrthoMADS method with a GPS/GSS poll, or vice versa. Each phase uses its selected method's step and transition factors. A failed search alone never contracts the polling mesh. Search and poll callbacks retain the same overall evaluation budget and complete-set rules.

Latin-hypercube search

SearchFcn='searchlhs' selects Latin-hypercube sampling before polling. The default sample count is 15*numberOfVariables and the default iteration limit is one search/poll pass. A cell {@searchlhs,iterlim,level}, or a cell with the method name first, supplies positive host scalar counts for the pass limit and sample count. The limit includes inner nonlinear subproblem passes and does not reset at multiplier updates. Native integer counts use the existing structural-option extension.

Each coordinate uses an independent unbiased permutation and uniform jitter from the invocation stream. The candidate set is generated before callbacks; no random turn remains held while evaluating an objective or constraint. Finite bound pairs give the sampling interval, and fixed coordinates remain constant. With both bounds missing the interval is [-1,1]. For a one-sided bound, RunMat uses a width-two window extending from its finite endpoint, enlarged to an adjacent representable endpoint when needed; an extreme endpoint with no finite outward neighbor is constant. Original bounds and linear rows still decide which points can be evaluated.

UseCompleteSearch=true evaluates the feasible candidates and retains the best measured merit. With false, the first improvement ends the search. Selected parallel execution uses complete search, and selected vectorized or worker waves keep the same remaining objective-point budget. Infeasible linear samples and already visited cached samples do not add objective calls. A failed or exhausted sample set cannot by itself contract the polling mesh or certify convergence. Search improvements use the selected poll strategy's mesh expansion.

Latin search and mutable output callbacks retain the invocation stream before evaluating the objective. Exceptions and cancellation do not repeat evaluations. A zero point budget generates no samples and makes no search calls.

Custom search callbacks

SearchFcn=@search calls [success,xBest,fBest,funccount]=search(fun,x,A,b,Aeq,beq,lb,ub,optimValues,options). The original handle and its captured values select the callback. A same-named user function takes the custom route rather than a predefined search. Custom cell parameters are not supported; bind extra parameters in the supplied handle.

fun evaluates the current search subproblem through the original objective and nonlinear-constraint callbacks. For a nonlinear problem it returns the augmented-Lagrangian merit, not the raw objective. Original bounds and linear rows remain enforced. The current x reuses its measured generation without another callback. Undefined or cached trials return NaN; they cannot become newly measured improvements.

optimValues contains x, fval, iteration, funccount, scale, problemtype, meshsize, and method. problemtype describes the current unconstrained, bound-constrained, or linearly constrained subproblem. success must be a logical scalar. A successful result must identify the best point and merit actually measured during this search, or the unchanged current point. funccount must equal the actual additional objective attempts. Returned claims never trigger validation evaluations or change the solver counter.

UseVectorized follows the original x0 orientation: row/scalar x0 uses one point per matrix row and a merit column; column x0 uses one point per matrix column and a merit row. The same point axis applies to a single point and complete batches. Selected worker execution evaluates original objective and constraint targets through the existing worker path. Both modes share the remaining objective-point budget. UseCompleteSearch is inapplicable to custom callbacks: the callback controls its own search. A time or point limit stops the nested evaluator without authorizing more work.

The supplied fun handle is valid only while this search callback runs. It can be assigned or captured locally, but invoking an escaped handle after the callback completes raises ScopedCallable:Expired. It cannot be sent to a worker, foreign adapter, or persistent codec. Its class is function_handle; functions reports scopedcallable, and func2str returns descriptive text rather than a reconstructible function name. Original exceptions can be caught by the search callback; uncaught exceptions and cancellation stop the solver without replay.

Nelder-Mead search

SearchFcn='searchneldermead' runs a Nelder-Mead simplex search before polling, for unconstrained problems only. Bounds and linear or nonlinear constraints are rejected before the first objective evaluation. Explicit infinite bounds do not impose finite restrictions. A cell {@searchneldermead,iterlim,optionsNM} sets the positive number of Pattern passes that run this search (default one) and a scalar fminsearch options structure from optimset.

The simplex starts from the current measured point without evaluating it again. It runs to its own TolX/TolFun, MaxIter/MaxFunEvals, output-function or plot-function stopping condition, while sharing the remaining Pattern objective budget, original context, cancellation and time limit. Local counts describe only additional objective attempts. A partial limit retains an actual earlier improvement; a local Nelder-Mead stop does not certify Pattern convergence.

optionsNM supports the same implemented fminsearch controls: Display, FunValCheck, MaxIter, MaxFunEvals, TolX, TolFun, OutputFcn, and PlotFcns. Its callbacks receive normal fminsearch iteration metadata and phases. A nested observer stop ends the auxiliary search, not the outer Pattern solve. FunValCheck='on' rejects undefined auxiliary trials; otherwise undefined or skipped cached trials cannot establish simplex convergence. UseCompleteSearch does not apply.

Selected vectorized and worker modes retain their actual callback route, including one-point measurements. The simplex arithmetic, order and observers do not replay an objective for reporting or verification. Original callback exceptions and cancellation propagate rather than becoming unsuccessful simplex steps. Nelder-Mead remains a local derivative-free heuristic, not a global or first-order optimality certificate.

Genetic search

SearchFcn='searchga' runs a genetic population search before polling. The cell form {@searchga,iterlim,optionsGA} supplies a positive Pattern-pass limit (default one) and scalar ga options from optimoptions. The search runs while the enclosing completed-pass count is below iterlim, including after OutputFcn activates it; activation does not reset that count. A local genetic stop does not establish Pattern convergence. UseCompleteSearch does not select an alternate genetic algorithm.

Genetic coordinate proposals are checked against the original bounds and linear constraints before evaluation; finite sampling windows do not replace unbounded original coordinates. For nonlinear Pattern problems its fitness is the current fixed augmented-Lagrangian merit. Original objective and constraint observations remain separate from genetic ranking scores. Only a newly measured physical point can replace the outer best; supplied InitialScores or observer-edited scores cannot manufacture an outer observation.

When no initial population is supplied, RunMat includes the current point as a compatible numeric seed. Missing initial scores for an unchanged copy of that point can reuse its current observation; explicit initial scores retain precedence. Later missing scores, requested elite reevaluations, and calls to FitnessFcn make new budgeted observations even at the same coordinates. The visited-point cache does not suppress these requested genetic measurements. Genetic FunEval and callback counts exclude the inherited seed and include additional original callback attempts, including those requested from custom operators, observers, and a local hybrid.

Omitting optionsGA inherits Pattern UseVectorized and UseParallel. An explicitly supplied structure or [] uses its ga settings and defaults. Vectorized batches and selected worker waves evaluate the original objective and nonlinear callbacks, with the remaining outer point budget bounding each batch. Errors and cancellation propagate without serial replay. A nested custom callback or hybrid that tries to export the locally scoped FitnessFcn to another worker is not supported; it fails source admission instead of silently running serially.

The same genetic options, operators, OutputFcn/PlotFcn events, and supported local hybrids as ga are consumed. Custom genomes must project through their normal indexing protocol to real coordinate rows of the original variable count. Size and indexing callbacks can call FitnessFcn while their enclosing genetic event is active. A local observer stop ends only the auxiliary search. A parent budget or time stop retains completed observations and, after genetic initialization, delivers normal final events; hard cancellation and user exceptions retain their error semantics.

All work shares the enclosing cancellation, host-memory policy, random stream, original timing service, and objective-point budget. Each auxiliary MaxTime measures that invocation's elapsed duration on the original clock; the parent deadline remains independent and can stop it sooner. Selecting genetic search requires that clock before its first work. Finite host-memory execution remains unsupported. Public Pattern outputs retain the original shape, physical objective and constraints, and total original evaluation count.

Radial-basis surrogate search

SearchFcn='rbfsurrogate' forms a cubic radial-basis interpolant with an affine polynomial tail from recent finite evaluations. The search starts after at least n+1 distinct points, where n is numel(x0). After every 10*n actual objective attempts, the model and retained samples are erased; sampling restarts with subsequent points. Undefined trials count toward that reset but are not interpolation sites. Repeated coordinates keep their most recent finite measurement.

Explicit finite lower and upper bounds are retained. A missing endpoint is estimated from the recent coordinate minimum or maximum. Original linear constraints and bounds still restrict every evaluated proposal. Equality-constrained models keep full physical distances and use independent coordinates only for the affine tail. Fixed coordinates do not create artificial independent tail columns.

For nonlinear constraints, raw objective and constraint values are retained, and interpolation scores use the current augmented-Lagrangian multipliers and penalty. A multiplier update does not reuse stale merit scores. Coordinate arrays and constraint payloads share their immutable callback backing; no callback is repeated to fill a model or verify a proposed point.

RunMat minimizes the interpolant locally using feasible generating directions and box-clipped steps, with at most 8*(n+1) direction attempts per search. This is a proposal-work policy rather than a stopping certificate for the original objective. Singular, undefined or unpoised models skip the auxiliary phase. A new proposal is evaluated once through the selected scalar, vectorized or worker route, and accepted only on an actual merit improvement. UseCompleteSearch does not apply.

Nonuniform pattern search

Algorithm='nups' alternates GPS and random orthogonal polling in 16-iteration cycles. Each phase receives between two and fourteen iterations according to its measured improvement per objective point. 'nups-gps' uses only GPS; 'nups-mads' uses only the random orthogonal phase. Interior polls use coordinate rays and the positive all-ones ray, followed by their negatives. An orthogonal frame is retained across that pair, rather than redrawn for its negative half.

Linear boundary geometry adds feasible generating rays. Trial steps are shortened against the original bounds and linear rows. Linear equalities use tangent GPS generators: 'nups' uses its GPS phase only, and 'nups-mads' rejects linear equalities. Nonlinear constraints use the same augmented-Lagrangian subproblems as classic search.

A poll retains small improvements while continuing until sufficient relative decrease or exhaustion of its directions. Selected parallel execution completes the poll. PollMethod, PollOrderAlgorithm, UseCompletePoll, MeshRotate, AccelerateMesh, MeshExpansionFactor, and MeshContractionFactor are dormant NUPS controls. A poll method cannot be SearchFcn; Latin-hypercube search remains available.

RunMat uses relative decrease 1e-4, an initial 8/8 phase allocation, and the effective initial mesh as its coarse-mesh threshold. Future allocations round the measured rate proportion and clamp each phase to two through fourteen iterations; two zero rates restore 8/8. Unsuccessful polls halve the mesh. Sufficient decrease doubles it; a third consecutive small-improvement poll multiplies it by 1.5; other improvements double a coarse mesh or leave a finer mesh unchanged. These numerical choices do not specify a MATLAB-identical random trajectory.

A successful auxiliary search doubles the mesh without attributing its gain to a polling phase or changing that phase's polarity. Mesh and machine-precision convergence require a completed spanning pair, or a complete equality-tangent cone, at the current accepted point. An accepted move, changed boundary controls, changed scaling, or nonlinear merit update invalidates earlier coverage. Partial time/evaluation exhaustion cannot certify convergence.

Random draws and rngstate use the supplied execution context's stream, or the process fallback stream when no context is supplied. A foreign ambient context does not replace that stream. The same rule applies to classic random ordering, LTMADS, and Latin-hypercube search. No random turn remains held across objective, constraint, or observer callbacks.

Controls, limits, and output

Use optimoptions('patternsearch',...) or a scalar options structure. InitialMeshSize defaults to 1, MaxMeshSize to Inf, MeshExpansionFactor to 2, and MeshContractionFactor to 0.5. MeshTolerance, StepTolerance, FunctionTolerance, and ConstraintTolerance default to 1e-6. MaxIterations defaults to 100*numberOfVariables and MaxFunctionEvaluations to 2000*numberOfVariables. The dimension-dependent constructor strings are interpreted as those defaults, not evaluated as arbitrary expressions. Numeric [] selects a default.

MaxTime is a nonnegative number of seconds, a scalar duration, or Inf. A finite limit uses the invocation Clock service. An OutputFcn that can change options also retains that Clock from the start, so changing MaxTime never resets elapsed time. With no mutable output callback and MaxTime=Inf, the solver does not acquire Clock. InitialMeshSize and InitialPenalty initialize their state; changes to effective tolerances, transition factors, selected polling, and subsequent budgets apply after the callback.

The four outputs are x, fval, exitflag, and output. x retains the row/column shape of x0. fval is measured at x without a reporting evaluation; it is [] before any objective call. A zero objective budget returns an unevaluated linearly feasible initial point. Proven linear infeasibility returns x=[] and fval=[]. output includes function, problemtype, pollmethod, searchmethod, iterations, funccount, constraintcallcount, meshsize, maxconstraint, rngstate, and message. funccount counts evaluated objective points, including each point in a vectorized call; constraintcallcount separately counts actual nonlinear callback invocations. rngstate records the original stream before callback execution when requested.

Exitflag 1 means the mesh/feasibility conditions pass, including nonlinear complementarity where applicable. Flags 2 and 3 use measured accepted-point or objective change after an unsuccessful sufficiently small poll; 4 means no represented feasible step changes the point. Flag 0 is an objective, completed-iteration, or time limit; -1 is observer stop; -2 is proven linear infeasibility; -4 is numerical difficulty. Positive flags describe local numerical stopping, not a global minimum certificate.

Vectorized and parallel evaluation

UseVectorized=true passes complete search/poll sets in one numeric matrix. For row or scalar x0, points are rows and objective values form a column. For column x0, points are columns and objective values form a row. Nonlinear constraint matrices use the same point axis and one component axis per constraint. Empty constraint outputs are allowed. Functions must also accept a single point. With incomplete polling/searching, points are evaluated individually with that same orientation.

UseParallel='auto' uses an eligible existing selected native/browser worker pool or computes serially when no eligible pool is available. 'on' requires a selected worker route and can create its normal pool. Selected source and capture eligibility remain required. Worker failures and user errors stop the solve without serial replay. A selected parallel request enables complete polling/searching and disables caching; cache controls are not read in that mode.

Vectorized evaluation takes precedence over UseParallel, so a dormant parallel selector is not inspected. Every batch contains only points that pass the original linear constraints and bounds. The remaining MaxFunctionEvaluations limit bounds its point count. A budget-interrupted set retains its best evaluated point without treating the incomplete set as an unsuccessful full poll. Mutable output options take effect before the next batch.

Output functions, plots, and display

OutputFcn is a handle or cell of handles called as [stop,options,optchanged]=f(optimvalues,options,flag). stop and optchanged are logical scalars. With optchanged=true during init or iter, the replacement options are admitted for subsequent iterations while the old callback generation remains available. The nonlinear interrupt phase reports inner-subproblem metrics, permits stop, and ignores option changes. done is the final phase and does not apply new options.

optimvalues contains x, iteration, fval, meshsize, funccount, method, TolFun, and TolX; nonlinear problems also include nonlinineq and nonlineq. Unknown changes before a second accepted best point are []. Output and plot calls do not consume the objective budget. PlotFcn accepts custom handles or psplotbestf, psplotfuncount, psplotmeshsize, psplotbestx, and psplotmaxconstr. Plot callbacks use stop=f(optimvalues,flag); PlotInterval controls major-iteration plotting. Selected plots require the plot-core UI service. Display='off' or 'none' suppresses console output; 'iter' reports iterations; 'final' reports the final reason; 'diagnose' also reports problem dimensions and active numerical controls before iteration.

Supported data and remaining algorithms

Host double data are the ordinary numerical interface. Single data, exact native-integer/logical numeric data, native-integer controls, and explicit gpuArray gathering are separate RunMat compatibility extensions. Automatic-residency numeric carriers can be gathered without the explicit-gpu extension; unproven residency intent is refused. Counts preserve native integer exactness; converted numeric values must fit the exact double boundary. Callback captures are not gathered as control data. Solver outputs are double, and computation is on the host.

Cache='on' retains a bounded visited-point history and omits poll points within CacheTol of that history without another objective or constraint call. CacheSize is a positive integer (default 10000), and CacheTol is finite positive (default eps). Use caching only for deterministic callbacks. A near match can hide an improvement, so keep CacheTol small. Cached coordinates are not published as newly measured nearby points. Nonlinear multiplier/penalty updates clear the previous merit generation's history. The callback-array backing is shared with history; caching does not gather captures or custom metadata.

Finite host-memory execution is unsupported and fails before callbacks or solver workspaces. Long numerical loops, sparse geometry, and callback boundaries cooperate with cancellation and yielding. Optional rngstate restores the original selected random stream; no random turn remains held across user callbacks.

Genetic search, custom handles, cubic RBF surrogate search, unconstrained Nelder-Mead, GPS/GSS, LTMADS, and OrthoMADS poll-method searches are supported. The five predefined psplot helpers update the selected progress axes.

Examples

Minimize a quadratic with column-shaped x

opts = optimoptions('patternsearch','Display','off');
[x,fval,flag,out] = patternsearch(@(x) sum((x-[2;-1]).^2),[0;0],[],[],[],[],[],[],[],opts)

Keep every poll inside linear bounds

opts = optimoptions('patternsearch','Display','off');
[x,fval,flag] = patternsearch(@(x) -sum(x),[0 0],[1 1],1,[],[],[0 0],[],[],opts)

Minimize subject to a nonlinear ball

opts = optimoptions('patternsearch','Display','off','MaxFunctionEvaluations',20000,'MaxIterations',200);
nonlcon = @(x) deal(sum(x.^2)-1,[]);
[x,fval,flag] = patternsearch(@(x) sum(x.^2),[1 0],[],[],[],[],[],[],nonlcon,opts)

Evaluate a complete pattern with row-oriented points

opts = optimoptions('patternsearch','Display','off','UseVectorized',true,'UseCompletePoll',true);
fun = @(X) sum((X-[2 -1]).^2,2);
[x,fval,flag] = patternsearch(fun,[0 0],[],[],[],[],[],[],[],opts)

Poll the previous successful direction first

opts = optimoptions('patternsearch','Display','off','PollOrderAlgorithm','Success','ScaleMesh',false,'MaxFunctionEvaluations',4);
[x,fval,flag] = patternsearch(@(x) x(1)^2+(x(2)-3)^2,[0 0],[],[],[],[],[],[],[],opts)

Use mesh-adaptive polling with an upper bound

opts = optimoptions('patternsearch','Display','off','PollMethod','MADSPositiveBasis2N','ScaleMesh',false,'MeshTolerance',1e-3);
[x,fval,flag,out] = patternsearch(@(x) (x-2)^2,0,[],[],[],[],[],1,[],opts)

Use deterministic orthogonal polling

opts = optimoptions('patternsearch','Display','off','PollMethod','OrthoMADSPositiveBasis2N','ScaleMesh',false,'MeshTolerance',1e-3);
[x,fval,flag] = patternsearch(@(x) (x-2)^2,0,[],[],[],[],[],1,[],opts)

Search a bounded interval with Latin-hypercube points

opts = optimoptions('patternsearch','Display','off','SearchFcn','searchlhs','UseCompleteSearch',true,'MaxFunctionEvaluations',16);
[x,fval,flag,out] = patternsearch(@(x) -x,0,[],[],[],[],0,1,[],opts)

Measure a custom search point through the supplied function

opts=optimoptions('patternsearch','Display','off','SearchFcn',@searchpoint,'MaxIterations',1);
[x,fval,flag,out]=patternsearch(@(x) (x-0.25)^2,0,[],[],[],[],[],[],[],opts);
function [success,xBest,fBest,funccount]=searchpoint(fun,x,A,b,Aeq,beq,lb,ub,optimValues,options)
xBest=0.25; fBest=fun(xBest); funccount=1; success=fBest<optimValues.fval;
end

Use a one-evaluation auxiliary simplex budget

local=optimset('Display','off','MaxFunEvals',1);
opts=optimoptions('patternsearch','Display','off','SearchFcn',{@searchneldermead,1,local},'MaxIterations',1);
[x,fval,flag,out]=patternsearch(@(x) (x-1)^2,0,[],[],[],[],[],[],[],opts)

Reuse the current observation in an initial genetic population

local=optimoptions('ga','Display','off','PopulationSize',2,'EliteCount',2,'InitialPopulationMatrix',[0;0],'MaxGenerations',0);
opts=optimoptions('patternsearch','Display','off','ScaleMesh',false,'SearchFcn',{@searchga,1,local},'MaxIterations',1,'MaxFunctionEvaluations',2);
[x,fval,flag,out]=patternsearch(@(x) (x-1)^2,0,[],[],[],[],[],[],[],opts)

Use recent samples for a radial-basis proposal

opts=optimoptions('patternsearch','Display','off','SearchFcn','rbfsurrogate','ScaleMesh',false,'MaxFunctionEvaluations',100);
[x,fval,flag,out]=patternsearch(@(x) (x-1.2)^2,0,[],[],[],[],0,3,[],opts)

Use nonuniform GPS with an active upper bound

opts = optimoptions('patternsearch','Algorithm','nups-gps','Display','off','ScaleMesh',false,'MeshTolerance',1e-3);
[x,fval,flag,out] = patternsearch(@(x) (x-2)^2,0,[],[],[],[],0,1,[],opts)

Using patternsearch with coding agents

Open a RunMat example with live inputs, then ask the agent to explain how patternsearch changes the result.

Run a small patternsearch example, explain the result, then change one input and compare the output.

FAQ

Does a small mesh establish a global minimum?⌄

No. It reports local numerical stopping for the evaluated objective and constraints; undefined trials, nonsmoothness, scaling, and conditioning can affect convergence.

Related Math functions

Optim

acceptancesa · annealingboltz · annealingfast · coneprog · crossoverarithmetic · crossoverheuristic · crossoverintermediate · crossoverlaplace · crossoverscattered · crossoversinglepoint · crossovertwopoint · eqnproblem · EquationProblem.solve · EquationProblem.subsasgn · EquationProblem.subsref · evaluate · fgoalattain · fitscalingprop · fitscalingrank · fitscalingshiftlinear · fitscalingtop · fminbnd · fmincon · fminimax · fminsearch · fminunc · fseminf · fsolve · fzero · ga · gacreationlinearfeasible · gacreationnonlinearfeasible · gacreationsobol · gacreationuniform · gacreationuniformint · gaplotbestf · gaplotbestindiv · gaplotdistance · gaplotexpectation · gaplotgenealogy · gaplotmaxconstr · gaplotrange · gaplotscorediversity · gaplotscores · gaplotselection · gaplotstopping · integerConstraint · integral · intlinprog · linprog · lsqcurvefit · lsqlin · LsqlinWarmStart.subsasgn · LsqlinWarmStart.subsref · lsqnonlin · lsqnonneg · mutationadaptfeasible · mutationgaussian · mutationpositivebasis · mutationpower · mutationuniform · optimexpr · optimget · OptimizationConstraint.evaluate · OptimizationConstraint.subsasgn · OptimizationConstraint.subsref · OptimizationExitflag.double · OptimizationExitflag.eq · OptimizationExitflag.ne · OptimizationExitflag.string · OptimizationExpression.acos · OptimizationExpression.acosh · OptimizationExpression.acot · OptimizationExpression.acoth · OptimizationExpression.acsc · OptimizationExpression.acsch · OptimizationExpression.asec · OptimizationExpression.asech · OptimizationExpression.asin · OptimizationExpression.asinh · OptimizationExpression.atan · OptimizationExpression.atanh · OptimizationExpression.cat · OptimizationExpression.cos · OptimizationExpression.cosh · OptimizationExpression.cot · OptimizationExpression.coth · OptimizationExpression.csc · OptimizationExpression.csch · OptimizationExpression.ctranspose · OptimizationExpression.cumprod · OptimizationExpression.cumsum · OptimizationExpression.diag · OptimizationExpression.diff · OptimizationExpression.dot · OptimizationExpression.eq · OptimizationExpression.evaluate · OptimizationExpression.exp · OptimizationExpression.ge · OptimizationExpression.horzcat · OptimizationExpression.ldivide · OptimizationExpression.le · OptimizationExpression.log · OptimizationExpression.mean · OptimizationExpression.minus · OptimizationExpression.mldivide · OptimizationExpression.mpower · OptimizationExpression.mrdivide · OptimizationExpression.mtimes · OptimizationExpression.norm · OptimizationExpression.plus · OptimizationExpression.power · OptimizationExpression.prod · OptimizationExpression.rdivide · OptimizationExpression.reshape · OptimizationExpression.sec · OptimizationExpression.sech · OptimizationExpression.sin · OptimizationExpression.sinh · OptimizationExpression.sqrt · OptimizationExpression.subsasgn · OptimizationExpression.subsref · OptimizationExpression.sum · OptimizationExpression.tan · OptimizationExpression.tanh · OptimizationExpression.times · OptimizationExpression.trace · OptimizationExpression.transpose · OptimizationExpression.uminus · OptimizationExpression.uplus · OptimizationExpression.vertcat · OptimizationExpression.zeros · OptimizationExpression.zerosLike · OptimizationProblem.solve · OptimizationProblem.subsasgn · OptimizationProblem.subsref · OptimizationVariable.subsasgn · OptimizationVariable.subsref · optimoptions · optimplotconstrviolation · optimplotfirstorderopt · optimplotfunccount · optimplotfval · optimplotfvalconstr · optimplotmilp · optimplotstepsize · optimplotx · optimproblem · optimset · optimvar · optimwarmstart · particleswarm · psplotbestf · psplotbestx · psplotfuncount · psplotmaxconstr · psplotmeshsize · pswcreationuniform · pswplotbestf · quad · quadprog · QuadprogWarmStart.subsasgn · QuadprogWarmStart.subsref · saplotbestf · saplotbestx · saplotf · saplotstopping · saplottemperature · saplotx · savemilpsolutions · secondordercone · selectionremainder · selectionroulette · selectionstochunif · selectiontournament · selectionuniform · simulannealbnd · solve · surrogateopt · surrogateoptplot · temperatureboltz · temperatureexp · temperaturefast

Elementwise

abs · angle · besselj · bsxfun · complex · conj · double · eps · erf · erfcinv · exp · expm1 · flintmax · gamma · gammaln · heaviside · hypot · imag · int16 · int32 · int64 · int8 · intmax · intmin · ldivide · log · log10 · log1p · log2 · minus · nextpow2 · plus · pow2 · power · rdivide · real · realmax · realmin · realsqrt · rescale · sign · single · sqrt · times · typecast · uint16 · uint32 · uint64 · uint8

Trigonometry

acos · acosd · acosh · acotd · acscd · asecd · asin · asind · asinh · atan · atan2 · atan2d · atand · atanh · cos · cosd · cosh · cospi · deg2rad · pol2cart · rad2deg · sin · sind · sinh · sinpi · tan · tand · tanh

Reduction

all · any · bounds · cummax · cummin · cumprod · cumsum · cumtrapz · diff · gradient · max · maxk · mean · median · min · mink · movmax · movmean · movmedian · movmin · movprod · movstd · movsum · movvar · nnz · prod · rms · std · sum · trapz · var

Structure

bandwidth · isdiag · ishermitian · issymmetric · istril · istriu · symrcm

Bitwise

bitand · bitcmp · bitget · bitor · bitset · bitshift · bitxor · swapbytes

Signal

blackman · butter · buttord · cheb2ord · conv · conv2 · deconv · downsample · envelope · filter · filtfilt · fir1 · freqz · gauspuls · hamming · hann · hilbert · periodogram · pulstran · pwelch · rectpuls · resample · sawtooth · sinc · spectrogram · square · tripuls · unwrap · upsample · zplane

Rounding

ceil · fix · floor · mod · rem · round

Factor

chol · decomposition · decomposition.ctranspose · decomposition.mldivide · decomposition.mrdivide · decomposition.mtimes · decomposition.rdivide · decomposition.subsref · decomposition.times · decomposition.uminus · decomposition.uplus · eig · eigs · gmres · ichol · ilu · lu · ordeig · ordqz · ordschur · pcg · qr · qz · rsf2csf · schur · svd

Solve

cond · det · inv · linsolve · norm · null · pinv · rank · rcond · rref · vecnorm

Ops

cross · ctranspose · dot · mldivide · mpower · mrdivide · mtimes · pagemtimes · pagetranspose · trace · transpose

Symbolic

digits · int · limit · piecewise · sym · syms · vpa

Discrete

factor · factorial · gcd · isprime · lcm · primes

Fft

fft · fft2 · fftn · fftshift · ifft · ifft2 · ifftn · ifftshift

Interpolation

griddedInterpolant · griddedInterpolant.subsref · interp1 · interp1q · interp2 · pchip · ppval · spline

Integer Division

idivide

Ode

ode15s · ode23 · ode45 · odeset

Poly

poly · polyder · polyfit · polyint · polyval · roots

Source you can read

Every RunMat function's source is public. Read exactly how patternsearch is executed, line by line, in Rust.

  • View the source for patternsearch in Rust on GitHub
  • Learn how the RunMat runtime works
  • Found a bug? Open an issue with a minimal reproduction.

About RunMat

RunMat is a runtime that executes MATLAB-syntax code fast on any GPU. The runtime is free for individuals, including freelancers; students and faculty at an academic institution, for teaching or research there; contributors to an open-source project, for work on that project; organizations with 250 or fewer people and US$10M or less in annual revenue; and anyone, for non-production use. See runmat.com/license.

  • RunMat automatically optimizes your math for GPU execution on Apple, Nvidia, and AMD hardware. No code changes needed. Simulations that took hours now take minutes.
  • Start running code in seconds. RunMat runs in the browser, on the desktop, or from the CLI. No license server, no IT ticket.

Getting started · Benchmarks · Pricing

Download RunMat

Download RunMat for full performance, or use RunMat in your browser for zero setup.

Download RunMatOpen Sandbox
On this page
  • Syntax
  • Inputs
  • Returns
  • Errors
  • Call forms and problem structures
  • Classic polling and nonlinear constraints
  • Mesh-adaptive polling
  • Latin-hypercube search
  • Custom search callbacks
  • Nelder-Mead search
  • Genetic search
  • Radial-basis surrogate search
  • Nonuniform pattern search
  • Controls, limits, and output
  • Vectorized and parallel evaluation
  • Output functions, plots, and display
  • Supported data and remaining algorithms
  • Examples
  • Minimize a quadratic with column-shaped x
  • Keep every poll inside linear bounds
  • Minimize subject to a nonlinear ball
  • Evaluate a complete pattern with row-oriented points
  • Poll the previous successful direction first
  • Use mesh-adaptive polling with an upper bound
  • Use deterministic orthogonal polling
  • Search a bounded interval with Latin-hypercube points
  • Measure a custom search point through the supplied function
  • Use a one-evaluation auxiliary simplex budget
  • Reuse the current observation in an initial genetic population
  • Use recent samples for a radial-basis proposal
  • Use nonuniform GPS with an active upper bound
  • Using patternsearch with coding agents
  • FAQ
  • Related Math functions
  • Optim
  • Elementwise
  • Trigonometry
  • Reduction
  • Structure
  • Bitwise
  • Signal
  • Rounding
  • Factor
  • Solve
  • Ops
  • Symbolic
  • Discrete
  • Fft
  • Interpolation
  • Integer Division
  • Ode
  • Poly
  • Source you can read
  • About RunMat