VGboolean shIsTessCacheValid (VGContext *c, SHPath *p)
{
SHfloat nX, nY;
SHVector2 X, Y;
SHMatrix3x3 mi, mchange;
VGboolean valid = VG_TRUE;
if (p->cacheDataValid == VG_FALSE) {
valid = VG_FALSE;
}
else if (p->cacheTransformInit == VG_FALSE) {
valid = VG_FALSE;
}
else if (shInvertMatrix( &p->cacheTransform, &mi ) == VG_FALSE) {
valid = VG_FALSE;
}
else
{
/* TODO: Compare change matrix for any scale or shear */
MULMATMAT( c->pathTransform, mi, mchange );
SET2( X, mi.m[0][0], mi.m[1][0] );
SET2( Y, mi.m[0][1], mi.m[1][1] );
nX = NORM2( X ); nY = NORM2( Y );
if (nX > 1.01f || nX < 0.99 ||
nY > 1.01f || nY < 0.99)
valid = VG_FALSE;
}
if (valid == VG_FALSE)
{
/* Update cache */
p->cacheDataValid = VG_TRUE;
p->cacheTransformInit = VG_TRUE;
p->cacheTransform = c->pathTransform;
p->cacheStrokeTessValid = VG_FALSE;
}
return valid;
}
void incr_facet(
REAL n1, REAL n2, REAL n3,
REAL i1, REAL i2, REAL i3,
REAL j1, REAL j2, REAL j3,
REAL k1, REAL k2, REAL k3){
REAL x[3] = {i1-j1,i2-j2,i3-j3};
REAL y[3] = {i1-k1,i2-k2,i3-k3};
REAL zz[3]; CROSS(x,y,zz);
REAL A = sqrt(NORM2(zz))/2;
REAL incr = 1./3. * (i1*n1+i2*n2+i3*n3)*A;
// REAL incr = (-1*k1*j2*i3 + j1*k2*i3 + k1*i2*j3 - i1*k2*j3 - j1*i2*k3 + i1*j2*k3)/6.;
vol+=incr;
}
int shDrawRadialGradientMesh(SHPaint *p, SHVector2 *min, SHVector2 *max,
VGPaintMode mode, GLenum texUnit)
{
SHint i, j;
float a, n;
SHfloat cx = p->radialGradient[0];
SHfloat cy = p->radialGradient[1];
SHfloat fx = p->radialGradient[2];
SHfloat fy = p->radialGradient[3];
float r = p->radialGradient[4];
float fcx, fcy, rr, C;
SHVector2 ux;
SHVector2 uy;
SHVector2 c, f;
SHVector2 cf;
SHMatrix3x3 *m;
SHMatrix3x3 mi;
SHint invertible;
SHVector2 corners[4];
SHVector2 fcorners[4];
SHfloat minOffset=0.0f;
SHfloat maxOffset=0.0f;
SHint maxI=0, maxJ=0;
SHfloat maxA=0.0f;
SHfloat startA=0.0f;
int numsteps = 100;
float step = 2*PI/numsteps;
SHVector2 tmin, tmax;
SHVector2 min1, max1, min2, max2;
/* Pick paint transform matrix */
SH_GETCONTEXT(0);
if (mode == VG_FILL_PATH)
m = &context->fillTransform;
else if (mode == VG_STROKE_PATH)
m = &context->strokeTransform;
/* Move focus into circle if outside */
SET2(cf, fx,fy);
SUB2(cf, cx,cy);
n = NORM2(cf);
if (n > r) {
DIV2(cf, n);
fx = cx + 0.995f * r * cf.x;
fy = cy + 0.995f * r * cf.y;
}
/* Precalculations */
rr = r*r;
fcx = fx - cx;
fcy = fy - cy;
C = fcx*fcx + fcy*fcy - rr;
/* Apply paint-to-user transformation
to focus and unit vectors */
SET2(f, fx, fy);
SET2(c, cx, cy);
SET2(ux, 1, 0);
SET2(uy, 0, 1);
ADD2(ux, cx, cy);
ADD2(uy, cx, cy);
TRANSFORM2(f, (*m));
TRANSFORM2(c, (*m));
TRANSFORM2(ux, (*m));
TRANSFORM2(uy, (*m));
SUB2V(ux, c); SUB2V(uy, c);
/* Boundbox corners */
SET2(corners[0], min->x, min->y);
SET2(corners[1], max->x, min->y);
SET2(corners[2], max->x, max->y);
SET2(corners[3], min->x, max->y);
/* Find inverse transformation (back to paint space) */
invertible = shInvertMatrix(m, &mi);
if (!invertible || r <= 0.0f) {
/* Fill boundbox with color at offset 1 */
SHColor *c = &p->stops.items[p->stops.size-1].color;
glColor4fv((GLfloat*)c); glBegin(GL_QUADS);
for (i=0; i<4; ++i) glVertex2fv((GLfloat*)&corners[i]);
glEnd();
return 1;
}
/*--------------------------------------------------------*/
/* Find min/max offset */
for (i=0; i<4; ++i) {
/* Transform to paint space */
SHfloat ax,ay, A,B,D,t, off;
TRANSFORM2TO(corners[i], mi, fcorners[i]);
SUB2(fcorners[i], fx, fy);
n = NORM2(fcorners[i]);
if (n == 0.0f) {
/* Avoid zero-length vectors */
off = 0.0f;
}else{
/* Distance from focus to circle at corner angle */
DIV2(fcorners[i], n);
ax = fcorners[i].x;
ay = fcorners[i].y;
A = ax*ax + ay*ay;
B = 2 * (fcx*ax + fcy*ay);
D = B*B - 4*A*C;
t = (-B + SH_SQRT(D)) / (2*A);
/* Relative offset of boundbox corner */
if (D <= 0.0f) off = 1.0f;
else off = n / t;
}
/* Find smallest and largest offset */
if (off < minOffset || i==0) minOffset = off;
if (off > maxOffset || i==0) maxOffset = off;
}
/* Is transformed focus inside original boundbox? */
if (f.x >= min->x && f.x <= max->x &&
f.y >= min->y && f.y <= max->y) {
/* Draw whole circle */
minOffset = 0.0f;
startA = 0.0f;
maxA = 2*PI;
}else{
/* Find most distant corner pair */
for (i=0; i<3; ++i) {
if (ISZERO2(fcorners[i])) continue;
for (j=i+1; j<4; ++j) {
if (ISZERO2(fcorners[j])) continue;
a = ANGLE2N(fcorners[i], fcorners[j]);
if (a > maxA || maxA == 0.0f)
{maxA=a; maxI=i; maxJ=j;}
}}
/* Pick starting angle */
if (CROSS2(fcorners[maxI],fcorners[maxJ]) > 0.0f)
startA = shVectorOrientation(&fcorners[maxI]);
else startA = shVectorOrientation(&fcorners[maxJ]);
}
/*---------------------------------------------------------*/
/* TODO: for minOffset we'd actually need to find minimum
of the gradient function when X and Y are substitued
with a line equation for each bound-box edge. As a
workaround we use 0.0f for now. */
minOffset = 0.0f;
step = PI/50;
numsteps = (SHint)SH_CEIL(maxA / step) + 1;
glActiveTexture(texUnit);
shSetGradientTexGLState(p);
glEnable(GL_TEXTURE_1D);
glBegin(GL_QUADS);
/* Walk the steps and draw gradient mesh */
for (i=0, a=startA; i<numsteps; ++i, a+=step) {
/* Distance from focus to circle border
at current angle (gradient space) */
float ax = SH_COS(a);
float ay = SH_SIN(a);
float A = ax*ax + ay*ay;
float B = 2 * (fcx*ax + fcy*ay);
float D = B*B - 4*A*C;
float t = (-B + SH_SQRT(D)) / (2*A);
if (D <= 0.0f) t = 0.0f;
/* Vectors pointing towards minimum and maximum
offset at current angle (gradient space) */
tmin.x = ax * t * minOffset;
tmin.y = ay * t * minOffset;
tmax.x = ax * t * maxOffset;
tmax.y = ay * t * maxOffset;
/* Transform back to user space */
min2.x = f.x + tmin.x * ux.x + tmin.y * uy.x;
min2.y = f.y + tmin.x * ux.y + tmin.y * uy.y;
max2.x = f.x + tmax.x * ux.x + tmax.y * uy.x;
max2.y = f.y + tmax.x * ux.y + tmax.y * uy.y;
/* Draw quad */
if (i!=0) {
glMultiTexCoord1f(texUnit, minOffset);
glVertex2fv((GLfloat*)&min1);
glVertex2fv((GLfloat*)&min2);
glMultiTexCoord1f(texUnit, maxOffset);
glVertex2fv((GLfloat*)&max2);
glVertex2fv((GLfloat*)&max1);
}
/* Save prev points */
min1 = min2;
max1 = max2;
}
glEnd();
glDisable(GL_TEXTURE_1D);
return 1;
}
int shDrawLinearGradientMesh(SHPaint *p, SHVector2 *min, SHVector2 *max,
VGPaintMode mode, GLenum texUnit)
{
SHint i;
SHfloat n;
SHfloat x1 = p->linearGradient[0];
SHfloat y1 = p->linearGradient[1];
SHfloat x2 = p->linearGradient[2];
SHfloat y2 = p->linearGradient[3];
SHVector2 c, ux, uy;
SHVector2 cc, uux, uuy;
SHMatrix3x3 *m;
SHMatrix3x3 mi;
SHint invertible;
SHVector2 corners[4];
SHfloat minOffset = 0.0f;
SHfloat maxOffset = 0.0f;
SHfloat left = 0.0f;
SHfloat right = 0.0f;
SHVector2 l1,r1,l2,r2;
/* Pick paint transform matrix */
SH_GETCONTEXT(0);
if (mode == VG_FILL_PATH)
m = &context->fillTransform;
else if (mode == VG_STROKE_PATH)
m = &context->strokeTransform;
/* Gradient center and unit vectors */
SET2(c, x1, y1);
SET2(ux, x2-x1, y2-y1);
SET2(uy, -ux.y, ux.x);
n = NORM2(ux);
DIV2(ux, n);
NORMALIZE2(uy);
/* Apply paint-to-user transformation */
ADD2V(ux, c); ADD2V(uy, c);
TRANSFORM2TO(c, (*m), cc);
TRANSFORM2TO(ux, (*m), uux);
TRANSFORM2TO(uy, (*m), uuy);
SUB2V(ux,c); SUB2V(uy,c);
SUB2V(uux,cc); SUB2V(uuy,cc);
/* Boundbox corners */
SET2(corners[0], min->x, min->y);
SET2(corners[1], max->x, min->y);
SET2(corners[2], max->x, max->y);
SET2(corners[3], min->x, max->y);
/* Find inverse transformation (back to paint space) */
invertible = shInvertMatrix(m, &mi);
if (!invertible || n==0.0f) {
/* Fill boundbox with color at offset 1 */
SHColor *c = &p->stops.items[p->stops.size-1].color;
glColor4fv((GLfloat*)c); glBegin(GL_QUADS);
for (i=0; i<4; ++i) glVertex2fv((GLfloat*)&corners[i]);
glEnd();
return 1;
}
/*--------------------------------------------------------*/
for (i=0; i<4; ++i) {
/* Find min/max offset and perpendicular span */
SHfloat o, s;
TRANSFORM2(corners[i], mi);
SUB2V(corners[i], c);
o = DOT2(corners[i], ux) / n;
s = DOT2(corners[i], uy);
if (o < minOffset || i==0) minOffset = o;
if (o > maxOffset || i==0) maxOffset = o;
if (s < left || i==0) left = s;
if (s > right || i==0) right = s;
}
/*---------------------------------------------------------*/
/* Corners of boundbox in gradient system */
SET2V(l1, cc); SET2V(r1, cc);
SET2V(l2, cc); SET2V(r2, cc);
OFFSET2V(l1, uuy, left); OFFSET2V(l1, uux, minOffset * n);
OFFSET2V(r1, uuy, right); OFFSET2V(r1, uux, minOffset * n);
OFFSET2V(l2, uuy, left); OFFSET2V(l2, uux, maxOffset * n);
OFFSET2V(r2, uuy, right); OFFSET2V(r2, uux, maxOffset * n);
/* Draw quad using color-ramp texture */
glActiveTexture(texUnit);
shSetGradientTexGLState(p);
glEnable(GL_TEXTURE_1D);
glBegin(GL_QUAD_STRIP);
glMultiTexCoord1f(texUnit, minOffset);
glVertex2fv((GLfloat*)&r1);
glVertex2fv((GLfloat*)&l1);
glMultiTexCoord1f(texUnit, maxOffset);
glVertex2fv((GLfloat*)&r2);
glVertex2fv((GLfloat*)&l2);
glEnd();
glDisable(GL_TEXTURE_1D);
return 1;
}
opk_task_t
opk_iterate_vmlmb(opk_vmlmb_t* opt, opk_vector_t* x,
double f, opk_vector_t* g)
{
double dtg, gtest, stpmin, stpmax;
opk_index_t k;
opk_status_t status;
opk_lnsrch_task_t lnsrch_task;
opk_bool_t bounded;
if (opt == NULL) {
return OPK_TASK_ERROR;
}
bounded = (opt->box != NULL);
switch (opt->task) {
case OPK_TASK_COMPUTE_FG:
/* Caller has computed the function value and the gradient at the current
point. */
++opt->evaluations;
if (opt->evaluations > 1) {
/* A line search is in progress, check whether it has converged. */
if (opk_lnsrch_use_deriv(opt->lnsrch)) {
if (bounded) {
/* Compute the directional derivative as the inner product between
the effective step and the gradient divided by the step length. */
#if 0
if (opt->tmp == NULL &&
(opt->tmp = opk_vcreate(opt->vspace)) == NULL) {
return failure(opt, OPK_INSUFFICIENT_MEMORY);
}
AXPBY(opt->tmp, 1, x, -1, opt->x0);
dtg = DOT(opt->tmp, g)/opt->stp;
#else
dtg = (DOT(x, g) - DOT(opt->x0, g))/opt->stp;
#endif
} else {
/* Compute the directional derivative. */
dtg = -opk_vdot(opt->d, g);
}
} else {
/* Line search does not need directional derivative. */
dtg = 0;
}
lnsrch_task = opk_lnsrch_iterate(opt->lnsrch, &opt->stp, f, dtg);
if (lnsrch_task == OPK_LNSRCH_SEARCH) {
/* Line search has not yet converged, break to compute a new trial
point along the search direction. */
break;
}
if (lnsrch_task != OPK_LNSRCH_CONVERGENCE) {
/* An error may have occurred during the line search. Figure out
whether this error can be safely ignored. */
status = opk_lnsrch_get_status(opt->lnsrch);
if (lnsrch_task != OPK_LNSRCH_WARNING ||
status != OPK_ROUNDING_ERRORS_PREVENT_PROGRESS) {
return failure(opt, status);
}
}
++opt->iterations;
}
/* The current step is acceptable. Check for global convergence. */
if (bounded) {
/* Determine the set of free variables. */
status = opk_get_free_variables(opt->w, x, opt->box, g, OPK_ASCENT);
if (status != OPK_SUCCESS) {
return failure(opt, status);
}
}
if (opt->method == OPK_VMLMB) {
/* Compute the Euclidean norm of the projected gradient. */
opt->gnorm = WNORM2(g);
} else if (opt->method == OPK_BLMVM) {
/* Compute the projected gradient and its norm. */
opk_vproduct(opt->gp, opt->w, g);
opt->gnorm = NORM2(opt->gp);
} else {
/* Compute the Euclidean norm of the gradient. */
opt->gnorm = NORM2(g);
}
if (opt->evaluations == 1) {
opt->ginit = opt->gnorm;
}
gtest = max3(0.0, opt->gatol, opt->grtol*opt->ginit);
return success(opt, (opt->gnorm <= gtest
? OPK_TASK_FINAL_X
: OPK_TASK_NEW_X));
case OPK_TASK_NEW_X:
case OPK_TASK_FINAL_X:
/* Compute a new search direction. */
if (opt->iterations >= 1) {
/* Update L-BFGS approximation of the Hessian. */
update(opt, x, (opt->method == OPK_BLMVM ? opt->gp : g));
}
status = apply(opt, g);
if (status == OPK_SUCCESS) {
/* The L-BFGS approximation produces a search direction D. To warrant
convergence, we have to check whether -D is a sufficient descent
direction (that is to say that D is a sufficient ascent direction).
As shown by Zoutendijk, this is true if cos(theta) = (D/|D|)'.(G/|G|)
is larger or equal EPSILON > 0, where G is the gradient at X and D
the, ascent for us, search direction. */
if (bounded) {
/* Project the search direction produced by the L-BFGS recursion. */
status = opk_project_direction(opt->d, x, opt->box, opt->d, OPK_ASCENT);
if (status != OPK_SUCCESS) {
return failure(opt, status);
}
}
dtg = -DOT(opt->d, g);
if (opt->epsilon > 0 && -dtg < opt->epsilon*NORM2(opt->d)*opt->gnorm) {
/* -D is not a sufficient descent direction. Set the directional
derivative to zero to force using the steepest descent direction. */
dtg = 0.0;
}
} else {
/* The L-BFGS approximation is not available (first iteration or just
after a reset) or failed to produce a direction. Set the directional
derivative to zero to use the steepest descent direction. */
dtg = 0.0;
}
/* Determine the initial step length. */
if (dtg < 0) {
/* A sufficient descent direction has been produced by L-BFGS recursion.
An initial unit step will be used. */
opt->stp = 1.0;
} else {
/* First iteration or L-BFGS recursion failed to produce a sufficient
descent direction, use the (projected) gradient as a search
direction. */
if (opt->mp > 0) {
/* L-BFGS recursion did not produce a sufficient descent direction. */
++opt->restarts;
opt->mp = 0;
}
if (opt->method == OPK_VMLMB) {
/* Use the projected gradient. */
opk_vproduct(opt->d, opt->w, g);
} else if (opt->method == OPK_BLMVM) {
/* Use the projected gradient (which has already been computed and
* stored in the scratch vector). */
opk_vcopy(opt->d, opt->gp);
} else {
/* Use the gradient. */
opk_vcopy(opt->d, g);
}
dtg = -opt->gnorm*opt->gnorm;
if (f != 0) {
opt->stp = 2*fabs(f/dtg);
} else {
/* Use a small step compared to X. */
double dnorm = opt->gnorm;
double xnorm = (bounded ? WNORM2(x) : NORM2(x));
if (xnorm > 0) {
opt->stp = opt->delta*xnorm/dnorm;
} else {
opt->stp = opt->delta/dnorm;
}
}
}
stpmin = opt->stp*opt->stpmin;
stpmax = opt->stp*opt->stpmax;
if (bounded) {
/* Shortcut the step length. */
double bsmin1, bsmin2, bsmax;
status = opk_get_step_limits(&bsmin1, &bsmin2, &bsmax,
x, opt->box, opt->d, OPK_ASCENT);
if (bsmin1 < 0) {
fprintf(stderr, "FIXME: SMIN1 =%g, SMIN2 =%g, SMAX =%g\n",
bsmin1, bsmin2, bsmax);
}
if (status != OPK_SUCCESS) {
return failure(opt, status);
}
if (bsmax <= 0) {
return failure(opt, OPK_WOULD_BLOCK);
}
if (opt->stp > bsmax) {
opt->stp = bsmax;
}
if (stpmax > bsmax) {
stpmax = bsmax;
}
opt->bsmin = bsmin2;
}
/* Save current point. */
if (opt->save_memory) {
k = SLOT(0);
opt->x0 = S(k); /* weak reference */
opt->g0 = Y(k); /* weak reference */
if (opt->mp == opt->m) {
--opt->mp;
}
}
COPY(opt->x0, x);
COPY(opt->g0, (opt->method == OPK_BLMVM ? opt->gp : g));
opt->f0 = f;
/* Start the line search and break to take the first step along the line
search. */
if (opk_lnsrch_start(opt->lnsrch, f, dtg, opt->stp,
stpmin, stpmax) != OPK_LNSRCH_SEARCH) {
return failure(opt, opk_lnsrch_get_status(opt->lnsrch));
}
break;
default:
/* There must be something wrong. */
return opt->task;
}
/* Compute a new trial point along the line search. */
opk_vaxpby(x, 1, opt->x0, -opt->stp, opt->d);
if (bounded && opt->stp > opt->bsmin) {
opk_status_t status = opk_project_variables(x, x, opt->box);
if (status != OPK_SUCCESS) {
return failure(opt, status);
}
}
return success(opt, OPK_TASK_COMPUTE_FG);
}
opk_task_t
opk_iterate_vmlmn(opk_vmlmn_t* opt, opk_vector_t* x,
double f, opk_vector_t* g)
{
double dtg;
opk_index_t k;
opk_status_t status;
opk_lnsrch_task_t lnsrch_task;
opk_bool_t bounded, final;
bounded = (opt->bounds != 0);
switch (opt->task) {
case OPK_TASK_COMPUTE_FG:
/* Caller has computed the function value and the gradient at the current
point. */
++opt->evaluations;
if (opt->evaluations > 1) {
/* A line search is in progress, check whether it has converged. */
if (opk_lnsrch_use_deriv(opt->lnsrch)) {
if (bounded) {
/* Compute the directional derivative as the inner product between
the effective step and the gradient. */
#if 0
if (opt->tmp == NULL &&
(opt->tmp = opk_vcreate(opt->vspace)) == NULL) {
return failure(opt, OPK_INSUFFICIENT_MEMORY);
}
AXPBY(opt->tmp, 1, x, -1, opt->x0);
dtg = DOT(opt->tmp, g)/opt->stp;
#else
dtg = (DOT(x, g) - DOT(opt->x0, g))/opt->stp;
#endif
} else {
/* Compute the directional derivative. */
dtg = -opk_vdot(opt->d, g);
}
} else {
/* Line search does not need directional derivative. */
dtg = 0;
}
lnsrch_task = opk_lnsrch_iterate(opt->lnsrch, &opt->stp, f, dtg);
if (lnsrch_task == OPK_LNSRCH_SEARCH) {
/* Line search has not yet converged, break to compute a new trial
point along the search direction. */
break;
}
if (lnsrch_task != OPK_LNSRCH_CONVERGENCE) {
status = opk_lnsrch_get_status(opt->lnsrch);
if (lnsrch_task != OPK_LNSRCH_WARNING ||
status != OPK_ROUNDING_ERRORS_PREVENT_PROGRESS) {
return failure(opt, status);
}
}
++opt->iterations;
}
if (bounded) {
/* Determine the set of free variables. */
status = opk_box_get_free_variables(opt->w, x, opt->xl, opt->xu,
g, OPK_ASCENT);
if (status != OPK_SUCCESS) {
return failure(opt, status);
}
}
/* Check for global convergence. */
if (opt->method == OPK_VMLMN) {
/* Compute the Euclidean norm of the projected gradient. */
opt->gnorm = WNORM2(g);
} else if (opt->method == OPK_BLMVM) {
/* Compute the projected gradient and its norm. */
opk_vproduct(opt->tmp, opt->w, g);
opt->gnorm = NORM2(opt->tmp);
} else {
/* Compute the Euclidean norm of the gradient. */
opt->gnorm = NORM2(g);
}
if (opt->evaluations == 1) {
opt->ginit = opt->gnorm;
}
final = (opt->gnorm <= max3(0.0, opt->gatol, opt->grtol*opt->ginit));
return success(opt, (final ? OPK_TASK_FINAL_X : OPK_TASK_NEW_X));
case OPK_TASK_NEW_X:
case OPK_TASK_FINAL_X:
/* Compute a new search direction. */
if (opt->iterations >= 1) {
/* Update L-BFGS approximation of the Hessian. */
update(opt, x, (opt->method == OPK_BLMVM ? opt->tmp : g));
}
if (apply(opt, g) == OPK_SUCCESS) {
/* We take care of checking whether -D is a sufficient descent direction
(that is to say that D is a sufficient ascent direction). As shown by
Zoutendijk, this is true if cos(theta) = (D/|D|)'.(G/|G|) is larger or
equal EPSILON > 0, where G is the gradient at X and D the (ascent for
us) search direction. */
dtg = -DOT(opt->d, g);
if (opt->epsilon > 0 &&
dtg > -opt->epsilon*NORM2(opt->d)*opt->gnorm) {
/* We do not have a sufficient descent direction. Set the directional
derivative to zero to force using the steepest descent direction. */
dtg = 0.0;
}
} else {
/* The L-BFGS approximation is unset (first iteration) or failed to
produce a direction. Set the directional derivative to zero to use
the steepest descent direction. */
dtg = 0.0;
}
/* Determine the initial step length. */
if (dtg < 0) {
/* A sufficient descent direction has been produced by L-BFGS recursion.
An initial unit step will be used. */
opt->stp = 1.0;
} else {
/* First iteration or L-BFGS recursion failed to produce a sufficient
descent direction, use the (projected) gradient as a search
direction. */
if (opt->mp > 0) {
/* L-BFGS recursion did not produce a sufficient descent direction. */
++opt->restarts;
opt->mp = 0;
}
if (opt->method == OPK_VMLMN) {
/* Use the projected gradient. */
opk_vproduct(opt->d, opt->w, g);
} else if (opt->method == OPK_BLMVM) {
/* Use the projected gradient (which has aready been computed and
* stored in the scratch vector). */
opk_vcopy(opt->d, opt->tmp);
} else {
/* Use the gradient. */
opk_vcopy(opt->d, g);
}
dtg = -opt->gnorm*opt->gnorm;
if (f != 0) {
opt->stp = 2*fabs(f/dtg);
} else {
/* Use a small step compared to X. */
double dnorm = opt->gnorm;
double xnorm = (bounded ? WNORM2(x) : NORM2(x));
if (xnorm > 0) {
opt->stp = opt->delta*xnorm/dnorm;
} else {
opt->stp = opt->delta/dnorm;
}
}
}
if (bounded) {
/* Shortcut the step length. */
double bsmin, bsmax, wolfe;
status = opk_box_get_step_limits(&bsmin, &wolfe, &bsmax,
x, opt->xl, opt->xu,
opt->d, OPK_ASCENT);
if (status != OPK_SUCCESS) {
return failure(opt, status);
}
if (bsmax <= 0) {
return failure(opt, OPK_WOULD_BLOCK);
}
if (opt->stp > bsmax) {
opt->stp = bsmax;
}
opt->bsmin = bsmin;
}
/* Save current point. */
#if SAVE_MEMORY
k = slot(opt, 0);
opt->x0 = S(k); /* weak reference */
opt->g0 = Y(k); /* weak reference */
if (opt->mp == opt->m) {
--opt->mp;
}
#endif
COPY(opt->x0, x);
COPY(opt->g0, (opt->method == OPK_BLMVM ? opt->tmp : g));
opt->f0 = f;
/* Start the line search and break to take the first step along the line
search. */
if (opk_lnsrch_start(opt->lnsrch, f, dtg, opt->stp,
opt->stp*opt->stpmin,
opt->stp*opt->stpmax) != OPK_LNSRCH_SEARCH) {
return failure(opt, opk_lnsrch_get_status(opt->lnsrch));
}
break;
default:
/* There must be something wrong. */
return opt->task;
}
