tree.hpp algorithm cmath /usr/include/gecode/int/cumulative.hh cmath /usr/include/gecode/int/cumulative/tree.hpp algorithm /usr/include/gecode/int/cumulative.hh /usr/include/gecode/int/cumulative/tree.hpp Gecode Gecode::Int Gecode::Int::Cumulative /*-*-mode:C++;c-basic-offset:2;indent-tabs-mode:nil-*-*/ /* *Mainauthors: *ChristianSchulte<schulte@gecode.org> *GuidoTack<tack@gecode.org> * *Copyright: *ChristianSchulte,2009 *GuidoTack,2010 * *Lastmodified: *$Date:2013-03-1106:26:07+0100(Mon,11Mar2013)$by$Author:tack$ *$Revision:13487$ * *ThisfileispartofGecode,thegenericconstraint *developmentenvironment: *http://www.gecode.org * *Permissionisherebygranted,freeofcharge,toanypersonobtaining *acopyofthissoftwareandassociateddocumentationfiles(the *"Software"),todealintheSoftwarewithoutrestriction,including *withoutlimitationtherightstouse,copy,modify,merge,publish, *distribute,sublicense,and/orsellcopiesoftheSoftware,andto *permitpersonstowhomtheSoftwareisfurnishedtodoso,subjectto *thefollowingconditions: * *Theabovecopyrightnoticeandthispermissionnoticeshallbe *includedinallcopiesorsubstantialportionsoftheSoftware. * *THESOFTWAREISPROVIDED"ASIS",WITHOUTWARRANTYOFANYKIND, *EXPRESSORIMPLIED,INCLUDINGBUTNOTLIMITEDTOTHEWARRANTIESOF *MERCHANTABILITY,FITNESSFORAPARTICULARPURPOSEAND *NONINFRINGEMENT.INNOEVENTSHALLTHEAUTHORSORCOPYRIGHTHOLDERSBE *LIABLEFORANYCLAIM,DAMAGESOROTHERLIABILITY,WHETHERINANACTION *OFCONTRACT,TORTOROTHERWISE,ARISINGFROM,OUTOFORINCONNECTION *WITHTHESOFTWAREORTHEUSEOROTHERDEALINGSINTHESOFTWARE. * */ #include<algorithm> #include<cmath> namespaceGecode{namespaceInt{namespaceCumulative{ /* *Omegatree */ forceinlinevoid OmegaNode::init(constOmegaNode&,constOmegaNode&){ e=0;env=-Limits::llinfinity; } forceinlinevoid OmegaNode::update(constOmegaNode&l,constOmegaNode&r){ e=l.e+r.e;env=std::max(plus(l.env,r.e),r.env); } template<classTaskView> OmegaTree<TaskView>::OmegaTree(Region&r,intc0, constTaskViewArray<TaskView>&t) :TaskTree<TaskView,OmegaNode>(r,t),c(c0){ for(inti=tasks.size();i--;){ leaf(i).e=0;leaf(i).env=-Limits::llinfinity; } init(); } template<classTaskView> forceinlinevoid OmegaTree<TaskView>::insert(inti){ leaf(i).e=tasks[i].e(); leaf(i).env= static_cast<longlongint>(c)*tasks[i].est()+tasks[i].e(); update(i); } template<classTaskView> forceinlinevoid OmegaTree<TaskView>::remove(inti){ leaf(i).e=0;leaf(i).env=-Limits::llinfinity; update(i); } template<classTaskView> forceinlinelonglongint OmegaTree<TaskView>::env(void)const{ returnroot().env; } /* *ExtendedOmegatree */ forceinlinevoid ExtOmegaNode::init(constExtOmegaNode&l,constExtOmegaNode&r){ OmegaNode::init(l,r); cenv=-Limits::llinfinity; } forceinlinevoid ExtOmegaNode::update(constExtOmegaNode&l,constExtOmegaNode&r){ OmegaNode::update(l,r); cenv=std::max(plus(l.cenv,r.e),r.cenv); } template<classTaskView>void ExtOmegaTree<TaskView>::init(intci0){ ci=ci0; for(inti=tasks.size();i--;){ leaf(i).e=0; leaf(i).env=leaf(i).cenv=-Limits::llinfinity; } init(); } template<classTaskView>template<classNode> ExtOmegaTree<TaskView>::ExtOmegaTree(Region&r,intc0, constTaskTree<TaskView,Node>&t) :TaskTree<TaskView,ExtOmegaNode>(r,t),c(c0){} template<classTaskView> forceinlinelonglongint ExtOmegaTree<TaskView>::env(inti){ //Entertaski leaf(i).e=tasks[i].e(); leaf(i).env= static_cast<longlongint>(c)*tasks[i].est()+tasks[i].e(); leaf(i).cenv= static_cast<longlongint>(c-ci)*tasks[i].est()+tasks[i].e(); TaskTree<TaskView,ExtOmegaNode>::update(i); //Performcomputationofnodefortaskwithminest intmet=0; { longlonginte=0; while(!n_leaf(met)){ if(plus(node[n_right(met)].cenv,e)> static_cast<longlongint>(c-ci)*tasks[i].lct()){ met=n_right(met); }else{ e+=node[n_right(met)].e;met=n_left(met); } } } /* *Thefollowingideatocomputethecutinonegoistakenfrom: *JosephScott,FilteringAlgorithmsforDiscreteResources, *MasterThesis,UppsalaUniversity,2010(inpreparation). */ //Nowperformsplitfromleafmetupwards longlonginta_e=node[met].e; longlonginta_env=node[met].env; longlongintb_e=0; while(!n_root(met)){ if(left(met)){ b_e+=node[n_right(n_parent(met))].e; }else{ a_env=std::max(a_env,plus(node[n_left(n_parent(met))].env,a_e)); a_e+=node[n_left(n_parent(met))].e; } met=n_parent(met); } returnplus(a_env,b_e); } /* *Omegalambdatree */ forceinlinevoid OmegaLambdaNode::init(constOmegaLambdaNode&l,constOmegaLambdaNode&r){ OmegaNode::init(l,r); le=0;lenv=-Limits::llinfinity; resLe=undef;resLenv=undef; } forceinlinevoid OmegaLambdaNode::update(constOmegaLambdaNode&l,constOmegaLambdaNode&r){ OmegaNode::update(l,r); if(l.le+r.e>l.e+r.le){ le=l.le+r.e; resLe=l.resLe; }else{ le=l.e+r.le; resLe=r.resLe; } if((r.lenv>=plus(l.env,r.le))&&(r.lenv>=plus(l.lenv,r.e))){ lenv=r.lenv;resLenv=r.resLenv; }elseif(plus(l.env,r.le)>=plus(l.lenv,r.e)){ assert(plus(l.env,r.le)>r.lenv); lenv=plus(l.env,r.le);resLenv=r.resLe; }else{ assert((plus(l.lenv,r.e)>r.lenv)&& (plus(l.lenv,r.e)>plus(l.env,r.le))); lenv=plus(l.lenv,r.e);resLenv=l.resLenv; } } template<classTaskView> OmegaLambdaTree<TaskView>::OmegaLambdaTree(Region&r,intc0, constTaskViewArray<TaskView>&t) :TaskTree<TaskView,OmegaLambdaNode>(r,t),c(c0){ //Enteralltasksintotree(omega=alltasks,lambda=empty) for(inti=tasks.size();i--;){ leaf(i).e=tasks[i].e(); leaf(i).le=0; leaf(i).env=static_cast<longlongint>(c)*tasks[i].est()+tasks[i].e(); leaf(i).lenv=-Limits::llinfinity; leaf(i).resLe=OmegaLambdaNode::undef; leaf(i).resLenv=OmegaLambdaNode::undef; } update(); } template<classTaskView> forceinlinevoid OmegaLambdaTree<TaskView>::shift(inti){ //iisinomega assert(leaf(i).env>-Limits::llinfinity); leaf(i).le=leaf(i).e; leaf(i).e=0; leaf(i).lenv=leaf(i).env; leaf(i).env=-Limits::llinfinity; leaf(i).resLe=i; leaf(i).resLenv=i; update(i); } template<classTaskView> forceinlinevoid OmegaLambdaTree<TaskView>::lremove(inti){ //inotinomegabutinlambda assert(leaf(i).env==-Limits::llinfinity); assert(leaf(i).lenv>-Limits::llinfinity); leaf(i).le=0; leaf(i).lenv=-Limits::llinfinity; leaf(i).resLe=OmegaLambdaNode::undef; leaf(i).resLenv=OmegaLambdaNode::undef; update(i); } template<classTaskView> forceinlinebool OmegaLambdaTree<TaskView>::lempty(void)const{ returnroot().resLenv<0; } template<classTaskView> forceinlineint OmegaLambdaTree<TaskView>::responsible(void)const{ returnroot().resLenv; } template<classTaskView> forceinlinelonglongint OmegaLambdaTree<TaskView>::env(void)const{ returnroot().env; } template<classTaskView> forceinlinelonglongint OmegaLambdaTree<TaskView>::lenv(void)const{ returnroot().lenv; } }}} //STATISTICS:int-prop