Community
cancel
Showing results for
Did you mean: Beginner
80 Views

## dtrnlspbc_init fails with TR_INVALID_OPTION

It appears that the trust region optimizer can only handle cases when number of function arguments is equal to number of function values (square Jacobian).

In particular, in the code below (this is a slightly modified fragment of optimization example from the MKL library package), the initialization function  dtrnlspbc_init fails (returns TR_INVALID_OPTION(1502)) whenever m != n. In particular, if n = 3, m = 1 (a scalar function of 3 variables). Note, that this initialization function does not know anything about objective function, it succeeds whenever m = n, like m = 3, n =3 or m = 5, n = 5.  It fails if n != n.

Is this expected behavior?

If it is not, what am I doing wrong?

Thanks.

int main()
{
/* user’s objective function */
extern void extended_powell(MKL_INT *, MKL_INT *, double *, double *, void *);
/* n - number of function variables
m - dimension of function value */
MKL_INT n = 3, m = 1;
/* precisions for stop-criteria (see manual for more details) */
double eps;
/* precision of the Jacobian matrix calculation */
double jac_eps;
/* solution vector. contains values x for f(x) */
double *x = NULL;
/* iter1 - maximum number of iterations
iter2 - maximum number of iterations of calculation of trial-step */
MKL_INT iter1 = 1000, iter2 = 100;
/* initial step bound */
double rs = 0.0;
/* reverse communication interface parameter */
MKL_INT RCI_Request;
/* controls of rci cycle */
MKL_INT successful;
/* function (f(x)) value vector */
double *fvec = NULL;
/* jacobi matrix */
double *fjac = NULL;
/* lower and upper bounds */
double *LW = NULL, *UP = NULL;
/* number of iterations */
MKL_INT iter;
/* number of stop-criterion */
MKL_INT st_cr;
/* initial and final residuals */
double r1, r2;
/* TR solver handle */
_TRNSPBC_HANDLE_t handle;
/* cycle’s counter */
MKL_INT i;
/* results of input parameter checking */
MKL_INT info;
/* memory allocation flags */
MKL_INT mem_error, error;

u_data m_data;
m_data.a = 1;
m_data.sum = 0;

error = 0;
/* memory allocation */
mem_error = 1;
x = (double *)mkl_malloc(sizeof(double) * n, 64);
if (x == NULL) goto end;
fvec = (double *)mkl_malloc(sizeof(double) * m, 64);
if (fvec == NULL) goto end;
fjac = (double *)mkl_malloc(sizeof(double) * m * n, 64);
if (fjac == NULL) goto end;
LW = (double *)mkl_malloc(sizeof(double) * n, 64);
if (LW == NULL) goto end;
UP = (double *)mkl_malloc(sizeof(double) * n, 64);
if (UP == NULL) goto end;
/* memory allocated correctly */
mem_error = 0;
/* set precisions for stop-criteria */
for (i = 0; i < 6; i++)
{
eps = 0.00001;
}
/* set precision of the Jacobian matrix calculation */
jac_eps = 0.00000001;
/* set the initial guess */
for (i = 0; i < n; i++)
x = 0;
/* set initial values */
for (i = 0; i < m; i++)
fvec = 0.0;
for (i = 0; i < m * n; i++)
fjac = 0.0;
/* set bounds */
for (i = 0; i < n; i++)
{
LW = -1.;
UP = 1.0;
}

/* initialize solver (allocate memory, set initial values)
handle       in/out: TR solver handle
n       in:     number of function variables
m       in:     dimension of function value
x       in:     solution vector. contains values x for f(x)
LW           in:             lower bound
UP           in:             upper bound
eps     in:     precisions for stop-criteria
iter1   in:     maximum number of iterations
iter2   in:     maximum number of iterations of calculation of trial-step
rs      in:     initial step bound */
MKL_INT st = dtrnlspbc_init(&handle, &n, &m, x, LW, UP, eps, &iter1, &iter2, &rs);  