int main()
{
UserData data;
realtype fnormtol, scsteptol;
N_Vector u1, u2, u, s, c;
int glstr, mset, flag;
void *kmem;
u1 = u2 = u = NULL;
s = c = NULL;
kmem = NULL;
data = NULL;
glstr = KIN_NONE;
/* User data */
data = (UserData)malloc(sizeof *data);
data->lb[0] = PT25; data->ub[0] = ONE;
data->lb[1] = ONEPT5; data->ub[1] = TWO*PI;
/* Create serial vectors of length NEQ */
u1 = N_VNew_Serial(NEQ);
if (check_flag((void *)u1, "N_VNew_Serial", 0)) return(1);
u2 = N_VNew_Serial(NEQ);
if (check_flag((void *)u2, "N_VNew_Serial", 0)) return(1);
u = N_VNew_Serial(NEQ);
if (check_flag((void *)u, "N_VNew_Serial", 0)) return(1);
s = N_VNew_Serial(NEQ);
if (check_flag((void *)s, "N_VNew_Serial", 0)) return(1);
c = N_VNew_Serial(NEQ);
if (check_flag((void *)c, "N_VNew_Serial", 0)) return(1);
SetInitialGuess1(u1,data);
SetInitialGuess2(u2,data);
N_VConst_Serial(ONE,s); /* no scaling */
Ith(c,1) = ZERO; /* no constraint on x1 */
Ith(c,2) = ZERO; /* no constraint on x2 */
Ith(c,3) = ONE; /* l1 = x1 - x1_min >= 0 */
Ith(c,4) = -ONE; /* L1 = x1 - x1_max <= 0 */
Ith(c,5) = ONE; /* l2 = x2 - x2_min >= 0 */
Ith(c,6) = -ONE; /* L2 = x2 - x22_min <= 0 */
fnormtol=FTOL; scsteptol=STOL;
kmem = KINCreate();
if (check_flag((void *)kmem, "KINCreate", 0)) return(1);
flag = KINSetUserData(kmem, data);
if (check_flag(&flag, "KINSetUserData", 1)) return(1);
flag = KINSetConstraints(kmem, c);
if (check_flag(&flag, "KINSetConstraints", 1)) return(1);
flag = KINSetFuncNormTol(kmem, fnormtol);
if (check_flag(&flag, "KINSetFuncNormTol", 1)) return(1);
flag = KINSetScaledStepTol(kmem, scsteptol);
if (check_flag(&flag, "KINSetScaledStepTol", 1)) return(1);
flag = KINInit(kmem, func, u);
if (check_flag(&flag, "KINInit", 1)) return(1);
/* Call KINDense to specify the linear solver */
flag = KINDense(kmem, NEQ);
if (check_flag(&flag, "KINDense", 1)) return(1);
/* Print out the problem size, solution parameters, initial guess. */
PrintHeader(glstr, fnormtol, scsteptol);
/* --------------------------- */
printf("\n------------------------------------------\n");
printf("\nInitial guess on lower bounds\n");
printf(" [x1,x2] = ");
PrintOutput(u1);
N_VScale_Serial(ONE,u1,u);
glstr = KIN_NONE;
mset = 1;
SolveIt(kmem, u, s, glstr, mset);
/* --------------------------- */
N_VScale_Serial(ONE,u1,u);
glstr = KIN_LINESEARCH;
mset = 1;
SolveIt(kmem, u, s, glstr, mset);
/* --------------------------- */
N_VScale_Serial(ONE,u1,u);
glstr = KIN_NONE;
mset = 0;
SolveIt(kmem, u, s, glstr, mset);
/* --------------------------- */
N_VScale_Serial(ONE,u1,u);
glstr = KIN_LINESEARCH;
mset = 0;
SolveIt(kmem, u, s, glstr, mset);
/* --------------------------- */
printf("\n------------------------------------------\n");
printf("\nInitial guess in middle of feasible region\n");
printf(" [x1,x2] = ");
PrintOutput(u2);
N_VScale_Serial(ONE,u2,u);
glstr = KIN_NONE;
mset = 1;
SolveIt(kmem, u, s, glstr, mset);
/* --------------------------- */
N_VScale_Serial(ONE,u2,u);
glstr = KIN_LINESEARCH;
mset = 1;
SolveIt(kmem, u, s, glstr, mset);
/* --------------------------- */
N_VScale_Serial(ONE,u2,u);
glstr = KIN_NONE;
mset = 0;
SolveIt(kmem, u, s, glstr, mset);
/* --------------------------- */
N_VScale_Serial(ONE,u2,u);
glstr = KIN_LINESEARCH;
mset = 0;
SolveIt(kmem, u, s, glstr, mset);
/* Free memory */
N_VDestroy_Serial(u);
N_VDestroy_Serial(s);
N_VDestroy_Serial(c);
KINFree(&kmem);
free(data);
return(0);
}
int main()
{
realtype fnormtol, scsteptol;
N_Vector y, scale, constraints;
int mset, flag, i;
void *kmem;
y = scale = constraints = NULL;
kmem = NULL;
printf("\nRobot Kinematics Example\n");
printf("8 variables; -1 <= x_i <= 1\n");
printf("KINSOL problem size: 8 + 2*8 = 24 \n\n");
/* Create vectors for solution, scales, and constraints */
y = N_VNew_Serial(NEQ);
if (check_flag((void *)y, "N_VNew_Serial", 0)) return(1);
scale = N_VNew_Serial(NEQ);
if (check_flag((void *)scale, "N_VNew_Serial", 0)) return(1);
constraints = N_VNew_Serial(NEQ);
if (check_flag((void *)constraints, "N_VNew_Serial", 0)) return(1);
/* Initialize and allocate memory for KINSOL */
kmem = KINCreate();
if (check_flag((void *)kmem, "KINCreate", 0)) return(1);
flag = KINMalloc(kmem, func, y); /* y passed as a template */
if (check_flag(&flag, "KINMalloc", 1)) return(1);
/* Set optional inputs */
N_VConst_Serial(ZERO,constraints);
for (i = NVAR+1; i <= NEQ; i++) Ith(constraints, i) = ONE;
flag = KINSetConstraints(kmem, constraints);
if (check_flag(&flag, "KINSetConstraints", 1)) return(1);
fnormtol = FTOL;
flag = KINSetFuncNormTol(kmem, fnormtol);
if (check_flag(&flag, "KINSetFuncNormTol", 1)) return(1);
scsteptol = STOL;
flag = KINSetScaledStepTol(kmem, scsteptol);
if (check_flag(&flag, "KINSetScaledStepTol", 1)) return(1);
/* Attach dense linear solver */
flag = KINDense(kmem, NEQ);
if (check_flag(&flag, "KINDense", 1)) return(1);
flag = KINDenseSetJacFn(kmem, jac, NULL);
/* Indicate exact Newton */
mset = 1;
flag = KINSetMaxSetupCalls(kmem, mset);
if (check_flag(&flag, "KINSetMaxSetupCalls", 1)) return(1);
/* Initial guess */
N_VConst_Serial(ONE, y);
for(i = 1; i <= NVAR; i++) Ith(y,i) = SQRT(TWO)/TWO;
printf("Initial guess:\n");
PrintOutput(y);
/* Call KINSol to solve problem */
N_VConst_Serial(ONE,scale);
flag = KINSol(kmem, /* KINSol memory block */
y, /* initial guess on input; solution vector */
KIN_LINESEARCH, /* global stragegy choice */
scale, /* scaling vector, for the variable cc */
scale); /* scaling vector for function values fval */
if (check_flag(&flag, "KINSol", 1)) return(1);
printf("\nComputed solution:\n");
PrintOutput(y);
/* Print final statistics and free memory */
PrintFinalStats(kmem);
N_VDestroy_Serial(y);
N_VDestroy_Serial(scale);
N_VDestroy_Serial(constraints);
KINFree(&kmem);
return(0);
}
void N_VConst(double c, N_Vector z)
{
N_VConst_Serial(c, z);
return;
}
