Classes | Namespaces | Functions

optimization.h File Reference

#include "ap.h"
#include "alglibinternal.h"
#include "alglibmisc.h"
#include "linalg.h"
#include "solvers.h"

Go to the source code of this file.

Classes

class  alglib::_minasareport_owner
 
class  alglib::_minasastate_owner
 
class  alglib::_minbcreport_owner
 
class  alglib::_minbcstate_owner
 
class  alglib::_minbleicreport_owner
 
class  alglib::_minbleicstate_owner
 
class  alglib::_mincgreport_owner
 
class  alglib::_mincgstate_owner
 
class  alglib::_minlbfgsreport_owner
 
class  alglib::_minlbfgsstate_owner
 
class  alglib::_minlmreport_owner
 
class  alglib::_minlmstate_owner
 
class  alglib::_minnlcreport_owner
 
class  alglib::_minnlcstate_owner
 
class  alglib::_minnsreport_owner
 
class  alglib::_minnsstate_owner
 
class  alglib::_minqpreport_owner
 
class  alglib::_minqpstate_owner
 
struct  alglib_impl::convexquadraticmodel
 
class  alglib::minasareport
 
struct  alglib_impl::minasareport
 
class  alglib::minasastate
 
struct  alglib_impl::minasastate
 
class  alglib::minbcreport
 
struct  alglib_impl::minbcreport
 
class  alglib::minbcstate
 
struct  alglib_impl::minbcstate
 
class  alglib::minbleicreport
 
struct  alglib_impl::minbleicreport
 
class  alglib::minbleicstate
 
struct  alglib_impl::minbleicstate
 
class  alglib::mincgreport
 
struct  alglib_impl::mincgreport
 
class  alglib::mincgstate
 
struct  alglib_impl::mincgstate
 
class  alglib::minlbfgsreport
 
struct  alglib_impl::minlbfgsreport
 
class  alglib::minlbfgsstate
 
struct  alglib_impl::minlbfgsstate
 
class  alglib::minlmreport
 
struct  alglib_impl::minlmreport
 
class  alglib::minlmstate
 
struct  alglib_impl::minlmstate
 
struct  alglib_impl::minlmstepfinder
 
class  alglib::minnlcreport
 
struct  alglib_impl::minnlcreport
 
class  alglib::minnlcstate
 
struct  alglib_impl::minnlcstate
 
struct  alglib_impl::minnsqp
 
class  alglib::minnsreport
 
struct  alglib_impl::minnsreport
 
class  alglib::minnsstate
 
struct  alglib_impl::minnsstate
 
class  alglib::minqpreport
 
struct  alglib_impl::minqpreport
 
class  alglib::minqpstate
 
struct  alglib_impl::minqpstate
 
struct  alglib_impl::precbuflbfgs
 
struct  alglib_impl::precbuflowrank
 
struct  alglib_impl::qpbleicbuffers
 
struct  alglib_impl::qpbleicsettings
 
struct  alglib_impl::qpcholeskybuffers
 
struct  alglib_impl::qpcholeskysettings
 
struct  alglib_impl::qpdenseaulbuffers
 
struct  alglib_impl::qpdenseaulsettings
 
struct  alglib_impl::qqpbuffers
 
struct  alglib_impl::qqpsettings
 
struct  alglib_impl::sactiveset
 
struct  alglib_impl::snnlssolver
 

Namespaces

 alglib
 
 alglib_impl
 

Functions

void alglib_impl::_convexquadraticmodel_clear (void *_p)
 
void alglib_impl::_convexquadraticmodel_destroy (void *_p)
 
void alglib_impl::_convexquadraticmodel_init (void *_p, ae_state *_state)
 
void alglib_impl::_convexquadraticmodel_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_minasareport_clear (void *_p)
 
void alglib_impl::_minasareport_destroy (void *_p)
 
void alglib_impl::_minasareport_init (void *_p, ae_state *_state)
 
void alglib_impl::_minasareport_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_minasastate_clear (void *_p)
 
void alglib_impl::_minasastate_destroy (void *_p)
 
void alglib_impl::_minasastate_init (void *_p, ae_state *_state)
 
void alglib_impl::_minasastate_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_minbcreport_clear (void *_p)
 
void alglib_impl::_minbcreport_destroy (void *_p)
 
void alglib_impl::_minbcreport_init (void *_p, ae_state *_state)
 
void alglib_impl::_minbcreport_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_minbcstate_clear (void *_p)
 
void alglib_impl::_minbcstate_destroy (void *_p)
 
void alglib_impl::_minbcstate_init (void *_p, ae_state *_state)
 
void alglib_impl::_minbcstate_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_minbleicreport_clear (void *_p)
 
void alglib_impl::_minbleicreport_destroy (void *_p)
 
void alglib_impl::_minbleicreport_init (void *_p, ae_state *_state)
 
void alglib_impl::_minbleicreport_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_minbleicstate_clear (void *_p)
 
void alglib_impl::_minbleicstate_destroy (void *_p)
 
void alglib_impl::_minbleicstate_init (void *_p, ae_state *_state)
 
void alglib_impl::_minbleicstate_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_mincgreport_clear (void *_p)
 
void alglib_impl::_mincgreport_destroy (void *_p)
 
void alglib_impl::_mincgreport_init (void *_p, ae_state *_state)
 
void alglib_impl::_mincgreport_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_mincgstate_clear (void *_p)
 
void alglib_impl::_mincgstate_destroy (void *_p)
 
void alglib_impl::_mincgstate_init (void *_p, ae_state *_state)
 
void alglib_impl::_mincgstate_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_minlbfgsreport_clear (void *_p)
 
void alglib_impl::_minlbfgsreport_destroy (void *_p)
 
void alglib_impl::_minlbfgsreport_init (void *_p, ae_state *_state)
 
void alglib_impl::_minlbfgsreport_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_minlbfgsstate_clear (void *_p)
 
void alglib_impl::_minlbfgsstate_destroy (void *_p)
 
void alglib_impl::_minlbfgsstate_init (void *_p, ae_state *_state)
 
void alglib_impl::_minlbfgsstate_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_minlmreport_clear (void *_p)
 
void alglib_impl::_minlmreport_destroy (void *_p)
 
void alglib_impl::_minlmreport_init (void *_p, ae_state *_state)
 
void alglib_impl::_minlmreport_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_minlmstate_clear (void *_p)
 
void alglib_impl::_minlmstate_destroy (void *_p)
 
void alglib_impl::_minlmstate_init (void *_p, ae_state *_state)
 
void alglib_impl::_minlmstate_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_minlmstepfinder_clear (void *_p)
 
void alglib_impl::_minlmstepfinder_destroy (void *_p)
 
void alglib_impl::_minlmstepfinder_init (void *_p, ae_state *_state)
 
void alglib_impl::_minlmstepfinder_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_minnlcreport_clear (void *_p)
 
void alglib_impl::_minnlcreport_destroy (void *_p)
 
void alglib_impl::_minnlcreport_init (void *_p, ae_state *_state)
 
void alglib_impl::_minnlcreport_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_minnlcstate_clear (void *_p)
 
void alglib_impl::_minnlcstate_destroy (void *_p)
 
void alglib_impl::_minnlcstate_init (void *_p, ae_state *_state)
 
void alglib_impl::_minnlcstate_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_minnsqp_clear (void *_p)
 
void alglib_impl::_minnsqp_destroy (void *_p)
 
void alglib_impl::_minnsqp_init (void *_p, ae_state *_state)
 
void alglib_impl::_minnsqp_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_minnsreport_clear (void *_p)
 
void alglib_impl::_minnsreport_destroy (void *_p)
 
void alglib_impl::_minnsreport_init (void *_p, ae_state *_state)
 
void alglib_impl::_minnsreport_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_minnsstate_clear (void *_p)
 
void alglib_impl::_minnsstate_destroy (void *_p)
 
void alglib_impl::_minnsstate_init (void *_p, ae_state *_state)
 
void alglib_impl::_minnsstate_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_minqpreport_clear (void *_p)
 
void alglib_impl::_minqpreport_destroy (void *_p)
 
void alglib_impl::_minqpreport_init (void *_p, ae_state *_state)
 
void alglib_impl::_minqpreport_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_minqpstate_clear (void *_p)
 
void alglib_impl::_minqpstate_destroy (void *_p)
 
void alglib_impl::_minqpstate_init (void *_p, ae_state *_state)
 
void alglib_impl::_minqpstate_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_precbuflbfgs_clear (void *_p)
 
void alglib_impl::_precbuflbfgs_destroy (void *_p)
 
void alglib_impl::_precbuflbfgs_init (void *_p, ae_state *_state)
 
void alglib_impl::_precbuflbfgs_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_precbuflowrank_clear (void *_p)
 
void alglib_impl::_precbuflowrank_destroy (void *_p)
 
void alglib_impl::_precbuflowrank_init (void *_p, ae_state *_state)
 
void alglib_impl::_precbuflowrank_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_qpbleicbuffers_clear (void *_p)
 
void alglib_impl::_qpbleicbuffers_destroy (void *_p)
 
void alglib_impl::_qpbleicbuffers_init (void *_p, ae_state *_state)
 
void alglib_impl::_qpbleicbuffers_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_qpbleicsettings_clear (void *_p)
 
void alglib_impl::_qpbleicsettings_destroy (void *_p)
 
void alglib_impl::_qpbleicsettings_init (void *_p, ae_state *_state)
 
void alglib_impl::_qpbleicsettings_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_qpcholeskybuffers_clear (void *_p)
 
void alglib_impl::_qpcholeskybuffers_destroy (void *_p)
 
void alglib_impl::_qpcholeskybuffers_init (void *_p, ae_state *_state)
 
void alglib_impl::_qpcholeskybuffers_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_qpcholeskysettings_clear (void *_p)
 
void alglib_impl::_qpcholeskysettings_destroy (void *_p)
 
void alglib_impl::_qpcholeskysettings_init (void *_p, ae_state *_state)
 
void alglib_impl::_qpcholeskysettings_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_qpdenseaulbuffers_clear (void *_p)
 
void alglib_impl::_qpdenseaulbuffers_destroy (void *_p)
 
void alglib_impl::_qpdenseaulbuffers_init (void *_p, ae_state *_state)
 
void alglib_impl::_qpdenseaulbuffers_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_qpdenseaulsettings_clear (void *_p)
 
void alglib_impl::_qpdenseaulsettings_destroy (void *_p)
 
void alglib_impl::_qpdenseaulsettings_init (void *_p, ae_state *_state)
 
void alglib_impl::_qpdenseaulsettings_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_qqpbuffers_clear (void *_p)
 
void alglib_impl::_qqpbuffers_destroy (void *_p)
 
void alglib_impl::_qqpbuffers_init (void *_p, ae_state *_state)
 
void alglib_impl::_qqpbuffers_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_qqpsettings_clear (void *_p)
 
void alglib_impl::_qqpsettings_destroy (void *_p)
 
void alglib_impl::_qqpsettings_init (void *_p, ae_state *_state)
 
void alglib_impl::_qqpsettings_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_sactiveset_clear (void *_p)
 
void alglib_impl::_sactiveset_destroy (void *_p)
 
void alglib_impl::_sactiveset_init (void *_p, ae_state *_state)
 
void alglib_impl::_sactiveset_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::_snnlssolver_clear (void *_p)
 
void alglib_impl::_snnlssolver_destroy (void *_p)
 
void alglib_impl::_snnlssolver_init (void *_p, ae_state *_state)
 
void alglib_impl::_snnlssolver_init_copy (void *_dst, void *_src, ae_state *_state)
 
void alglib_impl::applylowrankpreconditioner (ae_vector *s, precbuflowrank *buf, ae_state *_state)
 
void alglib_impl::calculatestepbound (ae_vector *x, ae_vector *d, double alpha, ae_vector *bndl, ae_vector *havebndl, ae_vector *bndu, ae_vector *havebndu, ae_int_t nmain, ae_int_t nslack, ae_int_t *variabletofreeze, double *valuetofreeze, double *maxsteplen, ae_state *_state)
 
void alglib_impl::cqmadx (convexquadraticmodel *s, ae_vector *x, ae_vector *y, ae_state *_state)
 
ae_bool alglib_impl::cqmconstrainedoptimum (convexquadraticmodel *s, ae_vector *x, ae_state *_state)
 
double alglib_impl::cqmdebugconstrainedevale (convexquadraticmodel *s, ae_vector *x, ae_state *_state)
 
double alglib_impl::cqmdebugconstrainedevalt (convexquadraticmodel *s, ae_vector *x, ae_state *_state)
 
void alglib_impl::cqmdropa (convexquadraticmodel *s, ae_state *_state)
 
double alglib_impl::cqmeval (convexquadraticmodel *s, ae_vector *x, ae_state *_state)
 
void alglib_impl::cqmevalx (convexquadraticmodel *s, ae_vector *x, double *r, double *noise, ae_state *_state)
 
void alglib_impl::cqmgeta (convexquadraticmodel *s, ae_matrix *a, ae_state *_state)
 
void alglib_impl::cqmgradunconstrained (convexquadraticmodel *s, ae_vector *x, ae_vector *g, ae_state *_state)
 
void alglib_impl::cqminit (ae_int_t n, convexquadraticmodel *s, ae_state *_state)
 
void alglib_impl::cqmrewritedensediagonal (convexquadraticmodel *s, ae_vector *z, ae_state *_state)
 
void alglib_impl::cqmscalevector (convexquadraticmodel *s, ae_vector *x, ae_state *_state)
 
void alglib_impl::cqmseta (convexquadraticmodel *s, ae_matrix *a, ae_bool isupper, double alpha, ae_state *_state)
 
void alglib_impl::cqmsetactiveset (convexquadraticmodel *s, ae_vector *x, ae_vector *activeset, ae_state *_state)
 
void alglib_impl::cqmsetb (convexquadraticmodel *s, ae_vector *b, ae_state *_state)
 
void alglib_impl::cqmsetd (convexquadraticmodel *s, ae_vector *d, double tau, ae_state *_state)
 
void alglib_impl::cqmsetq (convexquadraticmodel *s, ae_matrix *q, ae_vector *r, ae_int_t k, double theta, ae_state *_state)
 
double alglib_impl::cqmxtadx2 (convexquadraticmodel *s, ae_vector *x, ae_state *_state)
 
ae_bool alglib_impl::derivativecheck (double f0, double df0, double f1, double df1, double f, double df, double width, ae_state *_state)
 
ae_bool alglib_impl::enforceboundaryconstraints (ae_vector *x, ae_vector *bl, ae_vector *havebl, ae_vector *bu, ae_vector *havebu, ae_int_t nmain, ae_int_t nslack, ae_state *_state)
 
void alglib_impl::estimateparabolicmodel (double absasum, double absasum2, double mx, double mb, double md, double d1, double d2, ae_int_t *d1est, ae_int_t *d2est, ae_state *_state)
 
void alglib_impl::filterdirection (ae_vector *d, ae_vector *x, ae_vector *bndl, ae_vector *havebndl, ae_vector *bndu, ae_vector *havebndu, ae_vector *s, ae_int_t nmain, ae_int_t nslack, double droptol, ae_state *_state)
 
ae_bool alglib_impl::findfeasiblepoint (ae_vector *x, ae_vector *bndl, ae_vector *havebndl, ae_vector *bndu, ae_vector *havebndu, ae_int_t nmain, ae_int_t nslack, ae_matrix *ce, ae_int_t k, double epsi, ae_int_t *qpits, ae_int_t *gpaits, ae_state *_state)
 
void alglib_impl::inexactlbfgspreconditioner (ae_vector *s, ae_int_t n, ae_vector *d, ae_vector *c, ae_matrix *w, ae_int_t k, precbuflbfgs *buf, ae_state *_state)
 
void alglib_impl::minasacreate (ae_int_t n, ae_vector *x, ae_vector *bndl, ae_vector *bndu, minasastate *state, ae_state *_state)
 
void alglib::minasacreate (const ae_int_t n, const real_1d_array &x, const real_1d_array &bndl, const real_1d_array &bndu, minasastate &state)
 
void alglib::minasacreate (const real_1d_array &x, const real_1d_array &bndl, const real_1d_array &bndu, minasastate &state)
 
bool alglib::minasaiteration (const minasastate &state)
 
ae_bool alglib_impl::minasaiteration (minasastate *state, ae_state *_state)
 
void alglib::minasaoptimize (minasastate &state, void(*grad)(const real_1d_array &x, double &func, real_1d_array &grad, void *ptr), void(*rep)(const real_1d_array &x, double func, void *ptr)=NULL, void *ptr=NULL)
 
void alglib::minasarestartfrom (const minasastate &state, const real_1d_array &x, const real_1d_array &bndl, const real_1d_array &bndu)
 
void alglib_impl::minasarestartfrom (minasastate *state, ae_vector *x, ae_vector *bndl, ae_vector *bndu, ae_state *_state)
 
void alglib::minasaresults (const minasastate &state, real_1d_array &x, minasareport &rep)
 
void alglib_impl::minasaresults (minasastate *state, ae_vector *x, minasareport *rep, ae_state *_state)
 
void alglib::minasaresultsbuf (const minasastate &state, real_1d_array &x, minasareport &rep)
 
void alglib_impl::minasaresultsbuf (minasastate *state, ae_vector *x, minasareport *rep, ae_state *_state)
 
void alglib::minasasetalgorithm (const minasastate &state, const ae_int_t algotype)
 
void alglib_impl::minasasetalgorithm (minasastate *state, ae_int_t algotype, ae_state *_state)
 
void alglib::minasasetcond (const minasastate &state, const double epsg, const double epsf, const double epsx, const ae_int_t maxits)
 
void alglib_impl::minasasetcond (minasastate *state, double epsg, double epsf, double epsx, ae_int_t maxits, ae_state *_state)
 
void alglib::minasasetstpmax (const minasastate &state, const double stpmax)
 
void alglib_impl::minasasetstpmax (minasastate *state, double stpmax, ae_state *_state)
 
void alglib::minasasetxrep (const minasastate &state, const bool needxrep)
 
void alglib_impl::minasasetxrep (minasastate *state, ae_bool needxrep, ae_state *_state)
 
void alglib_impl::minbccreate (ae_int_t n, ae_vector *x, minbcstate *state, ae_state *_state)
 
void alglib::minbccreate (const ae_int_t n, const real_1d_array &x, minbcstate &state)
 
void alglib::minbccreate (const real_1d_array &x, minbcstate &state)
 
void alglib_impl::minbccreatef (ae_int_t n, ae_vector *x, double diffstep, minbcstate *state, ae_state *_state)
 
void alglib::minbccreatef (const ae_int_t n, const real_1d_array &x, const double diffstep, minbcstate &state)
 
void alglib::minbccreatef (const real_1d_array &x, const double diffstep, minbcstate &state)
 
bool alglib::minbciteration (const minbcstate &state)
 
ae_bool alglib_impl::minbciteration (minbcstate *state, ae_state *_state)
 
void alglib::minbcoptimize (minbcstate &state, void(*func)(const real_1d_array &x, double &func, void *ptr), void(*rep)(const real_1d_array &x, double func, void *ptr)=NULL, void *ptr=NULL)
 
void alglib::minbcoptimize (minbcstate &state, void(*grad)(const real_1d_array &x, double &func, real_1d_array &grad, void *ptr), void(*rep)(const real_1d_array &x, double func, void *ptr)=NULL, void *ptr=NULL)
 
void alglib::minbcrequesttermination (const minbcstate &state)
 
void alglib_impl::minbcrequesttermination (minbcstate *state, ae_state *_state)
 
void alglib::minbcrestartfrom (const minbcstate &state, const real_1d_array &x)
 
void alglib_impl::minbcrestartfrom (minbcstate *state, ae_vector *x, ae_state *_state)
 
void alglib::minbcresults (const minbcstate &state, real_1d_array &x, minbcreport &rep)
 
void alglib_impl::minbcresults (minbcstate *state, ae_vector *x, minbcreport *rep, ae_state *_state)
 
void alglib::minbcresultsbuf (const minbcstate &state, real_1d_array &x, minbcreport &rep)
 
void alglib_impl::minbcresultsbuf (minbcstate *state, ae_vector *x, minbcreport *rep, ae_state *_state)
 
void alglib::minbcsetbc (const minbcstate &state, const real_1d_array &bndl, const real_1d_array &bndu)
 
void alglib_impl::minbcsetbc (minbcstate *state, ae_vector *bndl, ae_vector *bndu, ae_state *_state)
 
void alglib::minbcsetcond (const minbcstate &state, const double epsg, const double epsf, const double epsx, const ae_int_t maxits)
 
void alglib_impl::minbcsetcond (minbcstate *state, double epsg, double epsf, double epsx, ae_int_t maxits, ae_state *_state)
 
void alglib::minbcsetgradientcheck (const minbcstate &state, const double teststep)
 
void alglib_impl::minbcsetgradientcheck (minbcstate *state, double teststep, ae_state *_state)
 
void alglib::minbcsetprecdefault (const minbcstate &state)
 
void alglib_impl::minbcsetprecdefault (minbcstate *state, ae_state *_state)
 
void alglib::minbcsetprecdiag (const minbcstate &state, const real_1d_array &d)
 
void alglib_impl::minbcsetprecdiag (minbcstate *state, ae_vector *d, ae_state *_state)
 
void alglib::minbcsetprecscale (const minbcstate &state)
 
void alglib_impl::minbcsetprecscale (minbcstate *state, ae_state *_state)
 
void alglib::minbcsetscale (const minbcstate &state, const real_1d_array &s)
 
void alglib_impl::minbcsetscale (minbcstate *state, ae_vector *s, ae_state *_state)
 
void alglib::minbcsetstpmax (const minbcstate &state, const double stpmax)
 
void alglib_impl::minbcsetstpmax (minbcstate *state, double stpmax, ae_state *_state)
 
void alglib::minbcsetxrep (const minbcstate &state, const bool needxrep)
 
void alglib_impl::minbcsetxrep (minbcstate *state, ae_bool needxrep, ae_state *_state)
 
void alglib_impl::minbleiccreate (ae_int_t n, ae_vector *x, minbleicstate *state, ae_state *_state)
 
void alglib::minbleiccreate (const ae_int_t n, const real_1d_array &x, minbleicstate &state)
 
void alglib::minbleiccreate (const real_1d_array &x, minbleicstate &state)
 
void alglib_impl::minbleiccreatef (ae_int_t n, ae_vector *x, double diffstep, minbleicstate *state, ae_state *_state)
 
void alglib::minbleiccreatef (const ae_int_t n, const real_1d_array &x, const double diffstep, minbleicstate &state)
 
void alglib::minbleiccreatef (const real_1d_array &x, const double diffstep, minbleicstate &state)
 
void alglib_impl::minbleicemergencytermination (minbleicstate *state, ae_state *_state)
 
bool alglib::minbleiciteration (const minbleicstate &state)
 
ae_bool alglib_impl::minbleiciteration (minbleicstate *state, ae_state *_state)
 
void alglib::minbleicoptimize (minbleicstate &state, void(*func)(const real_1d_array &x, double &func, void *ptr), void(*rep)(const real_1d_array &x, double func, void *ptr)=NULL, void *ptr=NULL)
 
void alglib::minbleicoptimize (minbleicstate &state, void(*grad)(const real_1d_array &x, double &func, real_1d_array &grad, void *ptr), void(*rep)(const real_1d_array &x, double func, void *ptr)=NULL, void *ptr=NULL)
 
void alglib::minbleicrequesttermination (const minbleicstate &state)
 
void alglib_impl::minbleicrequesttermination (minbleicstate *state, ae_state *_state)
 
void alglib::minbleicrestartfrom (const minbleicstate &state, const real_1d_array &x)
 
void alglib_impl::minbleicrestartfrom (minbleicstate *state, ae_vector *x, ae_state *_state)
 
void alglib::minbleicresults (const minbleicstate &state, real_1d_array &x, minbleicreport &rep)
 
void alglib_impl::minbleicresults (minbleicstate *state, ae_vector *x, minbleicreport *rep, ae_state *_state)
 
void alglib::minbleicresultsbuf (const minbleicstate &state, real_1d_array &x, minbleicreport &rep)
 
void alglib_impl::minbleicresultsbuf (minbleicstate *state, ae_vector *x, minbleicreport *rep, ae_state *_state)
 
void alglib::minbleicsetbarrierdecay (const minbleicstate &state, const double mudecay)
 
void alglib_impl::minbleicsetbarrierdecay (minbleicstate *state, double mudecay, ae_state *_state)
 
void alglib::minbleicsetbarrierwidth (const minbleicstate &state, const double mu)
 
void alglib_impl::minbleicsetbarrierwidth (minbleicstate *state, double mu, ae_state *_state)
 
void alglib::minbleicsetbc (const minbleicstate &state, const real_1d_array &bndl, const real_1d_array &bndu)
 
void alglib_impl::minbleicsetbc (minbleicstate *state, ae_vector *bndl, ae_vector *bndu, ae_state *_state)
 
void alglib::minbleicsetcond (const minbleicstate &state, const double epsg, const double epsf, const double epsx, const ae_int_t maxits)
 
void alglib_impl::minbleicsetcond (minbleicstate *state, double epsg, double epsf, double epsx, ae_int_t maxits, ae_state *_state)
 
void alglib_impl::minbleicsetdrep (minbleicstate *state, ae_bool needdrep, ae_state *_state)
 
void alglib::minbleicsetgradientcheck (const minbleicstate &state, const double teststep)
 
void alglib_impl::minbleicsetgradientcheck (minbleicstate *state, double teststep, ae_state *_state)
 
void alglib::minbleicsetlc (const minbleicstate &state, const real_2d_array &c, const integer_1d_array &ct)
 
void alglib::minbleicsetlc (const minbleicstate &state, const real_2d_array &c, const integer_1d_array &ct, const ae_int_t k)
 
void alglib_impl::minbleicsetlc (minbleicstate *state, ae_matrix *c, ae_vector *ct, ae_int_t k, ae_state *_state)
 
void alglib::minbleicsetprecdefault (const minbleicstate &state)
 
void alglib_impl::minbleicsetprecdefault (minbleicstate *state, ae_state *_state)
 
void alglib::minbleicsetprecdiag (const minbleicstate &state, const real_1d_array &d)
 
void alglib_impl::minbleicsetprecdiag (minbleicstate *state, ae_vector *d, ae_state *_state)
 
void alglib::minbleicsetprecscale (const minbleicstate &state)
 
void alglib_impl::minbleicsetprecscale (minbleicstate *state, ae_state *_state)
 
void alglib::minbleicsetscale (const minbleicstate &state, const real_1d_array &s)
 
void alglib_impl::minbleicsetscale (minbleicstate *state, ae_vector *s, ae_state *_state)
 
void alglib::minbleicsetstpmax (const minbleicstate &state, const double stpmax)
 
void alglib_impl::minbleicsetstpmax (minbleicstate *state, double stpmax, ae_state *_state)
 
void alglib::minbleicsetxrep (const minbleicstate &state, const bool needxrep)
 
void alglib_impl::minbleicsetxrep (minbleicstate *state, ae_bool needxrep, ae_state *_state)
 
void alglib_impl::mincgcreate (ae_int_t n, ae_vector *x, mincgstate *state, ae_state *_state)
 
void alglib::mincgcreate (const ae_int_t n, const real_1d_array &x, mincgstate &state)
 
void alglib::mincgcreate (const real_1d_array &x, mincgstate &state)
 
void alglib_impl::mincgcreatef (ae_int_t n, ae_vector *x, double diffstep, mincgstate *state, ae_state *_state)
 
void alglib::mincgcreatef (const ae_int_t n, const real_1d_array &x, const double diffstep, mincgstate &state)
 
void alglib::mincgcreatef (const real_1d_array &x, const double diffstep, mincgstate &state)
 
bool alglib::mincgiteration (const mincgstate &state)
 
ae_bool alglib_impl::mincgiteration (mincgstate *state, ae_state *_state)
 
double alglib_impl::mincglastgoodstep (mincgstate *state, ae_state *_state)
 
void alglib::mincgoptimize (mincgstate &state, void(*func)(const real_1d_array &x, double &func, void *ptr), void(*rep)(const real_1d_array &x, double func, void *ptr)=NULL, void *ptr=NULL)
 
void alglib::mincgoptimize (mincgstate &state, void(*grad)(const real_1d_array &x, double &func, real_1d_array &grad, void *ptr), void(*rep)(const real_1d_array &x, double func, void *ptr)=NULL, void *ptr=NULL)
 
void alglib::mincgrequesttermination (const mincgstate &state)
 
void alglib_impl::mincgrequesttermination (mincgstate *state, ae_state *_state)
 
void alglib::mincgrestartfrom (const mincgstate &state, const real_1d_array &x)
 
void alglib_impl::mincgrestartfrom (mincgstate *state, ae_vector *x, ae_state *_state)
 
void alglib::mincgresults (const mincgstate &state, real_1d_array &x, mincgreport &rep)
 
void alglib_impl::mincgresults (mincgstate *state, ae_vector *x, mincgreport *rep, ae_state *_state)
 
void alglib::mincgresultsbuf (const mincgstate &state, real_1d_array &x, mincgreport &rep)
 
void alglib_impl::mincgresultsbuf (mincgstate *state, ae_vector *x, mincgreport *rep, ae_state *_state)
 
void alglib::mincgsetcgtype (const mincgstate &state, const ae_int_t cgtype)
 
void alglib_impl::mincgsetcgtype (mincgstate *state, ae_int_t cgtype, ae_state *_state)
 
void alglib::mincgsetcond (const mincgstate &state, const double epsg, const double epsf, const double epsx, const ae_int_t maxits)
 
void alglib_impl::mincgsetcond (mincgstate *state, double epsg, double epsf, double epsx, ae_int_t maxits, ae_state *_state)
 
void alglib_impl::mincgsetdrep (mincgstate *state, ae_bool needdrep, ae_state *_state)
 
void alglib::mincgsetgradientcheck (const mincgstate &state, const double teststep)
 
void alglib_impl::mincgsetgradientcheck (mincgstate *state, double teststep, ae_state *_state)
 
void alglib::mincgsetprecdefault (const mincgstate &state)
 
void alglib_impl::mincgsetprecdefault (mincgstate *state, ae_state *_state)
 
void alglib::mincgsetprecdiag (const mincgstate &state, const real_1d_array &d)
 
void alglib_impl::mincgsetprecdiag (mincgstate *state, ae_vector *d, ae_state *_state)
 
void alglib_impl::mincgsetprecdiagfast (mincgstate *state, ae_vector *d, ae_state *_state)
 
void alglib_impl::mincgsetpreclowrankfast (mincgstate *state, ae_vector *d1, ae_vector *c, ae_matrix *v, ae_int_t vcnt, ae_state *_state)
 
void alglib::mincgsetprecscale (const mincgstate &state)
 
void alglib_impl::mincgsetprecscale (mincgstate *state, ae_state *_state)
 
void alglib_impl::mincgsetprecvarpart (mincgstate *state, ae_vector *d2, ae_state *_state)
 
void alglib::mincgsetscale (const mincgstate &state, const real_1d_array &s)
 
void alglib_impl::mincgsetscale (mincgstate *state, ae_vector *s, ae_state *_state)
 
void alglib::mincgsetstpmax (const mincgstate &state, const double stpmax)
 
void alglib_impl::mincgsetstpmax (mincgstate *state, double stpmax, ae_state *_state)
 
void alglib::mincgsetxrep (const mincgstate &state, const bool needxrep)
 
void alglib_impl::mincgsetxrep (mincgstate *state, ae_bool needxrep, ae_state *_state)
 
void alglib::mincgsuggeststep (const mincgstate &state, const double stp)
 
void alglib_impl::mincgsuggeststep (mincgstate *state, double stp, ae_state *_state)
 
void alglib_impl::minlbfgscreate (ae_int_t n, ae_int_t m, ae_vector *x, minlbfgsstate *state, ae_state *_state)
 
void alglib::minlbfgscreate (const ae_int_t m, const real_1d_array &x, minlbfgsstate &state)
 
void alglib::minlbfgscreate (const ae_int_t n, const ae_int_t m, const real_1d_array &x, minlbfgsstate &state)
 
void alglib_impl::minlbfgscreatef (ae_int_t n, ae_int_t m, ae_vector *x, double diffstep, minlbfgsstate *state, ae_state *_state)
 
void alglib::minlbfgscreatef (const ae_int_t m, const real_1d_array &x, const double diffstep, minlbfgsstate &state)
 
void alglib::minlbfgscreatef (const ae_int_t n, const ae_int_t m, const real_1d_array &x, const double diffstep, minlbfgsstate &state)
 
void alglib_impl::minlbfgscreatex (ae_int_t n, ae_int_t m, ae_vector *x, ae_int_t flags, double diffstep, minlbfgsstate *state, ae_state *_state)
 
bool alglib::minlbfgsiteration (const minlbfgsstate &state)
 
ae_bool alglib_impl::minlbfgsiteration (minlbfgsstate *state, ae_state *_state)
 
void alglib::minlbfgsoptimize (minlbfgsstate &state, void(*func)(const real_1d_array &x, double &func, void *ptr), void(*rep)(const real_1d_array &x, double func, void *ptr)=NULL, void *ptr=NULL)
 
void alglib::minlbfgsoptimize (minlbfgsstate &state, void(*grad)(const real_1d_array &x, double &func, real_1d_array &grad, void *ptr), void(*rep)(const real_1d_array &x, double func, void *ptr)=NULL, void *ptr=NULL)
 
void alglib::minlbfgsrequesttermination (const minlbfgsstate &state)
 
void alglib_impl::minlbfgsrequesttermination (minlbfgsstate *state, ae_state *_state)
 
void alglib::minlbfgsrestartfrom (const minlbfgsstate &state, const real_1d_array &x)
 
void alglib_impl::minlbfgsrestartfrom (minlbfgsstate *state, ae_vector *x, ae_state *_state)
 
void alglib::minlbfgsresults (const minlbfgsstate &state, real_1d_array &x, minlbfgsreport &rep)
 
void alglib_impl::minlbfgsresults (minlbfgsstate *state, ae_vector *x, minlbfgsreport *rep, ae_state *_state)
 
void alglib::minlbfgsresultsbuf (const minlbfgsstate &state, real_1d_array &x, minlbfgsreport &rep)
 
void alglib_impl::minlbfgsresultsbuf (minlbfgsstate *state, ae_vector *x, minlbfgsreport *rep, ae_state *_state)
 
void alglib::minlbfgssetcholeskypreconditioner (const minlbfgsstate &state, const real_2d_array &p, const bool isupper)
 
void alglib_impl::minlbfgssetcholeskypreconditioner (minlbfgsstate *state, ae_matrix *p, ae_bool isupper, ae_state *_state)
 
void alglib::minlbfgssetcond (const minlbfgsstate &state, const double epsg, const double epsf, const double epsx, const ae_int_t maxits)
 
void alglib_impl::minlbfgssetcond (minlbfgsstate *state, double epsg, double epsf, double epsx, ae_int_t maxits, ae_state *_state)
 
void alglib::minlbfgssetdefaultpreconditioner (const minlbfgsstate &state)
 
void alglib_impl::minlbfgssetdefaultpreconditioner (minlbfgsstate *state, ae_state *_state)
 
void alglib::minlbfgssetgradientcheck (const minlbfgsstate &state, const double teststep)
 
void alglib_impl::minlbfgssetgradientcheck (minlbfgsstate *state, double teststep, ae_state *_state)
 
void alglib::minlbfgssetpreccholesky (const minlbfgsstate &state, const real_2d_array &p, const bool isupper)
 
void alglib_impl::minlbfgssetpreccholesky (minlbfgsstate *state, ae_matrix *p, ae_bool isupper, ae_state *_state)
 
void alglib::minlbfgssetprecdefault (const minlbfgsstate &state)
 
void alglib_impl::minlbfgssetprecdefault (minlbfgsstate *state, ae_state *_state)
 
void alglib::minlbfgssetprecdiag (const minlbfgsstate &state, const real_1d_array &d)
 
void alglib_impl::minlbfgssetprecdiag (minlbfgsstate *state, ae_vector *d, ae_state *_state)
 
void alglib_impl::minlbfgssetpreclowrankexact (minlbfgsstate *state, ae_vector *d, ae_vector *c, ae_matrix *w, ae_int_t cnt, ae_state *_state)
 
void alglib_impl::minlbfgssetprecrankklbfgsfast (minlbfgsstate *state, ae_vector *d, ae_vector *c, ae_matrix *w, ae_int_t cnt, ae_state *_state)
 
void alglib::minlbfgssetprecscale (const minlbfgsstate &state)
 
void alglib_impl::minlbfgssetprecscale (minlbfgsstate *state, ae_state *_state)
 
void alglib::minlbfgssetscale (const minlbfgsstate &state, const real_1d_array &s)
 
void alglib_impl::minlbfgssetscale (minlbfgsstate *state, ae_vector *s, ae_state *_state)
 
void alglib::minlbfgssetstpmax (const minlbfgsstate &state, const double stpmax)
 
void alglib_impl::minlbfgssetstpmax (minlbfgsstate *state, double stpmax, ae_state *_state)
 
void alglib::minlbfgssetxrep (const minlbfgsstate &state, const bool needxrep)
 
void alglib_impl::minlbfgssetxrep (minlbfgsstate *state, ae_bool needxrep, ae_state *_state)
 
void alglib_impl::minlmcreatefgh (ae_int_t n, ae_vector *x, minlmstate *state, ae_state *_state)
 
void alglib::minlmcreatefgh (const ae_int_t n, const real_1d_array &x, minlmstate &state)
 
void alglib::minlmcreatefgh (const real_1d_array &x, minlmstate &state)
 
void alglib_impl::minlmcreatefgj (ae_int_t n, ae_int_t m, ae_vector *x, minlmstate *state, ae_state *_state)
 
void alglib::minlmcreatefgj (const ae_int_t m, const real_1d_array &x, minlmstate &state)
 
void alglib::minlmcreatefgj (const ae_int_t n, const ae_int_t m, const real_1d_array &x, minlmstate &state)
 
void alglib_impl::minlmcreatefj (ae_int_t n, ae_int_t m, ae_vector *x, minlmstate *state, ae_state *_state)
 
void alglib::minlmcreatefj (const ae_int_t m, const real_1d_array &x, minlmstate &state)
 
void alglib::minlmcreatefj (const ae_int_t n, const ae_int_t m, const real_1d_array &x, minlmstate &state)
 
void alglib_impl::minlmcreatev (ae_int_t n, ae_int_t m, ae_vector *x, double diffstep, minlmstate *state, ae_state *_state)
 
void alglib::minlmcreatev (const ae_int_t m, const real_1d_array &x, const double diffstep, minlmstate &state)
 
void alglib::minlmcreatev (const ae_int_t n, const ae_int_t m, const real_1d_array &x, const double diffstep, minlmstate &state)
 
void alglib_impl::minlmcreatevgj (ae_int_t n, ae_int_t m, ae_vector *x, minlmstate *state, ae_state *_state)
 
void alglib::minlmcreatevgj (const ae_int_t m, const real_1d_array &x, minlmstate &state)
 
void alglib::minlmcreatevgj (const ae_int_t n, const ae_int_t m, const real_1d_array &x, minlmstate &state)
 
void alglib_impl::minlmcreatevj (ae_int_t n, ae_int_t m, ae_vector *x, minlmstate *state, ae_state *_state)
 
void alglib::minlmcreatevj (const ae_int_t m, const real_1d_array &x, minlmstate &state)
 
void alglib::minlmcreatevj (const ae_int_t n, const ae_int_t m, const real_1d_array &x, minlmstate &state)
 
bool alglib::minlmiteration (const minlmstate &state)
 
ae_bool alglib_impl::minlmiteration (minlmstate *state, ae_state *_state)
 
void alglib::minlmoptimize (minlmstate &state, void(*func)(const real_1d_array &x, double &func, void *ptr), void(*grad)(const real_1d_array &x, double &func, real_1d_array &grad, void *ptr), void(*hess)(const real_1d_array &x, double &func, real_1d_array &grad, real_2d_array &hess, void *ptr), void(*rep)(const real_1d_array &x, double func, void *ptr)=NULL, void *ptr=NULL)
 
void alglib::minlmoptimize (minlmstate &state, void(*func)(const real_1d_array &x, double &func, void *ptr), void(*grad)(const real_1d_array &x, double &func, real_1d_array &grad, void *ptr), void(*jac)(const real_1d_array &x, real_1d_array &fi, real_2d_array &jac, void *ptr), void(*rep)(const real_1d_array &x, double func, void *ptr)=NULL, void *ptr=NULL)
 
void alglib::minlmoptimize (minlmstate &state, void(*func)(const real_1d_array &x, double &func, void *ptr), void(*jac)(const real_1d_array &x, real_1d_array &fi, real_2d_array &jac, void *ptr), void(*rep)(const real_1d_array &x, double func, void *ptr)=NULL, void *ptr=NULL)
 
void alglib::minlmoptimize (minlmstate &state, void(*fvec)(const real_1d_array &x, real_1d_array &fi, void *ptr), void(*jac)(const real_1d_array &x, real_1d_array &fi, real_2d_array &jac, void *ptr), void(*rep)(const real_1d_array &x, double func, void *ptr)=NULL, void *ptr=NULL)
 
void alglib::minlmoptimize (minlmstate &state, void(*fvec)(const real_1d_array &x, real_1d_array &fi, void *ptr), void(*rep)(const real_1d_array &x, double func, void *ptr)=NULL, void *ptr=NULL)
 
void alglib::minlmrequesttermination (const minlmstate &state)
 
void alglib_impl::minlmrequesttermination (minlmstate *state, ae_state *_state)
 
void alglib::minlmrestartfrom (const minlmstate &state, const real_1d_array &x)
 
void alglib_impl::minlmrestartfrom (minlmstate *state, ae_vector *x, ae_state *_state)
 
void alglib::minlmresults (const minlmstate &state, real_1d_array &x, minlmreport &rep)
 
void alglib_impl::minlmresults (minlmstate *state, ae_vector *x, minlmreport *rep, ae_state *_state)
 
void alglib::minlmresultsbuf (const minlmstate &state, real_1d_array &x, minlmreport &rep)
 
void alglib_impl::minlmresultsbuf (minlmstate *state, ae_vector *x, minlmreport *rep, ae_state *_state)
 
void alglib::minlmsetacctype (const minlmstate &state, const ae_int_t acctype)
 
void alglib_impl::minlmsetacctype (minlmstate *state, ae_int_t acctype, ae_state *_state)
 
void alglib::minlmsetbc (const minlmstate &state, const real_1d_array &bndl, const real_1d_array &bndu)
 
void alglib_impl::minlmsetbc (minlmstate *state, ae_vector *bndl, ae_vector *bndu, ae_state *_state)
 
void alglib::minlmsetcond (const minlmstate &state, const double epsx, const ae_int_t maxits)
 
void alglib_impl::minlmsetcond (minlmstate *state, double epsx, ae_int_t maxits, ae_state *_state)
 
void alglib::minlmsetgradientcheck (const minlmstate &state, const double teststep)
 
void alglib_impl::minlmsetgradientcheck (minlmstate *state, double teststep, ae_state *_state)
 
void alglib::minlmsetlc (const minlmstate &state, const real_2d_array &c, const integer_1d_array &ct)
 
void alglib::minlmsetlc (const minlmstate &state, const real_2d_array &c, const integer_1d_array &ct, const ae_int_t k)
 
void alglib_impl::minlmsetlc (minlmstate *state, ae_matrix *c, ae_vector *ct, ae_int_t k, ae_state *_state)
 
void alglib::minlmsetscale (const minlmstate &state, const real_1d_array &s)
 
void alglib_impl::minlmsetscale (minlmstate *state, ae_vector *s, ae_state *_state)
 
void alglib::minlmsetstpmax (const minlmstate &state, const double stpmax)
 
void alglib_impl::minlmsetstpmax (minlmstate *state, double stpmax, ae_state *_state)
 
void alglib::minlmsetxrep (const minlmstate &state, const bool needxrep)
 
void alglib_impl::minlmsetxrep (minlmstate *state, ae_bool needxrep, ae_state *_state)
 
void alglib_impl::minnlccreate (ae_int_t n, ae_vector *x, minnlcstate *state, ae_state *_state)
 
void alglib::minnlccreate (const ae_int_t n, const real_1d_array &x, minnlcstate &state)
 
void alglib::minnlccreate (const real_1d_array &x, minnlcstate &state)
 
void alglib_impl::minnlccreatef (ae_int_t n, ae_vector *x, double diffstep, minnlcstate *state, ae_state *_state)
 
void alglib::minnlccreatef (const ae_int_t n, const real_1d_array &x, const double diffstep, minnlcstate &state)
 
void alglib::minnlccreatef (const real_1d_array &x, const double diffstep, minnlcstate &state)
 
void alglib_impl::minnlcequalitypenaltyfunction (double alpha, double *f, double *df, double *d2f, ae_state *_state)
 
void alglib_impl::minnlcinequalitypenaltyfunction (double alpha, double stabilizingpoint, double *f, double *df, double *d2f, ae_state *_state)
 
void alglib_impl::minnlcinequalityshiftfunction (double alpha, double *f, double *df, double *d2f, ae_state *_state)
 
bool alglib::minnlciteration (const minnlcstate &state)
 
ae_bool alglib_impl::minnlciteration (minnlcstate *state, ae_state *_state)
 
void alglib::minnlcoptimize (minnlcstate &state, void(*fvec)(const real_1d_array &x, real_1d_array &fi, void *ptr), void(*rep)(const real_1d_array &x, double func, void *ptr)=NULL, void *ptr=NULL)
 
void alglib::minnlcoptimize (minnlcstate &state, void(*jac)(const real_1d_array &x, real_1d_array &fi, real_2d_array &jac, void *ptr), void(*rep)(const real_1d_array &x, double func, void *ptr)=NULL, void *ptr=NULL)
 
void alglib::minnlcrestartfrom (const minnlcstate &state, const real_1d_array &x)
 
void alglib_impl::minnlcrestartfrom (minnlcstate *state, ae_vector *x, ae_state *_state)
 
void alglib::minnlcresults (const minnlcstate &state, real_1d_array &x, minnlcreport &rep)
 
void alglib_impl::minnlcresults (minnlcstate *state, ae_vector *x, minnlcreport *rep, ae_state *_state)
 
void alglib::minnlcresultsbuf (const minnlcstate &state, real_1d_array &x, minnlcreport &rep)
 
void alglib_impl::minnlcresultsbuf (minnlcstate *state, ae_vector *x, minnlcreport *rep, ae_state *_state)
 
void alglib::minnlcsetalgoaul (const minnlcstate &state, const double rho, const ae_int_t itscnt)
 
void alglib_impl::minnlcsetalgoaul (minnlcstate *state, double rho, ae_int_t itscnt, ae_state *_state)
 
void alglib::minnlcsetbc (const minnlcstate &state, const real_1d_array &bndl, const real_1d_array &bndu)
 
void alglib_impl::minnlcsetbc (minnlcstate *state, ae_vector *bndl, ae_vector *bndu, ae_state *_state)
 
void alglib::minnlcsetcond (const minnlcstate &state, const double epsg, const double epsf, const double epsx, const ae_int_t maxits)
 
void alglib_impl::minnlcsetcond (minnlcstate *state, double epsg, double epsf, double epsx, ae_int_t maxits, ae_state *_state)
 
void alglib::minnlcsetgradientcheck (const minnlcstate &state, const double teststep)
 
void alglib_impl::minnlcsetgradientcheck (minnlcstate *state, double teststep, ae_state *_state)
 
void alglib::minnlcsetlc (const minnlcstate &state, const real_2d_array &c, const integer_1d_array &ct)
 
void alglib::minnlcsetlc (const minnlcstate &state, const real_2d_array &c, const integer_1d_array &ct, const ae_int_t k)
 
void alglib_impl::minnlcsetlc (minnlcstate *state, ae_matrix *c, ae_vector *ct, ae_int_t k, ae_state *_state)
 
void alglib::minnlcsetnlc (const minnlcstate &state, const ae_int_t nlec, const ae_int_t nlic)
 
void alglib_impl::minnlcsetnlc (minnlcstate *state, ae_int_t nlec, ae_int_t nlic, ae_state *_state)
 
void alglib::minnlcsetprecexactlowrank (const minnlcstate &state, const ae_int_t updatefreq)
 
void alglib_impl::minnlcsetprecexactlowrank (minnlcstate *state, ae_int_t updatefreq, ae_state *_state)
 
void alglib::minnlcsetprecexactrobust (const minnlcstate &state, const ae_int_t updatefreq)
 
void alglib_impl::minnlcsetprecexactrobust (minnlcstate *state, ae_int_t updatefreq, ae_state *_state)
 
void alglib::minnlcsetprecinexact (const minnlcstate &state)
 
void alglib_impl::minnlcsetprecinexact (minnlcstate *state, ae_state *_state)
 
void alglib::minnlcsetprecnone (const minnlcstate &state)
 
void alglib_impl::minnlcsetprecnone (minnlcstate *state, ae_state *_state)
 
void alglib::minnlcsetscale (const minnlcstate &state, const real_1d_array &s)
 
void alglib_impl::minnlcsetscale (minnlcstate *state, ae_vector *s, ae_state *_state)
 
void alglib::minnlcsetstpmax (const minnlcstate &state, const double stpmax)
 
void alglib_impl::minnlcsetstpmax (minnlcstate *state, double stpmax, ae_state *_state)
 
void alglib::minnlcsetxrep (const minnlcstate &state, const bool needxrep)
 
void alglib_impl::minnlcsetxrep (minnlcstate *state, ae_bool needxrep, ae_state *_state)
 
void alglib_impl::minnscreate (ae_int_t n, ae_vector *x, minnsstate *state, ae_state *_state)
 
void alglib::minnscreate (const ae_int_t n, const real_1d_array &x, minnsstate &state)
 
void alglib::minnscreate (const real_1d_array &x, minnsstate &state)
 
void alglib_impl::minnscreatef (ae_int_t n, ae_vector *x, double diffstep, minnsstate *state, ae_state *_state)
 
void alglib::minnscreatef (const ae_int_t n, const real_1d_array &x, const double diffstep, minnsstate &state)
 
void alglib::minnscreatef (const real_1d_array &x, const double diffstep, minnsstate &state)
 
bool alglib::minnsiteration (const minnsstate &state)
 
ae_bool alglib_impl::minnsiteration (minnsstate *state, ae_state *_state)
 
void alglib::minnsoptimize (minnsstate &state, void(*fvec)(const real_1d_array &x, real_1d_array &fi, void *ptr), void(*rep)(const real_1d_array &x, double func, void *ptr)=NULL, void *ptr=NULL)
 
void alglib::minnsoptimize (minnsstate &state, void(*jac)(const real_1d_array &x, real_1d_array &fi, real_2d_array &jac, void *ptr), void(*rep)(const real_1d_array &x, double func, void *ptr)=NULL, void *ptr=NULL)
 
void alglib::minnsrequesttermination (const minnsstate &state)
 
void alglib_impl::minnsrequesttermination (minnsstate *state, ae_state *_state)
 
void alglib::minnsrestartfrom (const minnsstate &state, const real_1d_array &x)
 
void alglib_impl::minnsrestartfrom (minnsstate *state, ae_vector *x, ae_state *_state)
 
void alglib::minnsresults (const minnsstate &state, real_1d_array &x, minnsreport &rep)
 
void alglib_impl::minnsresults (minnsstate *state, ae_vector *x, minnsreport *rep, ae_state *_state)
 
void alglib::minnsresultsbuf (const minnsstate &state, real_1d_array &x, minnsreport &rep)
 
void alglib_impl::minnsresultsbuf (minnsstate *state, ae_vector *x, minnsreport *rep, ae_state *_state)
 
void alglib::minnssetalgoags (const minnsstate &state, const double radius, const double penalty)
 
void alglib_impl::minnssetalgoags (minnsstate *state, double radius, double penalty, ae_state *_state)
 
void alglib::minnssetbc (const minnsstate &state, const real_1d_array &bndl, const real_1d_array &bndu)
 
void alglib_impl::minnssetbc (minnsstate *state, ae_vector *bndl, ae_vector *bndu, ae_state *_state)
 
void alglib::minnssetcond (const minnsstate &state, const double epsx, const ae_int_t maxits)
 
void alglib_impl::minnssetcond (minnsstate *state, double epsx, ae_int_t maxits, ae_state *_state)
 
void alglib::minnssetlc (const minnsstate &state, const real_2d_array &c, const integer_1d_array &ct)
 
void alglib::minnssetlc (const minnsstate &state, const real_2d_array &c, const integer_1d_array &ct, const ae_int_t k)
 
void alglib_impl::minnssetlc (minnsstate *state, ae_matrix *c, ae_vector *ct, ae_int_t k, ae_state *_state)
 
void alglib::minnssetnlc (const minnsstate &state, const ae_int_t nlec, const ae_int_t nlic)
 
void alglib_impl::minnssetnlc (minnsstate *state, ae_int_t nlec, ae_int_t nlic, ae_state *_state)
 
void alglib::minnssetscale (const minnsstate &state, const real_1d_array &s)
 
void alglib_impl::minnssetscale (minnsstate *state, ae_vector *s, ae_state *_state)
 
void alglib::minnssetxrep (const minnsstate &state, const bool needxrep)
 
void alglib_impl::minnssetxrep (minnsstate *state, ae_bool needxrep, ae_state *_state)
 
void alglib_impl::minqpcreate (ae_int_t n, minqpstate *state, ae_state *_state)
 
void alglib::minqpcreate (const ae_int_t n, minqpstate &state)
 
void alglib::minqpoptimize (const minqpstate &state)
 
void alglib_impl::minqpoptimize (minqpstate *state, ae_state *_state)
 
void alglib::minqpresults (const minqpstate &state, real_1d_array &x, minqpreport &rep)
 
void alglib_impl::minqpresults (minqpstate *state, ae_vector *x, minqpreport *rep, ae_state *_state)
 
void alglib::minqpresultsbuf (const minqpstate &state, real_1d_array &x, minqpreport &rep)
 
void alglib_impl::minqpresultsbuf (minqpstate *state, ae_vector *x, minqpreport *rep, ae_state *_state)
 
void alglib_impl::minqprewritediagonal (minqpstate *state, ae_vector *s, ae_state *_state)
 
void alglib::minqpsetalgobleic (const minqpstate &state, const double epsg, const double epsf, const double epsx, const ae_int_t maxits)
 
void alglib_impl::minqpsetalgobleic (minqpstate *state, double epsg, double epsf, double epsx, ae_int_t maxits, ae_state *_state)
 
void alglib::minqpsetalgocholesky (const minqpstate &state)
 
void alglib_impl::minqpsetalgocholesky (minqpstate *state, ae_state *_state)
 
void alglib::minqpsetalgodenseaul (const minqpstate &state, const double epsx, const double rho, const ae_int_t itscnt)
 
void alglib_impl::minqpsetalgodenseaul (minqpstate *state, double epsx, double rho, ae_int_t itscnt, ae_state *_state)
 
void alglib::minqpsetalgoquickqp (const minqpstate &state, const double epsg, const double epsf, const double epsx, const ae_int_t maxouterits, const bool usenewton)
 
void alglib_impl::minqpsetalgoquickqp (minqpstate *state, double epsg, double epsf, double epsx, ae_int_t maxouterits, ae_bool usenewton, ae_state *_state)
 
void alglib::minqpsetbc (const minqpstate &state, const real_1d_array &bndl, const real_1d_array &bndu)
 
void alglib_impl::minqpsetbc (minqpstate *state, ae_vector *bndl, ae_vector *bndu, ae_state *_state)
 
void alglib::minqpsetlc (const minqpstate &state, const real_2d_array &c, const integer_1d_array &ct)
 
void alglib::minqpsetlc (const minqpstate &state, const real_2d_array &c, const integer_1d_array &ct, const ae_int_t k)
 
void alglib_impl::minqpsetlc (minqpstate *state, ae_matrix *c, ae_vector *ct, ae_int_t k, ae_state *_state)
 
void alglib::minqpsetlcmixed (const minqpstate &state, const real_2d_array &densec, const integer_1d_array &densect, const ae_int_t densek, const sparsematrix &sparsec, const integer_1d_array &sparsect, const ae_int_t sparsek)
 
void alglib_impl::minqpsetlcmixed (minqpstate *state, ae_matrix *densec, ae_vector *densect, ae_int_t densek, sparsematrix *sparsec, ae_vector *sparsect, ae_int_t sparsek, ae_state *_state)
 
void alglib::minqpsetlcsparse (const minqpstate &state, const sparsematrix &c, const integer_1d_array &ct, const ae_int_t k)
 
void alglib_impl::minqpsetlcsparse (minqpstate *state, sparsematrix *c, ae_vector *ct, ae_int_t k, ae_state *_state)
 
void alglib::minqpsetlinearterm (const minqpstate &state, const real_1d_array &b)
 
void alglib_impl::minqpsetlinearterm (minqpstate *state, ae_vector *b, ae_state *_state)
 
void alglib_impl::minqpsetlineartermfast (minqpstate *state, ae_vector *b, ae_state *_state)
 
void alglib::minqpsetorigin (const minqpstate &state, const real_1d_array &xorigin)
 
void alglib_impl::minqpsetorigin (minqpstate *state, ae_vector *xorigin, ae_state *_state)
 
void alglib_impl::minqpsetoriginfast (minqpstate *state, ae_vector *xorigin, ae_state *_state)
 
void alglib::minqpsetquadraticterm (const minqpstate &state, const real_2d_array &a)
 
void alglib::minqpsetquadraticterm (const minqpstate &state, const real_2d_array &a, const bool isupper)
 
void alglib_impl::minqpsetquadraticterm (minqpstate *state, ae_matrix *a, ae_bool isupper, ae_state *_state)
 
void alglib_impl::minqpsetquadratictermfast (minqpstate *state, ae_matrix *a, ae_bool isupper, double s, ae_state *_state)
 
void alglib::minqpsetquadratictermsparse (const minqpstate &state, const sparsematrix &a, const bool isupper)
 
void alglib_impl::minqpsetquadratictermsparse (minqpstate *state, sparsematrix *a, ae_bool isupper, ae_state *_state)
 
void alglib::minqpsetscale (const minqpstate &state, const real_1d_array &s)
 
void alglib_impl::minqpsetscale (minqpstate *state, ae_vector *s, ae_state *_state)
 
void alglib::minqpsetstartingpoint (const minqpstate &state, const real_1d_array &x)
 
void alglib_impl::minqpsetstartingpoint (minqpstate *state, ae_vector *x, ae_state *_state)
 
void alglib_impl::minqpsetstartingpointfast (minqpstate *state, ae_vector *x, ae_state *_state)
 
ae_int_t alglib_impl::numberofchangedconstraints (ae_vector *x, ae_vector *xprev, ae_vector *bndl, ae_vector *havebndl, ae_vector *bndu, ae_vector *havebndu, ae_int_t nmain, ae_int_t nslack, ae_state *_state)
 
ae_int_t alglib_impl::postprocessboundedstep (ae_vector *x, ae_vector *xprev, ae_vector *bndl, ae_vector *havebndl, ae_vector *bndu, ae_vector *havebndu, ae_int_t nmain, ae_int_t nslack, ae_int_t variabletofreeze, double valuetofreeze, double steptaken, double maxsteplen, ae_state *_state)
 
void alglib_impl::preparelowrankpreconditioner (ae_vector *d, ae_vector *c, ae_matrix *w, ae_int_t n, ae_int_t k, precbuflowrank *buf, ae_state *_state)
 
void alglib_impl::projectgradientintobc (ae_vector *x, ae_vector *g, ae_vector *bl, ae_vector *havebl, ae_vector *bu, ae_vector *havebu, ae_int_t nmain, ae_int_t nslack, ae_state *_state)
 
void alglib_impl::qpbleiccopysettings (qpbleicsettings *src, qpbleicsettings *dst, ae_state *_state)
 
void alglib_impl::qpbleicloaddefaults (ae_int_t nmain, qpbleicsettings *s, ae_state *_state)
 
void alglib_impl::qpbleicoptimize (convexquadraticmodel *a, sparsematrix *sparsea, ae_int_t akind, ae_bool sparseaupper, double absasum, double absasum2, ae_vector *b, ae_vector *bndl, ae_vector *bndu, ae_vector *s, ae_vector *xorigin, ae_int_t n, ae_matrix *cleic, ae_int_t nec, ae_int_t nic, qpbleicsettings *settings, qpbleicbuffers *sstate, ae_bool *firstcall, ae_vector *xs, ae_int_t *terminationtype, ae_state *_state)
 
void alglib_impl::qpcholeskycopysettings (qpcholeskysettings *src, qpcholeskysettings *dst, ae_state *_state)
 
void alglib_impl::qpcholeskyloaddefaults (ae_int_t nmain, qpcholeskysettings *s, ae_state *_state)
 
void alglib_impl::qpcholeskyoptimize (convexquadraticmodel *a, double anorm, ae_vector *b, ae_vector *bndl, ae_vector *bndu, ae_vector *s, ae_vector *xorigin, ae_int_t n, ae_matrix *cleic, ae_int_t nec, ae_int_t nic, qpcholeskybuffers *sstate, ae_vector *xsc, ae_int_t *terminationtype, ae_state *_state)
 
void alglib_impl::qpdenseaulloaddefaults (ae_int_t nmain, qpdenseaulsettings *s, ae_state *_state)
 
void alglib_impl::qpdenseauloptimize (convexquadraticmodel *a, sparsematrix *sparsea, ae_int_t akind, ae_bool sparseaupper, ae_vector *b, ae_vector *bndl, ae_vector *bndu, ae_vector *s, ae_vector *xorigin, ae_int_t nn, ae_matrix *cleic, ae_int_t dnec, ae_int_t dnic, sparsematrix *scleic, ae_int_t snec, ae_int_t snic, ae_bool renormlc, qpdenseaulsettings *settings, qpdenseaulbuffers *state, ae_vector *xs, ae_int_t *terminationtype, ae_state *_state)
 
void alglib_impl::qqpcopysettings (qqpsettings *src, qqpsettings *dst, ae_state *_state)
 
void alglib_impl::qqploaddefaults (ae_int_t nmain, qqpsettings *s, ae_state *_state)
 
void alglib_impl::qqpoptimize (convexquadraticmodel *cqmac, sparsematrix *sparseac, ae_matrix *denseac, ae_int_t akind, ae_bool isupper, ae_vector *bc, ae_vector *bndlc, ae_vector *bnduc, ae_vector *sc, ae_vector *xoriginc, ae_int_t nc, ae_matrix *cleicc, ae_int_t nec, ae_int_t nic, qqpsettings *settings, qqpbuffers *sstate, ae_vector *xs, ae_int_t *terminationtype, ae_state *_state)
 
double alglib_impl::sasactivelcpenalty1 (sactiveset *state, ae_vector *x, ae_state *_state)
 
void alglib_impl::sasconstraineddescent (sactiveset *state, ae_vector *g, ae_vector *d, ae_state *_state)
 
void alglib_impl::sasconstraineddescentprec (sactiveset *state, ae_vector *g, ae_vector *d, ae_state *_state)
 
void alglib_impl::sasconstraineddirection (sactiveset *state, ae_vector *d, ae_state *_state)
 
void alglib_impl::sasconstraineddirectionprec (sactiveset *state, ae_vector *d, ae_state *_state)
 
void alglib_impl::sascorrection (sactiveset *state, ae_vector *x, double *penalty, ae_state *_state)
 
void alglib_impl::sasexploredirection (sactiveset *state, ae_vector *d, double *stpmax, ae_int_t *cidx, double *vval, ae_state *_state)
 
void alglib_impl::sasimmediateactivation (sactiveset *state, ae_int_t cidx, double cval, ae_state *_state)
 
void alglib_impl::sasinit (ae_int_t n, sactiveset *s, ae_state *_state)
 
ae_int_t alglib_impl::sasmoveto (sactiveset *state, ae_vector *xn, ae_bool needact, ae_int_t cidx, double cval, ae_state *_state)
 
void alglib_impl::sasreactivateconstraints (sactiveset *state, ae_vector *gc, ae_state *_state)
 
void alglib_impl::sasreactivateconstraintsprec (sactiveset *state, ae_vector *gc, ae_state *_state)
 
void alglib_impl::sasrebuildbasis (sactiveset *state, ae_state *_state)
 
double alglib_impl::sasscaledconstrainednorm (sactiveset *state, ae_vector *d, ae_state *_state)
 
void alglib_impl::sassetbc (sactiveset *state, ae_vector *bndl, ae_vector *bndu, ae_state *_state)
 
void alglib_impl::sassetlc (sactiveset *state, ae_matrix *c, ae_vector *ct, ae_int_t k, ae_state *_state)
 
void alglib_impl::sassetlcx (sactiveset *state, ae_matrix *cleic, ae_int_t nec, ae_int_t nic, ae_state *_state)
 
void alglib_impl::sassetprecdiag (sactiveset *state, ae_vector *d, ae_state *_state)
 
void alglib_impl::sassetscale (sactiveset *state, ae_vector *s, ae_state *_state)
 
ae_bool alglib_impl::sasstartoptimization (sactiveset *state, ae_vector *x, ae_state *_state)
 
void alglib_impl::sasstopoptimization (sactiveset *state, ae_state *_state)
 
void alglib_impl::snnlsdropnnc (snnlssolver *s, ae_int_t idx, ae_state *_state)
 
void alglib_impl::snnlsinit (ae_int_t nsmax, ae_int_t ndmax, ae_int_t nrmax, snnlssolver *s, ae_state *_state)
 
void alglib_impl::snnlssetproblem (snnlssolver *s, ae_matrix *a, ae_vector *b, ae_int_t ns, ae_int_t nd, ae_int_t nr, ae_state *_state)
 
void alglib_impl::snnlssolve (snnlssolver *s, ae_vector *x, ae_state *_state)
 
void alglib_impl::trimfunction (double *f, ae_vector *g, ae_int_t n, double threshold, ae_state *_state)
 
void alglib_impl::trimprepare (double f, double *threshold, ae_state *_state)
 
Page URL: http://wiki.math.ethz.ch/bin/view/Concepts/WebHome
21 August 2020
© 2020 Eidgenössische Technische Hochschule Zürich