interval.hpp stdexcept string gecode/third-party/boost/numeric/interval/detail/interval_prototype.hpp /usr/include/gecode/third-party/boost/numeric/interval/arith.hpp /usr/include/gecode/third-party/boost/numeric/interval/policies.hpp /usr/include/gecode/third-party/boost/numeric/interval.hpp boost::numeric::interval_lib::comparison_error boost::numeric::interval boost::numeric::interval::interval_holder boost::numeric::interval::number_holder boost boost::numeric boost::numeric::interval_lib /*Boostinterval/interval.hppheaderfile * *Copyright2002-2003HervéBrönnimann,GuillaumeMelquiond,SylvainPion * *DistributedundertheBoostSoftwareLicense,Version1.0. *(SeeaccompanyingfileLICENSE_1_0.txtor *copyathttp://www.boost.org/LICENSE_1_0.txt) */ #ifndefBOOST_NUMERIC_INTERVAL_INTERVAL_HPP #defineBOOST_NUMERIC_INTERVAL_INTERVAL_HPP #include<stdexcept> #include<string> #include<gecode/third-party/boost/numeric/interval/detail/interval_prototype.hpp> namespaceboost{ namespacenumeric{ namespaceinterval_lib{ classcomparison_error :publicstd::runtime_error { public: comparison_error() :std::runtime_error("boost::interval:uncertaincomparison") {} }; }//namespaceinterval_lib /* *intervalclass */ template<classT,classPolicies> classinterval { private: structinterval_holder; structnumber_holder; public: typedefTbase_type; typedefPoliciestraits_type; Tconst&lower()const; Tconst&upper()const; interval(); interval(Tconst&v); template<classT1>interval(T1const&v); interval(Tconst&l,Tconst&u); template<classT1,classT2>interval(T1const&l,T2const&u); interval(interval<T, Policies>const&r); template<classPolicies1>interval(interval<T, Policies1>const&r); template<classT1,classPolicies1>interval(interval<T1, Policies1>const&r); interval&operator=(Tconst&v); template<classT1>interval&operator=(T1const&v); interval&operator=(interval<T, Policies>const&r); template<classPolicies1>interval&operator=(interval<T, Policies1>const&r); template<classT1,classPolicies1>interval&operator=(interval<T1, Policies1>const&r); voidassign(constT&l,constT&u); staticintervalempty(); staticintervalwhole(); staticintervalhull(constT&x,constT&y); interval&operator+=(constT&r); interval&operator+=(constinterval&r); interval&operator-=(constT&r); interval&operator-=(constinterval&r); interval&operator*=(constT&r); interval&operator*=(constinterval&r); interval&operator/=(constT&r); interval&operator/=(constinterval&r); booloperator< (constinterval_holder&r)const; booloperator> (constinterval_holder&r)const; booloperator<= (constinterval_holder&r)const; booloperator>= (constinterval_holder&r)const; booloperator== (constinterval_holder&r)const; booloperator!= (constinterval_holder&r)const; booloperator< (constnumber_holder&r)const; booloperator> (constnumber_holder&r)const; booloperator<= (constnumber_holder&r)const; booloperator>= (constnumber_holder&r)const; booloperator== (constnumber_holder&r)const; booloperator!= (constnumber_holder&r)const; //thefollowingisforinternaluseonly,itisnotapublishedinterface //nevertheless,it'spublicbecausefriendsdon'talwaysworkcorrectly. interval(constT&l,constT&u,bool):low(l),up(u){} voidset_empty(); voidset_whole(); voidset(constT&l,constT&u); private: structinterval_holder{ template<classPolicies2> interval_holder(constinterval<T,Policies2>&r) :low(r.lower()),up(r.upper()) { typedeftypenamePolicies2::checkingchecking2; if(checking2::is_empty(low,up)) throwinterval_lib::comparison_error(); } constT&low; constT&up; }; structnumber_holder{ number_holder(constT&r):val(r) { typedeftypenamePolicies::checkingchecking; if(checking::is_nan(r)) throwinterval_lib::comparison_error(); } constT&val; }; typedeftypenamePolicies::checkingchecking; typedeftypenamePolicies::roundingrounding; Tlow; Tup; }; template<classT,classPolicies>inline interval<T,Policies>::interval(): low(static_cast<T>(0)),up(static_cast<T>(0)) {} template<classT,classPolicies>inline interval<T,Policies>::interval(Tconst&v):low(v),up(v) { if(checking::is_nan(v))set_empty(); } template<classT,classPolicies>template<classT1>inline interval<T,Policies>::interval(T1const&v) { if(checking::is_nan(v))set_empty(); else{ roundingrnd; low=rnd.conv_down(v); up=rnd.conv_up(v); } } template<classT,classPolicies>template<classT1,classT2>inline interval<T,Policies>::interval(T1const&l,T2const&u) { if(checking::is_nan(l)||checking::is_nan(u)||!(l<=u))set_empty(); else{ roundingrnd; low=rnd.conv_down(l); up=rnd.conv_up(u); } } template<classT,classPolicies>inline interval<T,Policies>::interval(Tconst&l,Tconst&u):low(l),up(u) { if(checking::is_nan(l)||checking::is_nan(u)||!(l<=u)) set_empty(); } template<classT,classPolicies>inline interval<T,Policies>::interval(interval<T,Policies>const&r):low(r.lower()),up(r.upper()) {} template<classT,classPolicies>template<classPolicies1>inline interval<T,Policies>::interval(interval<T,Policies1>const&r):low(r.lower()),up(r.upper()) { typedeftypenamePolicies1::checkingchecking1; if(checking1::is_empty(r.lower(),r.upper()))set_empty(); } template<classT,classPolicies>template<classT1,classPolicies1>inline interval<T,Policies>::interval(interval<T1,Policies1>const&r) { typedeftypenamePolicies1::checkingchecking1; if(checking1::is_empty(r.lower(),r.upper()))set_empty(); else{ roundingrnd; low=rnd.conv_down(r.lower()); up=rnd.conv_up(r.upper()); } } template<classT,classPolicies>inline interval<T,Policies>&interval<T,Policies>::operator=(Tconst&v) { if(checking::is_nan(v))set_empty(); elselow=up=v; return*this; } template<classT,classPolicies>template<classT1>inline interval<T,Policies>&interval<T,Policies>::operator=(T1const&v) { if(checking::is_nan(v))set_empty(); else{ roundingrnd; low=rnd.conv_down(v); up=rnd.conv_up(v); } return*this; } template<classT,classPolicies>inline interval<T,Policies>&interval<T,Policies>::operator=(interval<T,Policies>const&r) { low=r.lower(); up=r.upper(); return*this; } template<classT,classPolicies>template<classPolicies1>inline interval<T,Policies>&interval<T,Policies>::operator=(interval<T,Policies1>const&r) { typedeftypenamePolicies1::checkingchecking1; if(checking1::is_empty(r.lower(),r.upper()))set_empty(); else{ low=r.lower(); up=r.upper(); } return*this; } template<classT,classPolicies>template<classT1,classPolicies1>inline interval<T,Policies>&interval<T,Policies>::operator=(interval<T1,Policies1>const&r) { typedeftypenamePolicies1::checkingchecking1; if(checking1::is_empty(r.lower(),r.upper()))set_empty(); else{ roundingrnd; low=rnd.conv_down(r.lower()); up=rnd.conv_up(r.upper()); } return*this; } template<classT,classPolicies>inline voidinterval<T, Policies>::assign(constT&l,constT&u) { if(checking::is_nan(l)||checking::is_nan(u)||!(l<=u)) set_empty(); elseset(l,u); } template<classT,classPolicies>inline voidinterval<T,Policies>::set(constT&l,constT&u) { low=l; up=u; } template<classT,classPolicies>inline voidinterval<T,Policies>::set_empty() { low=checking::empty_lower(); up=checking::empty_upper(); } template<classT,classPolicies>inline voidinterval<T,Policies>::set_whole() { low=checking::neg_inf(); up=checking::pos_inf(); } template<classT,classPolicies>inline interval<T,Policies>interval<T,Policies>::hull(constT&x,constT&y) { boolbad_x=checking::is_nan(x); boolbad_y=checking::is_nan(y); if(bad_x) if(bad_y)returninterval::empty(); elsereturninterval(y,y,true); else if(bad_y)returninterval(x,x,true); if(x<=y)returninterval(x,y,true); elsereturninterval(y,x,true); } template<classT,classPolicies>inline interval<T,Policies>interval<T,Policies>::empty() { returninterval<T,Policies>(checking::empty_lower(), checking::empty_upper(),true); } template<classT,classPolicies>inline interval<T,Policies>interval<T,Policies>::whole() { returninterval<T,Policies>(checking::neg_inf(),checking::pos_inf(),true); } template<classT,classPolicies>inline constT&interval<T,Policies>::lower()const { returnlow; } template<classT,classPolicies>inline constT&interval<T,Policies>::upper()const { returnup; } /* *interval/intervalcomparisons */ template<classT,classPolicies>inline boolinterval<T, Policies>::operator< (constinterval_holder&r)const { if(!checking::is_empty(low,up)){ if(up<r.low)returntrue; elseif(low>=r.up)returnfalse; } throwinterval_lib::comparison_error(); } template<classT,classPolicies>inline boolinterval<T, Policies>::operator> (constinterval_holder&r)const { if(!checking::is_empty(low,up)){ if(low>r.up)returntrue; elseif(up<=r.low)returnfalse; } throwinterval_lib::comparison_error(); } template<classT,classPolicies>inline boolinterval<T, Policies>::operator<= (constinterval_holder&r)const { if(!checking::is_empty(low,up)){ if(up<=r.low)returntrue; elseif(low>r.up)returnfalse; } throwinterval_lib::comparison_error(); } template<classT,classPolicies>inline boolinterval<T, Policies>::operator>= (constinterval_holder&r)const { if(!checking::is_empty(low,up)){ if(low>=r.up)returntrue; elseif(up<r.low)returnfalse; } throwinterval_lib::comparison_error(); } template<classT,classPolicies>inline boolinterval<T, Policies>::operator== (constinterval_holder&r)const { if(!checking::is_empty(low,up)){ //Boostbug?if(up==r.low&&low==r.up)returntrue; if(up==r.up&&low==r.low)returntrue; elseif(up<r.low||low>r.up)returnfalse; } throwinterval_lib::comparison_error(); } template<classT,classPolicies>inline boolinterval<T, Policies>::operator!= (constinterval_holder&r)const { if(!checking::is_empty(low,up)){ if(up<r.low||low>r.up)returntrue; elseif(up==r.low&&low==r.up)returnfalse; } throwinterval_lib::comparison_error(); } /* *interval/numbercomparisons */ template<classT,classPolicies>inline boolinterval<T, Policies>::operator< (constnumber_holder&r)const { if(!checking::is_empty(low,up)){ if(up<r.val)returntrue; elseif(low>=r.val)returnfalse; } throwinterval_lib::comparison_error(); } template<classT,classPolicies>inline boolinterval<T, Policies>::operator> (constnumber_holder&r)const { if(!checking::is_empty(low,up)){ if(low>r.val)returntrue; elseif(up<=r.val)returnfalse; } throwinterval_lib::comparison_error(); } template<classT,classPolicies>inline boolinterval<T, Policies>::operator<= (constnumber_holder&r)const { if(!checking::is_empty(low,up)){ if(up<=r.val)returntrue; elseif(low>r.val)returnfalse; } throwinterval_lib::comparison_error(); } template<classT,classPolicies>inline boolinterval<T, Policies>::operator>= (constnumber_holder&r)const { if(!checking::is_empty(low,up)){ if(low>=r.val)returntrue; elseif(up<r.val)returnfalse; } throwinterval_lib::comparison_error(); } template<classT,classPolicies>inline boolinterval<T, Policies>::operator== (constnumber_holder&r)const { if(!checking::is_empty(low,up)){ if(up==r.val&&low==r.val)returntrue; elseif(up<r.val||low>r.val)returnfalse; } throwinterval_lib::comparison_error(); } template<classT,classPolicies>inline boolinterval<T, Policies>::operator!= (constnumber_holder&r)const { if(!checking::is_empty(low,up)){ if(up<r.val||low>r.val)returntrue; elseif(up==r.val&&low==r.val)returnfalse; } throwinterval_lib::comparison_error(); } }//namespacenumeric }//namespaceboost #endif//BOOST_NUMERIC_INTERVAL_INTERVAL_HPP