weights.hpp gecode/set.hh gecode/int.hh /usr/include/gecode/set/int.hh Gecode::Set::Int::OverweightValues Gecode::Set::Int::IntLess Gecode Gecode::Set Gecode::Set::Int /*-*-mode:C++;c-basic-offset:2;indent-tabs-mode:nil-*-*/ /* *Mainauthors: *GuidoTack<tack@gecode.org> *ChristianSchulte<schulte@gecode.org> *GaborSzokoli<szokoli@gecode.org> * *Copyright: *GuidoTack,2004 *ChristianSchulte,2004 *GaborSzokoli,2004 * *Lastmodified: *$Date:2012-09-0717:31:22+0200(Fri,07Sep2012)$by$Author:schulte$ *$Revision:13068$ * *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<gecode/set.hh> #include<gecode/int.hh> namespaceGecode{namespaceSet{namespaceInt{ template<classI> classOverweightValues{ private: intthreshold; Iiter; constSharedArray<int>elements; constSharedArray<int>weights; intindex; voidnext(void); public: OverweightValues(void); OverweightValues(intt, SharedArray<int>&elements0, SharedArray<int>&weights0, I&i); voidinit(intt, SharedArray<int>&elements0, SharedArray<int>&weights0, I&i); booloperator ()(void)const; voidoperator ++(void); intval(void)const; }; template<classI> forceinlinevoid OverweightValues<I>::next(void){ while(iter()){ while(elements[index]<iter.val())index++; assert(elements[index]==iter.val()); if(weights[index]>threshold){ return; } ++iter; } } template<classI> forceinline OverweightValues<I>::OverweightValues(void){} template<classI> forceinline OverweightValues<I>::OverweightValues(intt, SharedArray<int>&elements0, SharedArray<int>&weights0, I&i):threshold(t), iter(i), elements(elements0), weights(weights0), index(0){ next(); } template<classI> forceinlinevoid OverweightValues<I>::init(intt, SharedArray<int>&elements0, SharedArray<int>&weights0, I&i){ threshold=t;iter=i; elements=elements0;weights=weights0; index=0; next(); } template<classI> forceinlinebool OverweightValues<I>::operator ()(void)const{returniter();} template<classI> forceinlinevoid OverweightValues<I>::operator ++(void){++iter;next();} template<classI> forceinlineint OverweightValues<I>::val(void)const{returnelements[index];} template<classView> forceinline Weights<View>::Weights(Homehome, constSharedArray<int>&elements0, constSharedArray<int>&weights0, Viewx0,Gecode::Int::IntViewy0) :Propagator(home),elements(elements0),weights(weights0), x(x0),y(y0){ home.notice(*this,AP_DISPOSE); x.subscribe(home,*this,PC_SET_ANY); y.subscribe(home,*this,Gecode::Int::PC_INT_BND); } template<classView> forceinline Weights<View>::Weights(Space&home,boolshare,Weights&p) :Propagator(home,share,p){ x.update(home,share,p.x); y.update(home,share,p.y); elements.update(home,share,p.elements); weights.update(home,share,p.weights); } template<classView> inlineExecStatus Weights<View>::post(Homehome,constSharedArray<int>&elements, constSharedArray<int>&weights, Viewx,Gecode::Int::IntViewy){ if(elements.size()!=weights.size()) throwArgumentSizeMismatch("Weights"); Regionr(home); int*els_arr=r.alloc<int>(elements.size()); for(inti=elements.size();i--;) els_arr[i]=elements[i]; IntSetels(els_arr,elements.size()); IntSetRangeser(els); GECODE_ME_CHECK(x.intersectI(home,er)); (void)new(home)Weights(home,elements,weights,x,y); returnES_OK; } template<classView> PropCost Weights<View>::cost(constSpace&,constModEventDelta&)const{ returnPropCost::linear(PropCost::LO,y.size()+1); } template<classView> forceinlinesize_t Weights<View>::dispose(Space&home){ home.ignore(*this,AP_DISPOSE); x.cancel(home,*this,PC_SET_ANY); y.cancel(home,*this,Gecode::Int::PC_INT_BND); elements.~SharedArray(); weights.~SharedArray(); (void)Propagator::dispose(home); returnsizeof(*this); } template<classView> Actor* Weights<View>::copy(Space&home,boolshare){ returnnew(home)Weights(home,share,*this); } template<classI> forceinline intweightI(SharedArray<int>&elements, SharedArray<int>&weights, I&iter){ intsum=0; inti=0; Iter::Ranges::ToValues<I>v(iter); for(;v();++v){ //Skipallelementsbelowthecurrent while(elements[i]<v.val())i++; assert(elements[i]==v.val()); sum+=weights[i]; } assert(!v()); returnsum; } classIntLess{ public: booloperator()(intx,inty); }; forceinlinebool IntLess::operator()(intx,inty){ returnx<y; } template<classView> ExecStatus Weights<View>::propagate(Space&home,constModEventDelta&){ ModEventme=ME_SET_NONE; if(!x.assigned()){ //Collecttheweightsoftheelementsintheunknownsetinanarray intsize=elements.size(); Regionr(home); int*currentWeights=r.alloc<int>(size); UnknownRanges<View>ur(x); Iter::Ranges::ToValues<UnknownRanges<View>>urv(ur); for(inti=0;i<size;i++){ if(!urv()||elements[i]<urv.val()){ currentWeights[i]=0; }else{ assert(elements[i]==urv.val()); currentWeights[i]=weights[i]; ++urv; } } //Sorttheweightsoftheunknownelements IntLessil; Support::quicksort<int>(currentWeights,size,il); //Themaximumnumberofelementsthatcanstillbeaddedtox intdelta=static_cast<int>(std::min(x.unknownSize(),x.cardMax()-x.glbSize())); //Theweightoftheelementsalreadyinx GlbRanges<View>glb(x); intglbWeight=weightI<GlbRanges<View>>(elements,weights,glb); //Computetheweightofthecurrentlowerboundofx,plusatmost //delta-1furtherelementswithsmallestnegativeweights.Thisweight //determineswhichelementsintheupperboundcannotpossiblybe //addedtox(thosewhoseweightwouldexceedthecapacityevenif //allotherelementsareminimal) intlowWeight=glbWeight; for(inti=0;i<delta-1;i++){ if(currentWeights[i]>=0) break; lowWeight+=currentWeights[i]; } //Computethelowestpossibleweightofx.Ifthereisanotherelement //withnegativeweightleft,thenadditsweighttolowWeight. //OtherwiselowWeightisalreadythelowestpossibleweight. intlowestWeight=lowWeight; if(delta>0&&currentWeights[delta-1]<0) lowestWeight+=currentWeights[delta-1]; //Ifafterincludingtheminimalnumberofrequiredelements, //nomoreelementwithnegativeweightisavailable,then //atighterlowerboundcanbecomputed. if((x.cardMin()-x.glbSize()>0&& currentWeights[x.cardMin()-x.glbSize()-1]>=0)|| currentWeights[0]>=0){ intlowestPosWeight=glbWeight; for(unsignedinti=0;i<x.cardMin()-x.glbSize();i++){ lowestPosWeight+=currentWeights[i]; } lowestWeight=std::max(lowestWeight,lowestPosWeight); } //Computethehighestpossibleweightofxastheweightofthelower //boundplustheweightofthedeltaheaviestelementsstillinthe //upperbound. inthighestWeight=glbWeight; for(inti=0;i<delta;i++){ if(currentWeights[size-i-1]<=0) break; highestWeight+=currentWeights[size-i-1]; } //Prunetheweightusingthecomputedbounds GECODE_ME_CHECK(y.gq(home,lowestWeight)); GECODE_ME_CHECK(y.lq(home,highestWeight)); //Excludeallelementsthataretooheavyfromthesetx. //Elementsaretooheavyiftheirweightalonealready //exceedstheremainingcapacity intremainingCapacity=y.max()-lowWeight; UnknownRanges<View>ur2(x); Iter::Ranges::ToValues<UnknownRanges<View>>urv2(ur2); OverweightValues<Iter::Ranges::ToValues<UnknownRanges<View>>> ov(remainingCapacity,elements,weights,urv2); Iter::Values::ToRanges<OverweightValues< Iter::Ranges::ToValues<UnknownRanges<View>>>>ovr(ov); me=x.excludeI(home,ovr); GECODE_ME_CHECK(me); } if(x.assigned()){ //Ifxisassigned,justcomputeitsweightandassigny. GlbRanges<View>glb(x); intw= weightI<GlbRanges<View>>(elements,weights,glb); GECODE_ME_CHECK(y.eq(home,w)); returnhome.ES_SUBSUMED(*this); } returnme_modified(me)?ES_NOFIX:ES_FIX; } }}} //STATISTICS:set-prop