sym-imp.hpp /usr/include/gecode/int/ldsb.hh /usr/include/gecode/set/ldsb.hh /usr/include/gecode/int/ldsb.hh /usr/include/gecode/int/ldsb/sym-imp.hpp Gecode Gecode::Int Gecode::Int::LDSB /*-*-mode:C++;c-basic-offset:2;indent-tabs-mode:nil-*-*/ /* *Mainauthors: *ChristopherMears<chris.mears@monash.edu> * *Copyright: *ChristopherMears,2012 * *Lastmodified: *$Date:2013-03-0702:18:29+0100(Thu,07Mar2013)$by$Author:mears$ *$Revision:13455$ * *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. * */ namespaceGecode{namespaceInt{namespaceLDSB{ template<classT,classA> ArgArray<T> dynamicStackToArgArray(constSupport::DynamicStack<T,A>&s){ ArgArray<T>a(s.entries()); for(inti=0;i<s.entries();++i){ a[i]=s[i]; } returna; } template<classView> void* SymmetryImp<View>::operatornew(size_ts,Space&home){ returnhome.ralloc(s); } template<classView> void SymmetryImp<View>::operatordelete(void*,Space&){} template<classView> void SymmetryImp<View>::operatordelete(void*){} template<classView> VariableSymmetryImp<View> ::VariableSymmetryImp(Space&home,int*_indices,unsignedintn) :indices(home,0,0){ //Findminimumandmaximumvaluein_indices:theminimumisthe //offset,andthemaximumdictateshowlargethebitsetneedsto //be. intmaximum=_indices[0]; intminimum=_indices[0]; for(unsignedinti=1;i<n;i++){ if(_indices[i]>maximum)maximum=_indices[i]; if(_indices[i]<minimum)minimum=_indices[i]; } indices.resize(home,maximum-minimum+1,minimum); //Setthebitsfortheincludedindices. for(unsignedinti=0;i<n;i++){ indices.set(_indices[i]); } } template<classView> inline VariableSymmetryImp<View> ::VariableSymmetryImp(Space&home,constVariableSymmetryImp&other): indices(home,other.indices){} template<classView> size_t VariableSymmetryImp<View> ::dispose(Space&home){ indices.dispose(home); returnsizeof(*this); } template<classView> void VariableSymmetryImp<View> ::update(Literall){ if(indices.valid(l._variable)){ indices.clear(l._variable); } } template<classView> SymmetryImp<View>* VariableSymmetryImp<View> ::copy(Space&home,boolshare)const{ (void)share; returnnew(home)VariableSymmetryImp<View>(home,*this); } //Theminimumvalueinvsisthebitset'soffset,andthemaximum //dictateshowlargethebitsetneedstobe. template<classView> ValueSymmetryImp<View> ::ValueSymmetryImp(Space&home,int*vs,unsignedintn) :values(home,0,0){ //Findminimumandmaximumvalueinvs:theminimumisthe //offset,andthemaximumdictateshowlargethebitsetneedsto //be. assert(n>0); intmaximum=vs[0]; intminimum=vs[0]; for(unsignedinti=1;i<n;i++){ if(vs[i]>maximum)maximum=vs[i]; if(vs[i]<minimum)minimum=vs[i]; } values.resize(home,maximum-minimum+1,minimum); //Setthebitsfortheincludedvalues. for(unsignedinti=0;i<n;i++){ values.set(vs[i]); } } template<classView> ValueSymmetryImp<View> ::ValueSymmetryImp(Space&home,constValueSymmetryImp<View>&other) :values(home,other.values){} template<classView> size_t ValueSymmetryImp<View> ::dispose(Space&home){ values.dispose(home); returnsizeof(*this); } template<classView> void ValueSymmetryImp<View> ::update(Literall){ if(values.valid(l._value)) values.clear(l._value); } template<classView> SymmetryImp<View>* ValueSymmetryImp<View> ::copy(Space&home,boolshare)const{ (void)share; returnnew(home)ValueSymmetryImp(home,*this); } template<classView> int VariableSequenceSymmetryImp<View> ::getVal(unsignedintsequence,unsignedintposition)const{ returnindices[sequence*seq_size+position]; } template<classView> VariableSequenceSymmetryImp<View> ::VariableSequenceSymmetryImp(Space&home,int*_indices,unsignedintn, unsignedintseqsize) :n_indices(n),seq_size(seqsize),n_seqs(n/seqsize){ indices=home.alloc<unsignedint>(n_indices); unsignedintmax_index=_indices[0]; for(unsignedinti=0;i<n_indices;i++){ indices[i]=_indices[i]; if(indices[i]>max_index) max_index=indices[i]; } lookup_size=max_index+1; lookup=home.alloc<int>(lookup_size); for(unsignedinti=0;i<lookup_size;i++) lookup[i]=-1; for(unsignedinti=0;i<n_indices;i++){ if(lookup[indices[i]]==-1) lookup[indices[i]]=i; } } template<classView> VariableSequenceSymmetryImp<View> ::VariableSequenceSymmetryImp(Space&home,boolshare, constVariableSequenceSymmetryImp&s) :n_indices(s.n_indices),seq_size(s.seq_size),n_seqs(s.n_seqs), lookup_size(s.lookup_size){ (void)share; indices=home.alloc<unsignedint>(n_indices); memcpy(indices,s.indices,n_indices*sizeof(int)); lookup=home.alloc<int>(lookup_size); memcpy(lookup,s.lookup,lookup_size*sizeof(int)); } template<classView> size_t VariableSequenceSymmetryImp<View> ::dispose(Space&home){ home.free<unsignedint>(indices,n_indices); home.free<int>(lookup,lookup_size); returnsizeof(*this); } template<classView> ArgArray<Literal> VariableSequenceSymmetryImp<View> ::symmetric(Literall,constViewArray<View>&x)const{ Support::DynamicStack<Literal, Heap>s(heap); if(l._variable<(int)lookup_size){ intposIt=lookup[l._variable]; if(posIt==-1){ returndynamicStackToArgArray(s); } unsignedintseqNum=posIt/seq_size; unsignedintseqPos=posIt%seq_size; for(unsignedintseq=0;seq<n_seqs;seq++){ if(seq==seqNum){ continue; } if(x[getVal(seq,seqPos)].assigned()){ continue; } boolactive=true; constunsignedint*firstSeq=&indices[seqNum*seq_size]; constunsignedint*secondSeq=&indices[seq*seq_size]; for(unsignedinti=0;i<seq_size;i++){ constView&xv=x[firstSeq[i]]; constView&yv=x[secondSeq[i]]; if((!xv.assigned()&&!yv.assigned()) ||(xv.assigned()&&yv.assigned()&&xv.val()==yv.val())){ continue; }else{ active=false; break; } } if(active){ s.push(Literal(secondSeq[seqPos],l._value)); } } } returndynamicStackToArgArray(s); } template<classView> void VariableSequenceSymmetryImp<View> ::update(Literall){ //Donothing. (void)l; } template<classView> SymmetryImp<View>* VariableSequenceSymmetryImp<View> ::copy(Space&home,boolshare)const{ returnnew(home)VariableSequenceSymmetryImp<View>(home,share,*this); } template<classView> int ValueSequenceSymmetryImp<View> ::getVal(unsignedintsequence,unsignedintposition)const{ returnvalues[sequence*seq_size+position]; } template<classView> ValueSequenceSymmetryImp<View> ::ValueSequenceSymmetryImp(Space&home,int*_values,unsignedintn, unsignedintseqsize) :n_values(n),seq_size(seqsize),n_seqs(n/seqsize), dead_sequences(home,n_seqs){ values=home.alloc<int>(n_values); for(unsignedinti=0;i<n_values;i++) values[i]=_values[i]; } template<classView> ValueSequenceSymmetryImp<View> ::ValueSequenceSymmetryImp(Space&home, constValueSequenceSymmetryImp<View>&vss) :n_values(vss.n_values), seq_size(vss.seq_size), n_seqs(vss.n_seqs), dead_sequences(home,vss.dead_sequences){ values=home.alloc<int>(n_values); for(unsignedinti=0;i<n_values;i++) values[i]=vss.values[i]; } template<classView> size_t ValueSequenceSymmetryImp<View> ::dispose(Space&home){ home.free(values,n_values); returnsizeof(*this); } template<classView> void ValueSequenceSymmetryImp<View> ::update(Literall){ unsignedintseq=0; unsignedintpos=0; for(unsignedinti=0;i<n_values;i++){ if(values[i]==l._value){ dead_sequences.set(seq); //TODO:Thiscanbeslightlyoptimised. while(pos<seq_size){ i++; pos++; } } pos++; if(pos==seq_size){ pos=0; seq++; } } } template<classView> SymmetryImp<View>* ValueSequenceSymmetryImp<View> ::copy(Space&home,boolshare)const{ (void)share; returnnew(home)ValueSequenceSymmetryImp<View>(home,*this); } }}} //STATISTICS:int-branch