optimize

type Bound struct {
	Lo, Hi float64
}

type BracketError struct {
	Xa, Xb, Xc, Fa, Fb, Fc float64
	Nfev                   int
	Msg                    string
}

type BracketOptions struct {
	Xtol, Rtol float64
	MaxIter    int
}

type BruteOptions struct {
	// Ns is the number of grid points per axis when Range.Step is 0 (20).
	Ns int
	// NoFinish skips the final local minimisation (SciPy's finish=None).
	NoFinish bool
	// Finish is the local method polishing the best grid point
	// (Nelder-Mead, SciPy's fmin). Finish options come from FinishOptions.
	Finish        Method
	FinishOptions *Options
	// Workers evaluates the grid with this many goroutines (1). The
	// objective must then be safe for concurrent use.
	Workers int
}

type BruteResult struct {
	// X and Fun are the minimiser and its value (after the finish step).
	X   []float64
	Fun float64
	// Success is false when the finish step did not converge.
	Success bool
	// Axes holds the coordinates of each grid axis; Jout the objective on
	// the grid, row-major over the axes (shape len(Axes[0]) × …).
	Axes [][]float64
	Jout []float64
}

type Constraint struct {
	// Kind selects c(x) = 0 (Eq) or c(x) >= 0 (Ineq).
	Kind ConstraintKind
	// M is the number of outputs of Func.
	M int
	// Func writes the M constraint values at x into c.
	Func func(x, c []float64)
	// Jac writes the M×n Jacobian at x into jac, row-major. When nil it is
	// estimated by forward differences.
	Jac func(x, jac []float64)
}

type ConstraintKind int

type ConstraintSpec interface {
	// contains filtered or unexported methods
}

type CurveFitOptions struct {
	// Sigma is the uncertainty of ydata: a 1-D array of standard
	// deviations (the residuals are divided by it) or a 2-D covariance
	// matrix (the residuals are whitened by its Cholesky factor). nil means
	// unit weights.
	Sigma *ndarray.Array
	// AbsoluteSigma uses Sigma in an absolute sense: Pcov is not scaled by
	// the reduced chi-square.
	AbsoluteSigma bool
	// Bounds on the parameters; bounds select TRF.
	Bounds []Bound
	// Method is LM (the default without bounds) or TRF (with bounds).
	Method LSMethod
	// MaxFev, Ftol, Xtol and Gtol are passed to the solver (SciPy's maxfev
	// for LM, max_nfev for TRF; tolerances 1.49012e-8 for LM, 1e-8 for TRF).
	MaxFev           int
	Ftol, Xtol, Gtol float64
	// Loss and FScale select a robust loss (TRF only), as SciPy forwards
	// loss= and f_scale= to least_squares.
	Loss   Loss
	FScale float64
	// Workers evaluates the model over the samples with this many
	// goroutines when there are at least 2048 samples (default 1). The
	// model must then be safe for concurrent use; the result is identical.
	Workers int
}

type CurveFitResult struct {
	// Popt holds the fitted parameters.
	Popt []float64
	// Pcov is the n×n covariance of Popt, row-major. When it cannot be
	// estimated every entry is +Inf and CovOK is false (SciPy warns).
	Pcov  []float64
	CovOK bool
	// Fvec holds the (weighted) residuals at Popt and Nfev the solver's
	// count of residual evaluations (SciPy's infodict['nfev']: MINPACK's
	// count including finite differences for LM, least_squares' count
	// excluding them for TRF).
	Fvec []float64
	Nfev int
	// Status and Message are the solver's (SciPy's ier and mesg).
	Status  int
	Message string
}

type FDMethod int

type LPConstraints struct {
	// AUb and BUb are the inequality constraints A_ub·x <= b_ub.
	AUb, BUb *ndarray.Array
	// AEq and BEq are the equality constraints A_eq·x == b_eq.
	AEq, BEq *ndarray.Array
	// Bounds gives one interval per variable. nil means linprog's default
	// (0, +Inf) for every variable — note that this differs from Minimize,
	// where nil means unbounded. Use Unbounded() for a free variable.
	Bounds []Bound
}

type LPDual struct {
	// Residual is the slack of each constraint: b_ub − A_ub·x for
	// inequalities, b_eq − A_eq·x for equalities, x − lb and ub − x for
	// the bounds (±Inf for a missing bound).
	Residual []float64
	// Marginals is the sensitivity of the optimal objective to the
	// constraint's right-hand side (∂fun/∂b), with SciPy's HiGHS sign
	// convention: ineqlin and upper marginals are <= 0, lower marginals
	// are >= 0, eqlin marginals have any sign. They satisfy
	// c = A_ubᵀ·ineqlin + A_eqᵀ·eqlin + lower + upper. nil unless Status
	// is 0.
	Marginals []float64
}

type LPMethod string

type LPOptions struct {
	// Method selects the algorithm; the default is LPSimplex.
	Method LPMethod
	// Tol is the primal and dual feasibility tolerance. Default 1e-9 for
	// LPSimplex and 1e-8 for LPInteriorPoint (SciPy's interior-point
	// default). As in SciPy, the final feasibility check uses 10·√Tol.
	Tol float64
	// MaxIter bounds the iterations (simplex pivots and bound flips over
	// both phases, or interior-point iterations). Default 5000 for
	// LPSimplex and 1000 for LPInteriorPoint, as in SciPy.
	MaxIter int
	// NoPresolve disables the presolve pass (linprog's presolve=False).
	NoPresolve bool
}

type LPResult struct {
	// X is the solution. When Status is not 0 it is the last point the
	// solver held (it may violate the constraints), or nil when presolve
	// stopped before any solve.
	X []float64
	// Fun is c·X.
	Fun float64
	// Slack is b_ub − A_ub·X and Con is b_eq − A_eq·X.
	Slack, Con []float64
	// IneqLin, EqLin, Lower and Upper hold residuals and marginals of the
	// inequality rows, equality rows, lower bounds and upper bounds.
	IneqLin, EqLin, Lower, Upper LPDual
	// Status is SciPy's code: 0 optimal, 1 iteration limit, 2 infeasible,
	// 3 unbounded, 4 numerical difficulties.
	Status int
	// Success reports Status == 0.
	Success bool
	// Message describes the reason for termination.
	Message string
	// Nit counts iterations over all phases.
	Nit int
}

type LSMethod string

type LSOptions struct {
	// Bounds constrains the variables (TRF only). nil means unbounded.
	Bounds []Bound
	// Ftol, Xtol and Gtol are the termination tolerances (1e-8 each).
	// SciPy lets None disable one; here a negative value disables it.
	Ftol, Xtol, Gtol float64
	// MaxNfev bounds function evaluations (100·n; for LM it bounds
	// MINPACK's count, which leaves out finite-difference evaluations).
	MaxNfev int
	// XScale is the characteristic scale of each variable. nil means 1
	// (TRF) or 'jac' (LM, SciPy's default for that method); XScaleJac
	// selects SciPy's x_scale='jac'.
	XScale    []float64
	XScaleJac bool
	// Loss is the robust loss (TRF only; LossLinear by default) and FScale
	// its soft margin between inliers and outliers (1).
	Loss   Loss
	FScale float64
	// DiffStep is the relative finite-difference step (SciPy diff_step);
	// 0 selects the default of the scheme.
	DiffStep float64
	// FDMethod is the finite-difference scheme for TRF (FD2Point). LM uses
	// MINPACK's own forward differences.
	FDMethod FDMethod
}

type LSProblem struct {
	// Func writes the m residuals at x into f. Required.
	Func func(x, f []float64)
	// Jac writes the m×n Jacobian at x into jac, row-major. Optional:
	// finite differences are used when it is nil.
	Jac func(x, jac []float64)
	// M is the number of residuals. Required.
	M int
}

type LSResult struct {
	// X is the solution.
	X []float64
	// Cost is ½·Σρ(f_i²) at X.
	Cost float64
	// Fun holds the m residuals at X.
	Fun []float64
	// Jac is the m×n Jacobian at X, row-major (modified by the loss, as in
	// SciPy).
	Jac []float64
	// Grad is the gradient of the cost at X.
	Grad []float64
	// Optimality is the first-order optimality measure (max-norm of the
	// scaled gradient, as SciPy defines it per method).
	Optimality float64
	// ActiveMask is -1 or +1 for a variable at its lower or upper bound,
	// 0 otherwise.
	ActiveMask []int
	// Nfev and Njev count residual and Jacobian evaluations.
	Nfev, Njev int
	// Status follows SciPy: -1 improper input, 0 max_nfev reached, 1 gtol,
	// 2 ftol, 3 xtol, 4 both ftol and xtol satisfied.
	Status int
	// Success is Status > 0.
	Success bool
	// Message describes the termination.
	Message string
}

type LeastsqOptions struct {
	// Ftol is the relative error desired in the sum of squares and Xtol the
	// relative error desired in the solution (1.49012e-8 each; a negative
	// value means exactly 0). Gtol is the orthogonality desired between the
	// residuals and the Jacobian columns (0).
	Ftol, Xtol, Gtol float64
	// Maxfev bounds the calls to Func: 0 selects 100·(n+1) with a Jacobian
	// and 200·(n+1) without.
	Maxfev int
	// Epsfcn sets the forward-difference step sqrt(Epsfcn)·|x_j| when there
	// is no Jacobian; 0 selects the machine epsilon.
	Epsfcn float64
	// Factor sets the initial step bound Factor·|diag·x0| (100).
	Factor float64
	// Diag holds n positive scale factors for the variables; nil lets
	// MINPACK scale by the Jacobian column norms.
	Diag []float64
}

type LeastsqResult struct {
	// X is the solution (or the last iterate).
	X []float64
	// CovX is inv(JᵀJ) at X, n×n row-major, from the final R and
	// permutation; nil when R is singular or the run did not converge
	// (Ier not in 1..4). Multiply it by the residual variance to obtain the
	// covariance of X.
	CovX []float64
	// Nfev counts calls to Func, including those of the finite-difference
	// Jacobian; Njev counts calls to Jac (0 without one).
	Nfev, Njev int
	// Fvec holds the residuals at X.
	Fvec []float64
	// Fjac is SciPy's infodict['fjac']: an n×m row-major array whose rows
	// are the columns of MINPACK's final QR workspace, so that the upper
	// triangle of its transpose's first n rows is R with Jac·P = Q·R.
	Fjac []float64
	// Ipvt is the permutation P: column j of P is column Ipvt[j]
	// (zero-based) of the identity.
	Ipvt []int
	// Qtf is the first n components of Qᵀ·Fvec.
	Qtf []float64
	// Ier is MINPACK's info: 1 to 4 mean a solution was found, 5 to 8 that
	// it was not.
	Ier int
	// Mesg is SciPy's message for Ier.
	Mesg string
}

type LinearConstraint struct {
	A      *ndarray.Array
	Lb, Ub []float64
}

type Loss string

type Method string

type Model struct {
	// F returns the model value at sample x for parameters p. Required.
	F func(x, p []float64) float64
	// Grad writes ∂f/∂p at sample x into grad (len(p) values). Optional:
	// finite differences are used when it is nil (SciPy's jac=callable).
	Grad func(x, p, grad []float64)
	// contains filtered or unexported fields
}

type NewtonOptions struct {
	// Fprime is the derivative; nil selects the secant method.
	Fprime func(float64) float64
	// Fprime2 is the second derivative; with Fprime it selects Halley's
	// method.
	Fprime2 func(float64) float64
	// X1 is the second starting point of the secant method; 0 means
	// x0·(1+1e-4) ± 1e-4, as in SciPy. Set X1Set to use an explicit 0.
	X1    float64
	X1Set bool
	// Tol and Rtol are the absolute and relative tolerances on successive
	// iterates (numpy.isclose semantics).
	Tol, Rtol float64
	MaxIter   int
}

type NonlinearConstraint struct {
	// M is the number of outputs of Func.
	M int
	// Func writes the M constraint values at x into c.
	Func func(x, c []float64)
	// Jac writes the M×n Jacobian, row-major; nil means finite differences.
	Jac func(x, jac []float64)
	// Lb and Ub bound Func(x).
	Lb, Ub []float64
}

type Options struct {
	// Bounds constrains the variables (L-BFGS-B, SLSQP, trust-constr,
	// Nelder-Mead and Powell, as in SciPy). nil means unbounded.
	Bounds []Bound
	// Constraints are general equality and inequality constraints
	// (SLSQP and trust-constr): Constraint, NonlinearConstraint or
	// LinearConstraint values, SciPy's constraints argument. Other methods
	// return an error when it is set, where SciPy only warns.
	Constraints []ConstraintSpec
	// BarrierTol is trust-constr's barrier-parameter tolerance for the xtol
	// test (1e-8).
	BarrierTol float64
	// InitialTrRadius, InitialConstrPenalty, InitialBarrierParameter and
	// InitialBarrierTolerance are trust-constr's initial trust radius (1),
	// merit penalty (1), barrier parameter (0.1) and barrier subproblem
	// tolerance (0.1).
	InitialTrRadius, InitialConstrPenalty            float64
	InitialBarrierParameter, InitialBarrierTolerance float64
	// Tol is minimize's tol argument: it sets the method's main tolerance
	// the way SciPy does (Nelder-Mead: Xatol and Fatol; Powell: Xtol and
	// Ftol; CG and BFGS: Gtol; Newton-CG: Xtol; L-BFGS-B: Ftol and Gtol;
	// SLSQP: Ftol; trust-constr: Gtol, Xtol and BarrierTol) when those
	// fields are zero.
	Tol float64
	// MaxIter bounds the iterations (Nelder-Mead 200·n, Powell 1000·n,
	// CG, BFGS and Newton-CG 200·n, L-BFGS-B 15000, SLSQP 100,
	// trust-constr 1000). For Nelder-Mead and
	// Powell, setting only one of MaxIter and MaxFev leaves the other
	// unlimited, as in SciPy.
	MaxIter int
	// MaxFev bounds function evaluations (Nelder-Mead 200·n, Powell 1000·n,
	// L-BFGS-B 15000).
	MaxFev int
	// Gtol is the gradient tolerance: CG and BFGS stop when the Norm-norm
	// of the gradient is below it (1e-5); L-BFGS-B stops when the max-norm
	// of the projected gradient is below it (SciPy pgtol, 1e-5);
	// trust-constr stops when the max-norm of the Lagrangian gradient and
	// the constraint violation are both below it (1e-8).
	Gtol float64
	// Ftol is the relative reduction tolerance: Powell (1e-4),
	// L-BFGS-B ((f_k - f_{k+1})/max(|f_k|,|f_{k+1}|,1) <= Ftol, 2.22e-9);
	// for SLSQP it is the accuracy goal of the stopping tests (1e-6).
	Ftol float64
	// Xtol is the step tolerance: Powell (1e-4), Newton-CG (1e-5),
	// trust-constr's trust radius (1e-8).
	Xtol float64
	// Xatol and Fatol are Nelder-Mead's absolute tolerances (1e-4 each).
	Xatol, Fatol float64
	// Adaptive makes Nelder-Mead adapt its coefficients to the dimension.
	Adaptive bool
	// InitialSimplex is Nelder-Mead's initial simplex, n+1 points.
	InitialSimplex [][]float64
	// Direc is Powell's initial set of directions, n vectors.
	Direc [][]float64
	// Norm is the order of the gradient norm for CG and BFGS (+Inf).
	Norm float64
	// Eps is the absolute finite-difference step for gradient-based
	// methods when no gradient is given (sqrt(eps) ≈ 1.49e-8 for CG and
	// BFGS, 1e-8 for L-BFGS-B). It is ignored when FiniteDiffRelStep is set.
	Eps float64
	// FiniteDiffRelStep selects a relative finite-difference step instead
	// of the absolute Eps (SciPy finite_diff_rel_step with jac='2-point').
	FiniteDiffRelStep float64
	// FDMethod is the finite-difference scheme (FD2Point).
	FDMethod FDMethod
	// M is the number of L-BFGS-B correction pairs (10).
	M int
	// MaxLS bounds L-BFGS-B line-search steps per iteration (20).
	MaxLS int
	// C1 and C2 are the Wolfe constants for CG (1e-4, 0.4) and BFGS
	// (1e-4, 0.9).
	C1, C2 float64
	// HessInv0 is BFGS's initial inverse Hessian, n*n row-major (identity).
	HessInv0 []float64
	// XRtol is BFGS's relative step tolerance (0: disabled).
	XRtol float64
	// Callback is called after each iteration with a copy of the current
	// point and the objective value; returning true stops the minimisation,
	// which then reports Success false and Status 99 (SciPy's callback
	// raising StopIteration).
	Callback func(x []float64, f float64) (stop bool)
}

type Problem struct {
	// Func returns f(x).
	Func func(x []float64) float64
	// Grad writes ∇f(x) into grad (SciPy's jac=callable).
	Grad func(x, grad []float64)
	// FuncGrad returns f(x) and writes ∇f(x) into grad in one call
	// (SciPy's jac=True). It takes precedence over Func and Grad.
	FuncGrad func(x, grad []float64) float64
	// Hess writes the n×n Hessian at x into hess, row-major (SciPy's hess).
	Hess func(x, hess []float64)
	// HessP writes the Hessian at x times p into hp (SciPy's hessp).
	HessP func(x, p, hp []float64)
}

type QPConstraints struct {
	// AUb·x <= BUb. AUb is m×n (or one row of length n); BUb has one entry
	// per row, +Inf for a vacuous row.
	AUb, BUb *ndarray.Array
	// AEq·x = BEq, with finite right-hand sides.
	AEq, BEq *ndarray.Array
	// Linear holds blocks Lb <= A·x <= Ub, the type of Minimize's constraints.
	Linear []LinearConstraint
	// ASparse holds rows l <= ASparse·x <= u (QPADMM only); L and U have one
	// entry per row, or one entry broadcast, or nil for -Inf and +Inf.
	ASparse *sparse.CSC[float64]
	L, U    []float64
	// Bounds are the variable bounds; nil means free, as in Minimize (not
	// Linprog's (0, +Inf)).
	Bounds []Bound
}

type QPMethod string

type QPOptions struct {
	Method QPMethod
	// MaxIter is the iteration limit: 10·(n + m) for the active set, 4000 for
	// ADMM when zero.
	MaxIter int
	// FeasTol is the active set's primal feasibility tolerance (default 1e-9).
	FeasTol float64
	// ADMM settings: the zero value of each selects OSQP v1.0.0's default
	// (EpsAbs and EpsRel 1e-3, EpsPrimInf and EpsDualInf 1e-4, Rho 0.1,
	// Sigma 1e-6, Alpha 1.6, ScalingIter 10, AdaptiveRhoInterval 50,
	// CheckInterval 25, PolishDelta 1e-6, PolishRefine 3). A negative
	// ScalingIter or AdaptiveRhoInterval disables that step.
	EpsAbs, EpsRel         float64
	EpsPrimInf, EpsDualInf float64
	Rho, Sigma, Alpha      float64
	ScalingIter            int
	AdaptiveRhoInterval    int
	CheckInterval          int
	Polish                 bool
	PolishDelta            float64
	PolishRefine           int
	NoDualGapCheck         bool
	// X0 and Y0 (lengths n and the number of canonical rows) warm-start ADMM,
	// WorkingSet (canonical row indices) warm-starts the active set; both are
	// validated.
	X0, Y0     []float64
	WorkingSet []int
}

type QPProblem struct {
	// P is n×n and is symmetrised as (P+Pᵀ)/2, as MATLAB's quadprog does.
	P *ndarray.Array
	// PSparse is n×n and holds the entries with row <= column only.
	PSparse *sparse.CSC[float64]
	// Q has length n and defines n.
	Q    []float64
	Cons QPConstraints
}

type QPResult struct {
	X   []float64
	Fun float64
	// Residuals and marginals per family of constraints, one entry per input
	// row (a row unbounded on both sides has residual +Inf and marginal 0).
	// The marginal of a row a is the coefficient with which it enters
	// P·x + q = Σ marginal·a, so that
	//   P·x + q = AUbᵀ·IneqLin + AEqᵀ·EqLin + Aᵀ·Linear + A_sparseᵀ·Sparse
	//             + Lower + Upper,
	// the sign convention of Linprog (HiGHS). The residual of a two-sided row
	// (Linear, Sparse) is the slack of its nearer finite side. Lower and Upper
	// are indexed by variable; a variable pinned by lb == ub puts its marginal
	// in Lower when it is >= 0 and in Upper otherwise.
	IneqLin, EqLin, Linear, Sparse, Lower, Upper LPDual
	// Y holds OSQP-form multipliers (P·x + q + Aᵀy = 0, so y = −marginal) of
	// the canonical rows (design-qp.md §2.2: AEq rows, AUb rows, the Linear
	// blocks, the ASparse rows, then the finite bounds, rows unbounded on both
	// sides dropped).
	Y []float64
	// ActiveSet lists the canonical rows in the final working set.
	ActiveSet []int
	// PrimalCert and DualCert are the certificates of infeasibility and
	// unboundedness (nil until the solvers that produce them exist).
	PrimalCert, DualCert []float64
	// Optimality is ‖P·x + q − Σ marginal·a‖∞ recomputed from scratch,
	// ConstrViolation the largest violation of a canonical row, DualityGap the
	// gap between the primal and dual objectives (0 for a direct solve).
	Optimality, ConstrViolation, DualityGap float64
	Status                                  int
	// Success reports Status == QPOptimal.
	Success bool
	Message string
	// Method is the method that ran (QPAuto resolved).
	Method     QPMethod
	Nit        int
	RhoUpdates int
	Polished   bool
}

type QPSolver struct {
	// contains filtered or unexported fields
}

type Range struct {
	Lo, Hi, Step float64
}

type Result struct {
	// X is the solution.
	X []float64
	// Fun is the objective value at X.
	Fun float64
	// Jac is the gradient at X, when the method computes one.
	Jac []float64
	// HessInv is the final inverse-Hessian approximation as an n*n row-major
	// matrix (BFGS only, nil otherwise).
	HessInv []float64
	// Multipliers are the Lagrange multipliers of the constraints at X.
	// SLSQP: equalities first and then inequalities, in the order of the
	// standardised constraint blocks (SciPy's result.multipliers).
	// trust-constr: one per component of each constraint of
	// Options.Constraints, in order, with SciPy's sign (its result.v
	// without the bounds).
	Multipliers []float64
	// Optimality is the max-norm of the Lagrangian gradient and
	// ConstrViolation the largest constraint violation at X (trust-constr).
	Optimality, ConstrViolation float64
	// Nit, Nfev, Njev and Nhev count iterations and evaluations of the
	// objective, the gradient and the Hessian. Function evaluations spent on
	// finite-difference gradients are counted in Nfev, and each such gradient
	// also counts once in Njev, as in SciPy.
	Nit, Nfev, Njev, Nhev int
	// Status is a method-specific termination code; 0 means success.
	Status int
	// Success reports whether the method met its convergence criteria.
	Success bool
	// Message describes the reason for termination.
	Message string
}

type RootOptions struct {
	// Xtol stops the iteration when the relative error between two
	// consecutive iterates is at most Xtol (1.49012e-8; a negative value
	// means exactly 0).
	Xtol float64
	// Maxfev bounds the calls to Func: 0 selects 200·(n+1) without a
	// Jacobian (forward-difference calls included) and 100·(n+1) with one.
	Maxfev int
	// Eps sets the forward-difference step sqrt(Eps)·|x_j| when there is no
	// Jacobian (SciPy's eps for root, epsfcn for fsolve); 0 selects the
	// machine epsilon.
	Eps float64
	// Factor sets the initial step bound Factor·|Diag·x0| (100).
	Factor float64
	// Diag holds n positive scale factors for the variables; nil lets
	// MINPACK scale by the Jacobian column norms.
	Diag []float64
}

type RootResult struct {
	// X is the solution (or the last iterate).
	X []float64
	// Fun holds F(X).
	Fun []float64
	// Fjac is SciPy's fjac: the orthogonal factor Q of the QR factorisation
	// of the final approximate Jacobian, stored column-wise, so that as an
	// n×n row-major array it reads Qᵀ (row i is column i of Q).
	Fjac []float64
	// R is the upper-triangular factor packed by rows (n(n+1)/2 entries).
	R []float64
	// Qtf is Qᵀ·Fun.
	Qtf []float64
	// Nfev counts calls to Func, including those of finite differences;
	// Njev counts calls to Jac (0 without one). SciPy's root and fsolve
	// report two more calls: those their wrappers make outside MINPACK (a
	// shape check and the initial evaluation), which do not happen here.
	Nfev, Njev int
	// Status is MINPACK's info: 1 converged, 2 Maxfev reached, 3 Xtol too
	// small, 4 and 5 no progress.
	Status int
	// Success is Status == 1.
	Success bool
	// Message is SciPy's message for Status.
	Message string
}

type RootScalarOptions struct {
	// Bracket [a, b] for the bracketing methods.
	Bracket []float64
	// Fprime and Fprime2 are the first and second derivatives.
	Fprime, Fprime2 func(float64) float64
	// X0 and X1 are starting points for Newton, Halley and the secant
	// method; X0Set/X1Set mark them as given (0 is a valid start).
	X0, X1       float64
	X0Set, X1Set bool
	// Xtol, Rtol and MaxIter override the method's defaults.
	Xtol, Rtol float64
	MaxIter    int
}

type RootScalarResult struct {
	// Root is the estimated root.
	Root float64
	// Iterations and FunctionCalls count the work done (derivative
	// evaluations count as function calls for Newton and Halley).
	Iterations, FunctionCalls int
	// Converged reports whether the tolerance was met.
	Converged bool
	// Flag is "converged", "convergence error" or a message describing the
	// failure.
	Flag string
	// Method is the algorithm used.
	Method string
}

type ScalarMethod string

type ScalarOptions struct {
	// Bracket is a bracketing interval for Brent and Golden: two points
	// (xa, xb) from which Bracket searches downhill, or three points
	// (xa, xb, xc) with xa < xb < xc and f(xb) < f(xa), f(xc). nil starts
	// the downhill search from (0, 1).
	Bracket []float64
	// Bounds is the interval for the Bounded method; setting it selects
	// Bounded when the method is "".
	Bounds *Bound
	// Tol is minimize_scalar's tol: it sets Xtol (Brent, Golden) or Xatol
	// (Bounded) when those are zero.
	Tol float64
	// Xtol is the relative tolerance of Brent (1.48e-8) and Golden
	// (√eps ≈ 1.49e-8).
	Xtol float64
	// Xatol is the absolute tolerance of Bounded (1e-5).
	Xatol float64
	// MaxIter bounds iterations (Brent 500, Golden 5000) or function
	// evaluations (Bounded 500).
	MaxIter int
}

type ScalarResult struct {
	X, Fun    float64
	Nit, Nfev int
	Status    int // Bounded only: 0 solution found, 1 maxfun, 2 NaN
	Success   bool
	Message   string
}

type SystemProblem struct {
	// Func writes the n values of F at x into f. Required. It must not
	// modify x.
	Func func(x, f []float64)
	// Jac writes the n×n Jacobian of F at x into jac, row-major
	// (jac[i*n+j] = ∂F_i/∂x_j). Optional: MINPACK's forward differences are
	// used when it is nil.
	Jac func(x, jac []float64)
}