CL_GenericBTree::CL_GenericBTree (CL_AbstractComparator& cmp,
short order, CL_BTreeNodeSpace* space)
: _comparator (cmp)
{
_order = maxl (order, 2);
if (space) {
_nodeSpace = space;
_ownNodeSpace = FALSE;
}
else {
_nodeSpace = new CL_HeapBTreeNodeSpace (_order, *this, cmp);
_ownNodeSpace = TRUE;
}
}
CL_VoidPtr CL_GenericBTree::ItemWithRank (long rank) const
{
short pos;
bool found;
CL_VoidPtr itm;
CL_GenericBTreeNode* tmp_ptr, *p1;
tmp_ptr = _nodeSpace->BorrowRoot ();
if (!tmp_ptr || tmp_ptr->_keyCount <= 0)
return NULL;
rank = minl (maxl (rank, 0), tmp_ptr->_subtreeSize-1);
do {
if (tmp_ptr->_isLeaf) {
assert ((0 <= rank && rank <= tmp_ptr->_keyCount-1),
("Internal error: CL_GenericBTree::ItemWithRank:"
"bad key count %d rank %ld", tmp_ptr->_keyCount, rank));
CL_VoidPtr ret = tmp_ptr->_item[rank];
_nodeSpace->ReturnNode (tmp_ptr);
return ret;
}
// We're in a non-leaf, so find the subtree to descend into
// (if any)
short i;
for (i = 0; i < tmp_ptr->_keyCount; i++) {
p1 = _nodeSpace->BorrowNode (tmp_ptr->_subtree[i]);
if (p1->_subtreeSize > rank)
break;
rank -= p1->_subtreeSize; // Account for i-th subtree
_nodeSpace->ReturnNode (p1);
if (rank == 0) {
// We've got the item we wanted
CL_VoidPtr ret = tmp_ptr->_item[i];
_nodeSpace->ReturnNode (tmp_ptr);
return ret;
}
rank--; // Account for i-th key in node
}
if (i >= tmp_ptr->_keyCount) {
// Descend into rightmost subtree
p1 = _nodeSpace->BorrowNode (tmp_ptr->_subtree[i]);
}
_nodeSpace->ReturnNode (tmp_ptr);
tmp_ptr = p1;
} while (1);
}
int main() {
time_t t;
srand((unsigned)time(&t));
int i=0,ar[1000],si[1];
si[0]=0;
tnp tree=NULL;
lnp maxnodeu[0];
tree=magicalbinarytreemaker(100,ar,si);
inorder(tree); printf("\n\n");
preorder(tree); printf("\n\n");
postorder(tree); printf("\n\n");
maxl(tree,0);
//printf("The maximum sum from path to leaf is %d and way :\n",maxleafl);
pleaf(tree,0); printf("\n\n");
maxn(tree,maxnodeu);
//printf("The maximum sum from node to node is %d and way :\n",maxnodel);
for(i=0;i<maxnodeas;i++) {
printf("%d ",maxnodea[i]);
}
}
/* only semi-definite. */
double *optimize_qp(QP *qp, double *epsilon_crit, long nx, double *threshold, LEARN_PARM *learn_parm)
{
long i,j;
int result;
double eq,progress;
roundnumber++;
if(!primal) { /* allocate memory at first call */
primal=(double *)my_malloc(sizeof(double)*nx);
dual=(double *)my_malloc(sizeof(double)*((nx+1)*2));
nonoptimal=(long *)my_malloc(sizeof(long)*(nx));
buffer=(double *)my_malloc(sizeof(double)*((nx+1)*2*(nx+1)*2+
nx*nx+2*(nx+1)*2+2*nx+1+2*nx+
nx+nx+nx*nx));
(*threshold)=0;
for(i=0;i<nx;i++) {
primal[i]=0;
}
}
if(verbosity>=4) { /* really verbose */
printf("\n\n");
eq=qp->opt_ce0[0];
for(i=0;i<qp->opt_n;i++) {
eq+=qp->opt_xinit[i]*qp->opt_ce[i];
printf("%f: ",qp->opt_g0[i]);
for(j=0;j<qp->opt_n;j++) {
printf("%f ",qp->opt_g[i*qp->opt_n+j]);
}
printf(": a=%.10f < %f",qp->opt_xinit[i],qp->opt_up[i]);
printf(": y=%f\n",qp->opt_ce[i]);
}
if(qp->opt_m) {
printf("EQ: %f*x0",qp->opt_ce[0]);
for(i=1;i<qp->opt_n;i++) {
printf(" + %f*x%ld",qp->opt_ce[i],i);
}
printf(" = %f\n\n",-qp->opt_ce0[0]);
}
}
result=optimize_hildreth_despo(qp->opt_n,qp->opt_m,
opt_precision,(*epsilon_crit),
learn_parm->epsilon_a,maxiter,
/* (long)PRIMAL_OPTIMAL, */
(long)0, (long)0,
lindep_sensitivity,
qp->opt_g,qp->opt_g0,qp->opt_ce,qp->opt_ce0,
qp->opt_low,qp->opt_up,primal,qp->opt_xinit,
dual,nonoptimal,buffer,&progress);
if(verbosity>=3) {
printf("return(%d)...",result);
}
if(learn_parm->totwords < learn_parm->svm_maxqpsize) {
/* larger working sets will be linear dependent anyway */
learn_parm->svm_maxqpsize=maxl(learn_parm->totwords,(long)2);
}
if(result == NAN_SOLUTION) {
lindep_sensitivity*=2; /* throw out linear dependent examples more */
/* generously */
if(learn_parm->svm_maxqpsize>2) {
learn_parm->svm_maxqpsize--; /* decrease size of qp-subproblems */
}
precision_violations++;
}
/* take one round of only two variable to get unstuck */
if((result != PRIMAL_OPTIMAL) || (!(roundnumber % 31)) || (progress <= 0)) {
smallroundcount++;
result=optimize_hildreth_despo(qp->opt_n,qp->opt_m,
opt_precision,(*epsilon_crit),
learn_parm->epsilon_a,(long)maxiter,
(long)PRIMAL_OPTIMAL,(long)SMALLROUND,
lindep_sensitivity,
qp->opt_g,qp->opt_g0,qp->opt_ce,qp->opt_ce0,
qp->opt_low,qp->opt_up,primal,qp->opt_xinit,
dual,nonoptimal,buffer,&progress);
if(verbosity>=3) {
printf("return_srd(%d)...",result);
}
if(result != PRIMAL_OPTIMAL) {
if(result != ONLY_ONE_VARIABLE)
precision_violations++;
if(result == MAXITER_EXCEEDED)
maxiter+=100;
if(result == NAN_SOLUTION) {
lindep_sensitivity*=2; /* throw out linear dependent examples more */
/* generously */
/* results not valid, so return inital values */
for(i=0;i<qp->opt_n;i++) {
primal[i]=qp->opt_xinit[i];
}
}
}
}
if(precision_violations > 50) {
precision_violations=0;
(*epsilon_crit)*=10.0;
if(verbosity>=1) {
printf("\nWARNING: Relaxing epsilon on KT-Conditions (%f).\n",
(*epsilon_crit));
}
}
if((qp->opt_m>0) && (result != NAN_SOLUTION) && (!isnan(dual[1]-dual[0])))
(*threshold)=dual[1]-dual[0];
else
(*threshold)=0;
if(verbosity>=4) { /* really verbose */
printf("\n\n");
eq=qp->opt_ce0[0];
for(i=0;i<qp->opt_n;i++) {
eq+=primal[i]*qp->opt_ce[i];
printf("%f: ",qp->opt_g0[i]);
for(j=0;j<qp->opt_n;j++) {
printf("%f ",qp->opt_g[i*qp->opt_n+j]);
}
printf(": a=%.30f",primal[i]);
printf(": nonopti=%ld",nonoptimal[i]);
printf(": y=%f\n",qp->opt_ce[i]);
}
printf("eq-constraint=%.30f\n",eq);
printf("b=%f\n",(*threshold));
printf(" smallroundcount=%ld ",smallroundcount);
}
return(primal);
}
int optimize_hildreth_despo(long n, long m, double precision, double epsilon_crit,
double epsilon_a, long maxiter, long goal,
long smallround, double lindep_sensitivity, double *g,
double *g0, double *ce, double *ce0, double *low, double *up,
double *primal, double *init, double *dual, long *lin_dependent,
double *buffer, double *progress)
//long n; /* number of variables */
//long m; /* number of linear equality constraints [0,1] */
//double precision; /* solve at least to this dual precision */
//double epsilon_crit; /* stop, if KT-Conditions approx fulfilled */
//double epsilon_a; /* precision of alphas at bounds */
//long maxiter; /* stop after this many iterations */
//long goal; /* keep going until goal fulfilled */
//long smallround; /* use only two variables of steepest descent */
//double lindep_sensitivity; /* epsilon for detecting linear dependent ex */
//double *g; /* hessian of objective */
//double *g0; /* linear part of objective */
//double *ce,*ce0; /* linear equality constraints */
//double *low,*up; /* box constraints */
//double *primal; /* primal variables */
//double *init; /* initial values of primal */
//double *dual; /* dual variables */
//long *lin_dependent;
//double *buffer;
//double *progress; /* delta in the objective function between
// before and after */
{
long i,j,k,from,to,n_indep,changed;
double sum,bmin=0,bmax=0;
double *d,*d0,*ig,*dual_old,*temp,*start;
double *g0_new,*g_new,*ce_new,*ce0_new,*low_new,*up_new;
double add,t;
int result;
double obj_before,obj_after;
long b1,b2;
double g0_b1,g0_b2,ce0_b;
g0_new=&(buffer[0]); /* claim regions of buffer */
d=&(buffer[n]);
d0=&(buffer[n+(n+m)*2*(n+m)*2]);
ce_new=&(buffer[n+(n+m)*2*(n+m)*2+(n+m)*2]);
ce0_new=&(buffer[n+(n+m)*2*(n+m)*2+(n+m)*2+n]);
ig=&(buffer[n+(n+m)*2*(n+m)*2+(n+m)*2+n+m]);
dual_old=&(buffer[n+(n+m)*2*(n+m)*2+(n+m)*2+n+m+n*n]);
low_new=&(buffer[n+(n+m)*2*(n+m)*2+(n+m)*2+n+m+n*n+(n+m)*2]);
up_new=&(buffer[n+(n+m)*2*(n+m)*2+(n+m)*2+n+m+n*n+(n+m)*2+n]);
start=&(buffer[n+(n+m)*2*(n+m)*2+(n+m)*2+n+m+n*n+(n+m)*2+n+n]);
g_new=&(buffer[n+(n+m)*2*(n+m)*2+(n+m)*2+n+m+n*n+(n+m)*2+n+n+n]);
temp=&(buffer[n+(n+m)*2*(n+m)*2+(n+m)*2+n+m+n*n+(n+m)*2+n+n+n+n*n]);
b1=-1;
b2=-1;
for(i=0;i<n;i++) { /* get variables with steepest feasible descent */
sum=g0[i];
for(j=0;j<n;j++)
sum+=init[j]*g[i*n+j];
sum=sum*ce[i];
if(((b1==-1) || (sum<bmin))
&& (!((init[i]<=(low[i]+epsilon_a)) && (ce[i]<0.0)))
&& (!((init[i]>=( up[i]-epsilon_a)) && (ce[i]>0.0)))
) {
bmin=sum;
b1=i;
}
if(((b2==-1) || (sum>=bmax))
&& (!((init[i]<=(low[i]+epsilon_a)) && (ce[i]>0.0)))
&& (!((init[i]>=( up[i]-epsilon_a)) && (ce[i]<0.0)))
) {
bmax=sum;
b2=i;
}
}
/* in case of unbiased hyperplane, the previous projection on */
/* equality constraint can lead to b1 or b2 being -1. */
if((b1 == -1) || (b2 == -1)) {
b1=maxl(b1,b2);
b2=maxl(b1,b2);
}
for(i=0;i<n;i++) {
start[i]=init[i];
}
/* in case both example vectors are linearly dependent */
/* WARNING: Assumes that ce[] in {-1,1} */
add=0;
changed=0;
if((b1 != b2) && (m==1)) {
for(i=0;i<n;i++) { /* fix other vectors */
if(i==b1)
g0_b1=g0[i];
if(i==b2)
g0_b2=g0[i];
}
ce0_b=ce0[0];
for(i=0;i<n;i++) {
if((i!=b1) && (i!=b2)) {
for(j=0;j<n;j++) {
if(j==b1)
g0_b1+=start[i]*g[i*n+j];
if(j==b2)
g0_b2+=start[i]*g[i*n+j];
}
ce0_b-=(start[i]*ce[i]);
}
}
if((g[b1*n+b2] == g[b1*n+b1]) && (g[b1*n+b2] == g[b2*n+b2])) {
/* printf("euqal\n"); */
if(ce[b1] == ce[b2]) {
if(g0_b1 <= g0_b2) { /* set b1 to upper bound */
/* printf("case +=<\n"); */
changed=1;
t=up[b1]-init[b1];
if((init[b2]-low[b2]) < t) {
t=init[b2]-low[b2];
}
start[b1]=init[b1]+t;
start[b2]=init[b2]-t;
}
else if(g0_b1 > g0_b2) { /* set b2 to upper bound */
/* printf("case +=>\n"); */
changed=1;
t=up[b2]-init[b2];
if((init[b1]-low[b1]) < t) {
t=init[b1]-low[b1];
}
start[b1]=init[b1]-t;
start[b2]=init[b2]+t;
}
}
else if(((g[b1*n+b1]>0) || (g[b2*n+b2]>0))) { /* (ce[b1] != ce[b2]) */
/* printf("case +!\n"); */
t=((ce[b2]/ce[b1])*g0[b1]-g0[b2]+ce0[0]*(g[b1*n+b1]*ce[b2]/ce[b1]-g[b1*n+b2]/ce[b1]))/((ce[b2]*ce[b2]/(ce[b1]*ce[b1]))*g[b1*n+b1]+g[b2*n+b2]-2*(g[b1*n+b2]*ce[b2]/ce[b1]))-init[b2];
changed=1;
if((up[b2]-init[b2]) < t) {
t=up[b2]-init[b2];
}
if((init[b2]-low[b2]) < -t) {
t=-(init[b2]-low[b2]);
}
if((up[b1]-init[b1]) < t) {
t=(up[b1]-init[b1]);
}
if((init[b1]-low[b1]) < -t) {
t=-(init[b1]-low[b1]);
}
start[b1]=init[b1]+t;
start[b2]=init[b2]+t;
}
}
if((-g[b1*n+b2] == g[b1*n+b1]) && (-g[b1*n+b2] == g[b2*n+b2])) {
/* printf("diffeuqal\n"); */
if(ce[b1] != ce[b2]) {
if((g0_b1+g0_b2) < 0) { /* set b1 and b2 to upper bound */
/* printf("case -!<\n"); */
changed=1;
t=up[b1]-init[b1];
if((up[b2]-init[b2]) < t) {
t=up[b2]-init[b2];
}
start[b1]=init[b1]+t;
start[b2]=init[b2]+t;
}
else if((g0_b1+g0_b2) >= 0) { /* set b1 and b2 to lower bound */
/* printf("case -!>\n"); */
changed=1;
t=init[b1]-low[b1];
if((init[b2]-low[b2]) < t) {
t=init[b2]-low[b2];
}
start[b1]=init[b1]-t;
start[b2]=init[b2]-t;
}
}
else if(((g[b1*n+b1]>0) || (g[b2*n+b2]>0))) { /* (ce[b1]==ce[b2]) */
/* printf("case -=\n"); */
t=((ce[b2]/ce[b1])*g0[b1]-g0[b2]+ce0[0]*(g[b1*n+b1]*ce[b2]/ce[b1]-g[b1*n+b2]/ce[b1]))/((ce[b2]*ce[b2]/(ce[b1]*ce[b1]))*g[b1*n+b1]+g[b2*n+b2]-2*(g[b1*n+b2]*ce[b2]/ce[b1]))-init[b2];
changed=1;
if((up[b2]-init[b2]) < t) {
t=up[b2]-init[b2];
}
if((init[b2]-low[b2]) < -t) {
t=-(init[b2]-low[b2]);
}
if((up[b1]-init[b1]) < -t) {
t=-(up[b1]-init[b1]);
}
if((init[b1]-low[b1]) < t) {
t=init[b1]-low[b1];
}
start[b1]=init[b1]-t;
start[b2]=init[b2]+t;
}
}
}
/* if we have a biased hyperplane, then adding a constant to the */
/* hessian does not change the solution. So that is done for examples */
/* with zero diagonal entry, since HIDEO cannot handle them. */
if((m>0)
&& ((fabs(g[b1*n+b1]) < lindep_sensitivity)
|| (fabs(g[b2*n+b2]) < lindep_sensitivity))) {
/* printf("Case 0\n"); */
add+=0.093274;
}
/* in case both examples are linear dependent */
else if((m>0)
&& (g[b1*n+b2] != 0 && g[b2*n+b2] != 0)
&& (fabs(g[b1*n+b1]/g[b1*n+b2] - g[b1*n+b2]/g[b2*n+b2])
< lindep_sensitivity)) {
/* printf("Case lindep\n"); */
add+=0.078274;
}
/* special case for zero diagonal entry on unbiased hyperplane */
if((m==0) && (b1>=0)) {
if(fabs(g[b1*n+b1]) < lindep_sensitivity) {
/* printf("Case 0b1\n"); */
for(i=0;i<n;i++) { /* fix other vectors */
if(i==b1)
g0_b1=g0[i];
}
for(i=0;i<n;i++) {
if(i!=b1) {
for(j=0;j<n;j++) {
if(j==b1)
g0_b1+=start[i]*g[i*n+j];
}
}
}
if(g0_b1<0)
start[b1]=up[b1];
if(g0_b1>=0)
start[b1]=low[b1];
}
}
if((m==0) && (b2>=0)) {
if(fabs(g[b2*n+b2]) < lindep_sensitivity) {
/* printf("Case 0b2\n"); */
for(i=0;i<n;i++) { /* fix other vectors */
if(i==b2)
g0_b2=g0[i];
}
for(i=0;i<n;i++) {
if(i!=b2) {
for(j=0;j<n;j++) {
if(j==b2)
g0_b2+=start[i]*g[i*n+j];
}
}
}
if(g0_b2<0)
start[b2]=up[b2];
if(g0_b2>=0)
start[b2]=low[b2];
}
}
/* printf("b1=%ld,b2=%ld\n",b1,b2); */
lcopy_matrix(g,n,d);
if((m==1) && (add>0.0)) {
for(j=0;j<n;j++) {
for(k=0;k<n;k++) {
d[j*n+k]+=add*ce[j]*ce[k];
}
}
}
else {
add=0.0;
}
if(n>2) { /* switch, so that variables are better mixed */
lswitchrk_matrix(d,n,b1,(long)0);
if(b2 == 0)
lswitchrk_matrix(d,n,b1,(long)1);
else
lswitchrk_matrix(d,n,b2,(long)1);
}
if(smallround == SMALLROUND) {
for(i=2;i<n;i++) {
lin_dependent[i]=1;
}
if(m>0) { /* for biased hyperplane, pick two variables */
lin_dependent[0]=0;
lin_dependent[1]=0;
}
else { /* for unbiased hyperplane, pick only one variable */
lin_dependent[0]=smallroundcount % 2;
lin_dependent[1]=(smallroundcount+1) % 2;
}
}
else {
for(i=0;i<n;i++) {
lin_dependent[i]=0;
}
}
linvert_matrix(d,n,ig,lindep_sensitivity,lin_dependent);
if(n>2) { /* now switch back */
if(b2 == 0) {
lswitchrk_matrix(ig,n,b1,(long)1);
i=lin_dependent[1];
lin_dependent[1]=lin_dependent[b1];
lin_dependent[b1]=i;
}
else {
lswitchrk_matrix(ig,n,b2,(long)1);
i=lin_dependent[1];
lin_dependent[1]=lin_dependent[b2];
lin_dependent[b2]=i;
}
lswitchrk_matrix(ig,n,b1,(long)0);
i=lin_dependent[0];
lin_dependent[0]=lin_dependent[b1];
lin_dependent[b1]=i;
}
/* lprint_matrix(d,n); */
/* lprint_matrix(ig,n); */
lcopy_matrix(g,n,g_new); /* restore g_new matrix */
if(add>0)
for(j=0;j<n;j++) {
for(k=0;k<n;k++) {
g_new[j*n+k]+=add*ce[j]*ce[k];
}
}
for(i=0;i<n;i++) { /* fix linear dependent vectors */
g0_new[i]=g0[i]+add*ce0[0]*ce[i];
}
if(m>0) ce0_new[0]=-ce0[0];
for(i=0;i<n;i++) { /* fix linear dependent vectors */
if(lin_dependent[i]) {
for(j=0;j<n;j++) {
if(!lin_dependent[j]) {
g0_new[j]+=start[i]*g_new[i*n+j];
}
}
if(m>0) ce0_new[0]-=(start[i]*ce[i]);
}
}
from=0; /* remove linear dependent vectors */
to=0;
n_indep=0;
for(i=0;i<n;i++) {
if(!lin_dependent[i]) {
g0_new[n_indep]=g0_new[i];
ce_new[n_indep]=ce[i];
low_new[n_indep]=low[i];
up_new[n_indep]=up[i];
primal[n_indep]=start[i];
n_indep++;
}
for(j=0;j<n;j++) {
if((!lin_dependent[i]) && (!lin_dependent[j])) {
ig[to]=ig[from];
g_new[to]=g_new[from];
to++;
}
from++;
}
}
if(verbosity>=3) {
printf("real_qp_size(%ld)...",n_indep);
}
/* cannot optimize with only one variable */
if((n_indep<=1) && (m>0) && (!changed)) {
for(i=n-1;i>=0;i--) {
primal[i]=init[i];
}
return((int)ONLY_ONE_VARIABLE);
}
if((!changed) || (n_indep>1)) {
result=solve_dual(n_indep,m,precision,epsilon_crit,maxiter,g_new,g0_new,
ce_new,ce0_new,low_new,up_new,primal,d,d0,ig,
dual,dual_old,temp,goal);
}
else {
result=PRIMAL_OPTIMAL;
}
j=n_indep;
for(i=n-1;i>=0;i--) {
if(!lin_dependent[i]) {
j--;
primal[i]=primal[j];
}
else {
primal[i]=start[i]; /* leave as is */
}
temp[i]=primal[i];
}
obj_before=calculate_qp_objective(n,g,g0,init);
obj_after=calculate_qp_objective(n,g,g0,primal);
(*progress)=obj_before-obj_after;
if(verbosity>=3) {
printf("before(%.30f)...after(%.30f)...result_sd(%d)...",
obj_before,obj_after,result);
}
return((int)result);
}
uchar *get_wordl(uchar **cmd, int ml) { return maxl( get_word(cmd), ml); }
void maxl(tnp tr,int n) {
int nn=n+tr->v;
if((tr->l==NULL&&tr->r==NULL)&&(nn>maxleafl)) { maxleafl=nn; maxleaf=tr; return(n+tr->v); }
if(tr->l!=NULL) { maxl(tr->l,nn); }
if(tr->r!=NULL) { maxl(tr->r,nn); }
}
