Subject: [Boost-commit] svn:boost r65952 - in sandbox/itl: boost/itl/detail boost/itl/type_traits boost/itl_xt boost/validate/driver boost/validate/gentor boost/validate/itl boost/validate/laws boost/validate/validater libs/itl/test libs/itl/test/fastest_itl_interval_ libs/itl/test/fastest_itl_map_ libs/itl/test/test_casual_ libs/itl/test/test_itl_interval_ libs/validate/example/labat_map_copy_conformity_ libs/validate/test
From: afojgo_at_[hidden]
Date: 2010-10-14 09:16:12
Author: jofaber
Date: 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
New Revision: 65952
URL: http://svn.boost.org/trac/boost/changeset/65952
Log:
Refactoring: Replacing applications of old itl::interval. Stable{msvc-9.0,10.0, gcc-3.4.4}
Text files modified:
sandbox/itl/boost/itl/detail/set_algo.hpp | 37 --------------------
sandbox/itl/boost/itl/type_traits/is_numeric.hpp | 9 -----
sandbox/itl/boost/itl_xt/bits_gentor.hpp | 5 +-
sandbox/itl/boost/itl_xt/itvgentor.hpp | 12 ++---
sandbox/itl/boost/itl_xt/map_segment_gentor.hpp | 9 ++--
sandbox/itl/boost/itl_xt/mapgentor.hpp | 15 +++++---
sandbox/itl/boost/itl_xt/numbergentor.hpp | 13 +++---
sandbox/itl/boost/itl_xt/random.hpp | 7 ++-
sandbox/itl/boost/itl_xt/seqgentor.hpp | 12 +++--
sandbox/itl/boost/itl_xt/setgentor.hpp | 14 ++++---
sandbox/itl/boost/validate/driver/map_copy_conformity_driver.hpp | 19 ++++++----
sandbox/itl/boost/validate/gentor/gentorprofile.hpp | 71 ++++++++++++++++++++-------------------
sandbox/itl/boost/validate/gentor/randomgentor.hpp | 30 ++++++++--------
sandbox/itl/boost/validate/gentor/rangegentor.hpp | 34 ++++++++++++------
sandbox/itl/boost/validate/itl/functors.hpp | 13 +++---
sandbox/itl/boost/validate/laws/law_violations.hpp | 2
sandbox/itl/boost/validate/validater/law_validater.hpp | 4 +-
sandbox/itl/boost/validate/validater/sorted_associative_validater.hpp | 1
sandbox/itl/libs/itl/test/fastest_itl_interval_/fastest_itl_interval.cpp | 6 +--
sandbox/itl/libs/itl/test/fastest_itl_map_/fastest_itl_map_cases.hpp | 7 ---
sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp | 2 -
sandbox/itl/libs/itl/test/test_itl_interval.hpp | 3 -
sandbox/itl/libs/itl/test/test_itl_interval_/test_itl_interval.cpp | 3 -
sandbox/itl/libs/validate/example/labat_map_copy_conformity_/vc9_labat_map_copy_conformity.vcproj | 2
sandbox/itl/libs/validate/test/Jamfile.v2 | 4 +-
25 files changed, 146 insertions(+), 188 deletions(-)
Modified: sandbox/itl/boost/itl/detail/set_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/set_algo.hpp (original)
+++ sandbox/itl/boost/itl/detail/set_algo.hpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -63,24 +63,6 @@
return true;
}
-/*CL
-template<class ObjectT, class CoObjectT>
-ObjectT& erase(ObjectT& result, const CoObjectT& x2)
-{
- typename CoObjectT::const_iterator common_lwb_;
- typename CoObjectT::const_iterator common_upb_;
- if(!common_range(common_lwb_, common_upb_, x2, result))
- return result;
-
- typename CoObjectT::const_iterator x2_ = common_lwb_;
- typename ObjectT::iterator common_;
-
- while(x2_ != common_upb_)
- result.erase(*x2_++);
-
- return result;
-}
-*/
/** Function template <tt>contained_in</tt> implements the subset relation.
<tt>contained_in(sub, super)</tt> is true if <tt>sub</tt> is contained in <tt>super</tt> */
@@ -123,25 +105,6 @@
return false;
}
-/*CL
-template<class SetType>
-inline bool is_disjoint(const SetType& left, const SetType& right)
-{
- return !intersects(left, right);
-}
-
-template<class SetType>
-void flip(SetType& result, const SetType& x2)
-{
- typename SetType::const_iterator x2_ = x2.begin(), x1_;
- while(x2_ != x2.end())
- {
- std::pair<typename SetType::iterator,bool> insertion = result.insert(*x2_++);
- if(!insertion.second)
- result.erase(insertion.first);
- }
-}
-*/
#ifdef BOOST_MSVC
#pragma warning(push)
Modified: sandbox/itl/boost/itl/type_traits/is_numeric.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_numeric.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_numeric.hpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -28,15 +28,6 @@
};
//--------------------------------------------------------------------------
-/*CL
-namespace aux
-{
- template<class Type> struct functions
- {
- typedef bool (*Type_to_bool)(const Type&);
- };
-};
-*/
template<class Type, bool Enable = false> struct numeric_minimum;
template<class Type>
Modified: sandbox/itl/boost/itl_xt/bits_gentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/bits_gentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/bits_gentor.hpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -20,8 +20,7 @@
class bits_gentor: public RandomGentorAT<itl::bits<NaturalT> >
{
public:
- //CL typedef interval<NaturalT> range_type;
- typedef typename interval<NaturalT>::type range_type;
+ typedef typename itl::_interval<NaturalT>::type range_type;
typedef itl::bits<NaturalT> bits_type;
void some(bits_type& value)
@@ -29,7 +28,7 @@
value = bits_type(_natural_gentor(_value_range));
};
- void set_range(const itl::interval<NaturalT>& range)
+ void set_range(const range_type& range)
{ _value_range = range; }
private:
Modified: sandbox/itl/boost/itl_xt/itvgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/itvgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/itvgentor.hpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -42,12 +42,11 @@
namespace boost{namespace itl
{
-template <class ItvDomTV, class ItvTV=interval<ItvDomTV> >
+template <class ItvDomTV, class ItvTV=itl::_interval<ItvDomTV>::type>
class ItvGentorT: public RandomGentorAT<ItvTV>
{
public:
- typedef itl::interval<ItvDomTV> range_type;
- //typedef typename itl::_interval<ItvDomTV>::type range_type;
+ typedef typename itl::_interval<ItvDomTV>::type range_type;
virtual void some(ItvTV& x);
@@ -55,7 +54,9 @@
{ m_valueRange = range; }
void setValueRange(ItvDomTV low, ItvDomTV up)
- { m_valueRange.set(low,up, itl::right_open_bounded); }
+ {
+ m_valueRange = itl::construct<range_type>(low, up);
+ }
void setMaxIntervalLength(ItvDomTV len) { m_maxIntervalLength=len; }
void setProbDerivation();
@@ -106,20 +107,17 @@
if(decideEmpty==0)
{
ItvDomTV x2 = m_ItvDomTVGentor(m_valueRange);
- //CL x = construct<ItvTV>(x1, x1-x2, interval_bounds(bndTypes));
x = construct_interval<ItvTV, has_static_bounds<ItvTV>::value>
::apply(x1, x1-x2, interval_bounds(bndTypes));
}
else if(upOrDown==0) {
ItvDomTV up
= m_ItvDomTVGentor(x1, static_cast<ItvDomTV>((std::min)(m_valueRange.upper(), x1+m_maxIntervalLength)));
- //CL x = construct<ItvTV>(x1, up, interval_bounds(bndTypes));
x = construct_interval<ItvTV, has_static_bounds<ItvTV>::value>
::apply(x1, up, interval_bounds(bndTypes));
} else {
ItvDomTV low
= m_ItvDomTVGentor(static_cast<ItvDomTV>((std::max)(m_valueRange.lower(), x1-m_maxIntervalLength)), x1);
- //CL x = construct<ItvTV>(low, x1, interval_bounds(bndTypes));
x = construct_interval<ItvTV, has_static_bounds<ItvTV>::value>
::apply(low, x1, interval_bounds(bndTypes));
}
Modified: sandbox/itl/boost/itl_xt/map_segment_gentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/map_segment_gentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/map_segment_gentor.hpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -19,14 +19,15 @@
namespace boost{namespace itl
{
-template <class DomainT, class CodomainT, class IntervalT = itl::interval<DomainT> >
+template <class DomainT, class CodomainT, class IntervalT = itl::_interval<DomainT>::type >
class map_segment_gentor: public RandomGentorAT<std::pair<IntervalT, CodomainT> >
{
public:
typedef DomainT domain_type;
typedef CodomainT codomain_type;
typedef IntervalT interval_type;
- typedef itl::interval<codomain_type> co_range_type;
+ typedef typename itl::_interval<domain_type>::type range_type;
+ typedef typename itl::_interval<codomain_type>::type co_range_type;
//typedef typename itl::_interval<codomain_type>::type co_range_type;
typedef std::pair<IntervalT, CodomainT> segment_type;
@@ -36,10 +37,10 @@
virtual void some(segment_type& x);
- void set_range(const itl::interval<domain_type>& range)
+ void set_range(const range_type& range)
{ _interval_gentor.setRange(range); }
- void set_corange(const itl::interval<codomain_type>& range)
+ void set_corange(const co_range_type& range)
{ _covalue_range = range; }
void setMaxIntervalLength(domain_type max_itv_length)
Modified: sandbox/itl/boost/itl_xt/mapgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/mapgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/mapgentor.hpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -23,8 +23,7 @@
typedef typename MapTV::key_type DomainTD;
typedef typename MapTV::data_type CodomainTD;
typedef list<ValueTypeTD> SampleTypeTD;
- typedef itl::interval<int> sample_range_type;
- //typedef typename itl::_interval<int>::type sample_range_type;
+ typedef typename itl::_interval<int>::type sample_range_type;
MapGentorT(): p_domainGentor(NULL), p_codomainGentor(NULL) {}
~MapGentorT() { delete p_domainGentor; delete p_codomainGentor; }
@@ -45,9 +44,13 @@
}
void setRangeOfSampleSize(int lwb, int upb)
- { m_sampleSizeRange = interval<int>::right_open(lwb,upb); }
- void setRangeOfSampleSize(const interval<int>& szRange)
- { BOOST_ASSERT(szRange.is(right_open)); m_sampleSizeRange = szRange; }
+ { m_sampleSizeRange = _interval<int>::right_open(lwb,upb); }
+
+ void setRangeOfSampleSize(const itl::_interval<int>::type& szRange)
+ {
+ BOOST_ASSERT(itl::bounds(szRange) == interval_bounds::right_open());
+ m_sampleSizeRange = szRange;
+ }
private:
RandomGentorAT<DomainTD>* p_domainGentor;
@@ -62,7 +65,7 @@
void MapGentorT<MapTV>::some(MapTV& x)
{
NumberGentorT<int> intGentor;
- ITL_FUN_CALL(clear, x);
+ itl::clear(x);
m_sample.clear();
m_sampleSize = intGentor(m_sampleSizeRange);
Modified: sandbox/itl/boost/itl_xt/numbergentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/numbergentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/numbergentor.hpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -57,7 +57,6 @@
{
public:
typedef typename itl::_interval<NumT>::type range_type;
- //CL typedef itl:: interval<NumT> range_type;
private:
range_type _range;
};
@@ -66,25 +65,25 @@
class NumberGentorT : public RandomGentorAT<NumTV>
{
public:
- //typedef typename itl::_interval<NumTV>::type range_type;
- typedef itl:: interval<NumTV> range_type;
+ typedef typename itl::_interval<NumTV>::type range_type;
public:
NumberGentorT():
- m_valueRange( NumTV(), unit_element<NumTV>::value(), itl::right_open_bounded ) {}
+ m_valueRange( NumTV(), unit_element<NumTV>::value() ) {}
NumTV operator() (NumTV upb) { return rnd_0_to_excl<NumTV>(upb); }
NumTV operator() (NumTV lwb, NumTV upb) { return rnd_within_exUpb<NumTV>(lwb,upb); }
NumTV operator() (range_type rng)
{
- // BOOST_ASSERT(rng.is(right_open_bounded) || rng.is(closed_bounded));
- if(rng.is(itl::right_open_bounded))
+ BOOST_ASSERT( itl::bounds(rng) == interval_bounds::right_open()
+ || itl::bounds(rng) == interval_bounds::closed());
+ if(itl::bounds(rng) == interval_bounds::right_open())
return rnd_within_exUpb<NumTV>(rng.lower(), rng.upper());
else
return rnd_within<NumTV>(rng.lower(), rng.upper());
}
void setRange(range_type rng) { m_valueRange = rng; }
- void setRange(NumTV lwb, NumTV upb) { m_valueRange = interval<NumTV>::right_open(lwb,upb); }
+ void setRange(NumTV lwb, NumTV upb) { m_valueRange = _interval<NumTV>::right_open(lwb,upb); }
void calibrate(const RandomGentorProfile<NumTV>& profile)
{
Modified: sandbox/itl/boost/itl_xt/random.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/random.hpp (original)
+++ sandbox/itl/boost/itl_xt/random.hpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -58,8 +58,11 @@
return some + lwb;
}
- unsigned rnd(const itl::interval<unsigned>& rng)
- { BOOST_ASSERT( rng.is(right_open) ); return rnd(rng.lower(),rng.upper()); }
+ unsigned rnd(const itl::_interval<unsigned>::type& rng)
+ {
+ BOOST_ASSERT(itl::bounds(rng) == interval_bounds::right_open());
+ return rnd(rng.lower(),rng.upper());
+ }
private:
//JODO subtractive_rng m_random;
Modified: sandbox/itl/boost/itl_xt/seqgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/seqgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/seqgentor.hpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -45,8 +45,7 @@
typedef typename SeqTV::value_type ValueTypeTD;
typedef typename SeqTV::value_type DomainTD;
typedef list<ValueTypeTD> SampleTypeTD;
- typedef itl::interval<int> sample_range_type;
- //typedef typename itl::_interval<int>::type sample_range_type;
+ typedef typename itl::_interval<int>::type sample_range_type;
SeqGentorT(): p_domainGentor(NULL), m_unique(false){}
~SeqGentorT(){ delete p_domainGentor; }
@@ -62,9 +61,12 @@
}
void setRangeOfSampleSize(int lwb, int upb)
- { m_sampleSizeRange = interval<int>::right_open(lwb,upb); }
- void setRangeOfSampleSize(const interval<int>& szRange)
- { BOOST_ASSERT(szRange.is(itl::right_open)); m_sampleSizeRange = szRange; }
+ { m_sampleSizeRange = _interval<int>::right_open(lwb,upb); }
+ void setRangeOfSampleSize(const _interval<int>::type& szRange)
+ {
+ BOOST_ASSERT(itl::bounds(szRange) == interval_bounds::right_open());
+ m_sampleSizeRange = szRange;
+ }
void setUnique(bool truth) { m_unique = truth; }
Modified: sandbox/itl/boost/itl_xt/setgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/setgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/setgentor.hpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -48,8 +48,7 @@
typedef list<ValueTypeTD> SampleTypeTD;
typedef RandomGentorAT<DomainTD> DomainGentorT;
typedef DomainGentorT* DomainGentorPT;
- typedef itl::interval<int> sample_range_type;
- //typedef typename itl::_interval<int>::type sample_range_type;
+ typedef typename itl::_interval<int>::type sample_range_type;
SetGentorT(): p_domainGentor(NULL) {}
~SetGentorT() { delete p_domainGentor; }
@@ -65,9 +64,12 @@
}
void setRangeOfSampleSize(int lwb, int upb)
- { m_sampleSizeRange = interval<int>::right_open(lwb,upb); }
- void setRangeOfSampleSize(const interval<int>& szRange)
- { BOOST_ASSERT(szRange.is(right_open)); m_sampleSizeRange = szRange; }
+ { m_sampleSizeRange = _interval<int>::right_open(lwb,upb); }
+ void setRangeOfSampleSize(const itl::_interval<int>::type& szRange)
+ {
+ BOOST_ASSERT(itl::bounds(szRange) == interval_bounds::right_open());
+ m_sampleSizeRange = szRange;
+ }
DomainGentorPT domainGentor()const { return p_domainGentor; }
@@ -83,7 +85,7 @@
void SetGentorT<SetTV>::some(SetTV& x)
{
NumberGentorT<int> intGentor;
- ITL_FUN_CALL(clear, x);
+ itl::clear(x);
m_sample.clear();
m_sampleSize = intGentor(m_sampleSizeRange);
Modified: sandbox/itl/boost/validate/driver/map_copy_conformity_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/map_copy_conformity_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/map_copy_conformity_driver.hpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -94,6 +94,9 @@
concept_validater* chooseValidater()
{
+ typedef _interval<double>::type interval_double;
+ typedef _interval<int>::type interval_int;
+
int rootChoice = _rootChoice.some();
int identityHandlerChoice = _identityHandlerChoice.some();
@@ -112,20 +115,20 @@
//-----------------------------------------------------------------
case RootType::interval_map: {
switch(identityHandlerChoice) {
- case IdentityHandlerType::partial_absorber: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<double,std::less>::type,int> >, interval_map<double,int,partial_absorber> >;
- case IdentityHandlerType::partial_enricher: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<double,std::less>::type,int> >, interval_map<double,int,partial_enricher> >;
- case IdentityHandlerType::total_absorber: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<int,std::less>::type, int> >, interval_map<int, int,total_absorber > >;
- case IdentityHandlerType::total_enricher: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<int,std::less>::type, int> >, interval_map<int, int,total_enricher > >;
+ case IdentityHandlerType::partial_absorber: return new function_equality_validater<itl::list<std::pair<interval_double,int> >, interval_map<double,int,partial_absorber> >;
+ case IdentityHandlerType::partial_enricher: return new function_equality_validater<itl::list<std::pair<interval_double,int> >, interval_map<double,int,partial_enricher> >;
+ case IdentityHandlerType::total_absorber: return new function_equality_validater<itl::list<std::pair<interval_int, int> >, interval_map<int, int,total_absorber > >;
+ case IdentityHandlerType::total_enricher: return new function_equality_validater<itl::list<std::pair<interval_int, int> >, interval_map<int, int,total_enricher > >;
default: return choiceError(ITL_LOCATION("\nRootType::interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
}//switch identityHandlerChoice
}//case interval_map
//-----------------------------------------------------------------
case RootType::split_interval_map: {
switch(identityHandlerChoice) {
- case IdentityHandlerType::partial_absorber: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<double,std::less>::type,int> >, split_interval_map<double,int,partial_absorber> >;
- case IdentityHandlerType::partial_enricher: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<int,std::less>::type, int> >, split_interval_map<int, int,partial_enricher> >;
- case IdentityHandlerType::total_absorber: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<double,std::less>::type,int> >, split_interval_map<double,int,total_absorber > >;
- case IdentityHandlerType::total_enricher: return new function_equality_validater<itl::list<std::pair<typename interval_type_default<int,std::less>::type, int> >, split_interval_map<int, int,total_enricher > >;
+ case IdentityHandlerType::partial_absorber: return new function_equality_validater<itl::list<std::pair<interval_double,int> >, split_interval_map<double,int,partial_absorber> >;
+ case IdentityHandlerType::partial_enricher: return new function_equality_validater<itl::list<std::pair<interval_int, int> >, split_interval_map<int, int,partial_enricher> >;
+ case IdentityHandlerType::total_absorber: return new function_equality_validater<itl::list<std::pair<interval_double,int> >, split_interval_map<double,int,total_absorber > >;
+ case IdentityHandlerType::total_enricher: return new function_equality_validater<itl::list<std::pair<interval_int, int> >, split_interval_map<int, int,total_enricher > >;
default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: identityHandlerChoice:\n"), identityHandlerChoice, _identityHandlerChoice);
}//switch identityHandlerChoice
}//case split_interval_map
Modified: sandbox/itl/boost/validate/gentor/gentorprofile.hpp
==============================================================================
--- sandbox/itl/boost/validate/gentor/gentorprofile.hpp (original)
+++ sandbox/itl/boost/validate/gentor/gentorprofile.hpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -12,6 +12,7 @@
#include <math.h>
#include <boost/validate/type/nat.hpp>
#include <boost/itl/interval.hpp>
+#include <boost/itl/type_traits/interval_type_default.hpp>
namespace boost{namespace itl
{
@@ -29,35 +30,35 @@
void set_polygon_profile(int max_polygon_set_size, int max_polygon_size, int min_coord, int max_coord);
void set_range_int(int lwb, int upb)
- { _range_int = interval<int>::right_open(lwb, upb); }
+ { _range_int = _interval<int>::right_open(lwb, upb); }
void set_range_nat(cnat lwb, cnat upb)
- { _range_nat = interval<cnat>::right_open(lwb, upb); }
+ { _range_nat = _interval<cnat>::right_open(lwb, upb); }
void set_range_double(double lwb, double upb)
- { _range_double = interval<double>::right_open(lwb, upb); }
+ { _range_double = _interval<double>::right_open(lwb, upb); }
void set_range_ContainerSize(int lwb, int upb)
- { _range_ContainerSize = interval<int>::right_open(lwb, upb); }
+ { _range_ContainerSize = _interval<int>::right_open(lwb, upb); }
void set_range_interval_int(int lwb, int upb)
- { _range_interval_int = interval<int>::right_open(lwb, upb); }
+ { _range_interval_int = _interval<int>::right_open(lwb, upb); }
void set_range_interval_double(double lwb, double upb)
- { _range_interval_double = interval<double>::right_open(lwb, upb); }
+ { _range_interval_double = _interval<double>::right_open(lwb, upb); }
void set_maxIntervalLength(int val)
{ _maxIntervalLength = val; }
void set_range_codomain_ContainerSize(int lwb, int upb)
- { _range_codomain_ContainerSize = interval<int>::right_open(lwb, upb); }
+ { _range_codomain_ContainerSize = _interval<int>::right_open(lwb, upb); }
void set_repeat_count(int repeat) { _repeat_count = repeat; }
void set_trials_count(int trials) { _trials_count = trials; }
void set_trials_count_release(int trials) { _trials_count_release = trials; }
void set_laws_per_cycle(int count){ _laws_per_cycle = count; }
void set_debug_slowdown(double factor){ _debug_slowdown = factor; }
- interval<int> range_int() { return _range_int; }
- interval<cnat> range_nat() { return _range_nat; }
- interval<double> range_double() { return _range_double; }
- interval<int> range_ContainerSize() { return _range_ContainerSize; }
- interval<int> range_interval_int() { return _range_interval_int; }
- interval<double> range_interval_double() { return _range_interval_double; }
+ _interval<int>::type range_int() { return _range_int; }
+ _interval<cnat>::type range_nat() { return _range_nat; }
+ _interval<double>::type range_double() { return _range_double; }
+ _interval<int>::type range_ContainerSize() { return _range_ContainerSize; }
+ _interval<int>::type range_interval_int() { return _range_interval_int; }
+ _interval<double>::type range_interval_double() { return _range_interval_double; }
int maxIntervalLength() { return _maxIntervalLength; }
- interval<int> range_codomain_ContainerSize()
+ _interval<int>::type range_codomain_ContainerSize()
{ return _range_codomain_ContainerSize; }
int repeat_count() { return _repeat_count; }
int trials_count() { return _trials_count; }
@@ -74,16 +75,16 @@
void report_profile();
private:
- interval<int> _range_int;
- interval<cnat> _range_nat;
- interval<double> _range_double;
- interval<int> _range_ContainerSize;
+ _interval<int>::type _range_int;
+ _interval<cnat>::type _range_nat;
+ _interval<double>::type _range_double;
+ _interval<int>::type _range_ContainerSize;
- interval<int> _range_interval_int;
- interval<double> _range_interval_double;
+ _interval<int>::type _range_interval_int;
+ _interval<double>::type _range_interval_double;
int _maxIntervalLength;
- interval<int> _range_codomain_ContainerSize;
+ _interval<int>::type _range_codomain_ContainerSize;
int _repeat_count;
int _trials_count;
int _trials_count_release;
@@ -121,14 +122,14 @@
void set_trials_count(int trials) { m_profile.set_trials_count(trials); }
void set_laws_per_cycle(int count) { m_profile.set_laws_per_cycle(count); }
- interval<int> range_int() { return m_profile.range_int(); }
- interval<cnat> range_nat() { return m_profile.range_nat(); }
- interval<double> range_double() { return m_profile.range_double(); }
- interval<int> range_ContainerSize(){ return m_profile.range_ContainerSize(); }
- interval<int> range_interval_int() { return m_profile.range_interval_int(); }
- interval<double> range_interval_double() { return m_profile.range_interval_double();}
+ _interval<int>::type range_int() { return m_profile.range_int(); }
+ _interval<cnat>::type range_nat() { return m_profile.range_nat(); }
+ _interval<double>::type range_double() { return m_profile.range_double(); }
+ _interval<int>::type range_ContainerSize(){ return m_profile.range_ContainerSize(); }
+ _interval<int>::type range_interval_int() { return m_profile.range_interval_int(); }
+ _interval<double>::type range_interval_double() { return m_profile.range_interval_double();}
int maxIntervalLength() { return m_profile.maxIntervalLength(); }
- interval<int> range_codomain_ContainerSize(){ return m_profile.range_codomain_ContainerSize(); }
+ _interval<int>::type range_codomain_ContainerSize(){ return m_profile.range_codomain_ContainerSize(); }
int repeat_count() { return m_profile.repeat_count(); }
int trials_count() { return m_profile.trials_count(); }
int laws_per_cycle() { return m_profile.laws_per_cycle(); }
@@ -153,37 +154,37 @@
template<typename NumberT>
struct GentorProfileSgl_numeric_range
{
- static interval<NumberT> get();
+ static typename _interval<NumberT>::type get();
};
template<>
struct GentorProfileSgl_numeric_range<int>
{
- static interval<int> get()
+ static _interval<int>::type get()
{ return GentorProfileSgl::it()->range_int(); }
};
template<>
struct GentorProfileSgl_numeric_range<unsigned int>
{
- static interval<unsigned int> get()
+ static _interval<unsigned int>::type get()
{
- interval<cnat> inter_val = GentorProfileSgl::it()->range_nat();
- return interval<unsigned int>::right_open(inter_val.lower(), inter_val.upper());
+ _interval<cnat>::type inter_val = GentorProfileSgl::it()->range_nat();
+ return _interval<unsigned int>::right_open(inter_val.lower(), inter_val.upper());
}
};
template<>
struct GentorProfileSgl_numeric_range<cnat>
{
- static interval<cnat> get()
+ static _interval<cnat>::type get()
{ return GentorProfileSgl::it()->range_nat(); }
};
template<>
struct GentorProfileSgl_numeric_range<double>
{
- static interval<double> get()
+ static _interval<double>::type get()
{ return GentorProfileSgl::it()->range_double(); }
};
Modified: sandbox/itl/boost/validate/gentor/randomgentor.hpp
==============================================================================
--- sandbox/itl/boost/validate/gentor/randomgentor.hpp (original)
+++ sandbox/itl/boost/validate/gentor/randomgentor.hpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -276,7 +276,7 @@
static void apply(RandomGentor<itl::bits<BitsT> >& gentor)
{
// Set the range within which the sizes of the generated object varies.
- gentor.set_range(itl::interval<BitsT>::right_open(0, sizeof(BitsT)));
+ gentor.set_range(itl::_interval<BitsT>::right_open(0, sizeof(BitsT)));
}
};
@@ -589,7 +589,7 @@
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
ItvGentorT<int, discrete_interval<int,Compare> >* itvGentor
= new ItvGentorT<int, discrete_interval<int,Compare> >;
- interval<int> valRange = GentorProfileSgl::it()->range_interval_int();
+ typename _interval<int>::type valRange = GentorProfileSgl::it()->range_interval_int();
itvGentor->setValueRange(valRange.lower(), valRange.upper());
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
gentor.setDomainGentor(itvGentor);
@@ -683,7 +683,7 @@
NumberGentorT<NumericDomainT>* domainGentor = new NumberGentorT<NumericDomainT>;
bits_gentor<BitsT>* codomainGentor = new bits_gentor<BitsT>;
domainGentor->setRange(GentorProfileSgl_numeric_range<NumericDomainT>::get());
- codomainGentor->set_range(interval<BitsT>::closed(0, (std::numeric_limits<BitsT>::max)()));
+ codomainGentor->set_range(_interval<BitsT>::closed(0, (std::numeric_limits<BitsT>::max)()));
gentor.setDomainGentor(domainGentor);
gentor.setCodomainGentor(codomainGentor);
}
@@ -708,7 +708,7 @@
ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >* itvGentor
= new ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >;
- interval<NumericDomainT> valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
+ typename _interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
itvGentor->setValueRange(valRange.lower(), valRange.upper());
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
@@ -740,7 +740,7 @@
ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >* itvGentor
= new ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >;
- interval<NumericDomainT> valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
+ typename _interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
itvGentor->setValueRange(valRange.lower(), valRange.upper());
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
@@ -774,7 +774,7 @@
// NumberGentorT<int> intGentor;
ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >* itvGentor
= new ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >;
- interval<NumericDomainT> valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
+ typename _interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
itvGentor->setValueRange(valRange.lower(), valRange.upper());
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
@@ -806,7 +806,7 @@
// NumberGentorT<int> intGentor;
ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >* itvGentor
= new ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >;
- interval<NumericDomainT> valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
+ typename _interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
itvGentor->setValueRange(valRange.lower(), valRange.upper());
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
@@ -839,7 +839,7 @@
// NumberGentorT<int> intGentor;
ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >* itvGentor
= new ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >;
- interval<NumericDomainT> valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
+ typename _interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
itvGentor->setValueRange(valRange.lower(), valRange.upper());
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
@@ -873,7 +873,7 @@
// NumberGentorT<int> intGentor;
ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >* itvGentor
= new ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >;
- interval<NumericDomainT> valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
+ typename _interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
itvGentor->setValueRange(valRange.lower(), valRange.upper());
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
@@ -903,12 +903,12 @@
// NumberGentorT<int> intGentor;
ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >* itvGentor
= new ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >;
- interval<NumericDomainT> valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
+ typename _interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
itvGentor->setValueRange(valRange.lower(), valRange.upper());
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
bits_gentor<BitsT>* codomainGentor = new bits_gentor<BitsT>;
- codomainGentor->set_range(interval<BitsT>::closed(0, (std::numeric_limits<BitsT>::max)()));
+ codomainGentor->set_range(_interval<BitsT>::closed(0, (std::numeric_limits<BitsT>::max)()));
gentor.setDomainGentor(itvGentor);
gentor.setCodomainGentor(codomainGentor);
@@ -933,12 +933,12 @@
// NumberGentorT<int> intGentor;
ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >* itvGentor
= new ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >;
- interval<NumericDomainT> valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
+ typename _interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
itvGentor->setValueRange(valRange.lower(), valRange.upper());
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
bits_gentor<BitsT>* codomainGentor = new bits_gentor<BitsT>;
- codomainGentor->set_range(interval<BitsT>::closed(0, (std::numeric_limits<BitsT>::max)()));
+ codomainGentor->set_range(_interval<BitsT>::closed(0, (std::numeric_limits<BitsT>::max)()));
gentor.setDomainGentor(itvGentor);
gentor.setCodomainGentor(codomainGentor);
@@ -960,12 +960,12 @@
// NumberGentorT<int> intGentor;
ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >* itvGentor
= new ItvGentorT<NumericDomainT, ITL_INTERVAL_TYPE(Interval,NumericDomainT,Compare) >;
- interval<NumericDomainT> valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
+ typename _interval<NumericDomainT>::type valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
itvGentor->setValueRange(valRange.lower(), valRange.upper());
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
bits_gentor<BitsT>* codomainGentor = new bits_gentor<BitsT>;
- codomainGentor->set_range(interval<BitsT>::closed(0, (std::numeric_limits<BitsT>::max)()));
+ codomainGentor->set_range(_interval<BitsT>::closed(0, (std::numeric_limits<BitsT>::max)()));
gentor.setDomainGentor(itvGentor);
gentor.setCodomainGentor(codomainGentor);
Modified: sandbox/itl/boost/validate/gentor/rangegentor.hpp
==============================================================================
--- sandbox/itl/boost/validate/gentor/rangegentor.hpp (original)
+++ sandbox/itl/boost/validate/gentor/rangegentor.hpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -39,30 +39,40 @@
{
template <class Type>
- class RangeGentor: public RandomGentorAT<interval<Type> >
+ class RangeGentor: public RandomGentorAT<typename _interval<Type>::type >
{
public:
- virtual void some(interval<Type>& x);
- interval<Type> last()const;
+ typedef typename _interval<Type>::type interval_type;
+ public:
+ virtual void some(interval_type& x);
+ interval_type last()const;
void setLowerBoundRange(int lwb, int upb)
- { setLowerBoundRange(interval<int>::right_open(lwb,upb)); }
- void setLowerBoundRange(const interval<int>& range)
- { BOOST_ASSERT(range.is_right_open()||range.is_closed()); _lwbGentor.setRange(range); }
+ { setLowerBoundRange(_interval<int>::right_open(lwb,upb)); }
+
+ void setLowerBoundRange(const itl::_interval<int>::type& range)
+ {
+ //JODO? BOOST_ASSERT(range.is_right_open()||range.is_closed());
+ _lwbGentor.setRange(range);
+ }
void setUpperBoundRange(int lwb, int upb)
- { setUpperBoundRange(interval<int>::right_open(lwb,upb)); }
- void setUpperBoundRange(const interval<int>& range)
- { BOOST_ASSERT(range.is_right_open()||range.is_closed()); _upbGentor.setRange(range); }
+ { setUpperBoundRange(_interval<int>::right_open(lwb,upb)); }
+
+ void setUpperBoundRange(const itl::_interval<int>::type& range)
+ {
+ //JODO? BOOST_ASSERT(range.is_right_open()||range.is_closed());
+ _upbGentor.setRange(range);
+ }
private:
NumberGentorT<Type> _lwbGentor;
NumberGentorT<Type> _upbGentor;
- interval<Type> _last;
+ interval_type _last;
};
template <class Type>
- void RangeGentor<Type>::some(interval<Type>& x)
+ void RangeGentor<Type>::some(interval_type& x)
{
Type lwb, upb;
_lwbGentor.some(lwb);
@@ -72,7 +82,7 @@
}
template <class Type>
- interval<Type> RangeGentor<Type>::last()const
+ typename RangeGentor<Type>::interval_type RangeGentor<Type>::last()const
{
return _last;
}
Modified: sandbox/itl/boost/validate/itl/functors.hpp
==============================================================================
--- sandbox/itl/boost/validate/itl/functors.hpp (original)
+++ sandbox/itl/boost/validate/itl/functors.hpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -26,7 +26,7 @@
{
void operator()(TargetT& collected, const SourceT& items)
{
- ITL_FUN_CALL(clear, collected);
+ itl::clear(collected);
ITL_const_FORALL(typename SourceT, item_, items)
collected.insert(*item_);
}
@@ -40,7 +40,8 @@
{
void operator()(TargetT& collected, const SourceT& items)
{
- ITL_FUN_CALL(clear, collected);
+ typedef typename TargetT::value_type target_value_type;
+ itl::clear(collected);
typename TargetT::iterator prior_ = collected.end();
ITL_const_FORALL(typename SourceT, item_, items)
prior_ = collected.insert(prior_, *item_);
@@ -55,7 +56,7 @@
{
void operator()(TargetT& collected, const SourceT& items)
{
- ITL_FUN_CALL(clear, collected);
+ itl::clear(collected);
std::copy(items.begin(), items.end(), itl::inserter(collected, collected.end()));
}
};
@@ -69,7 +70,7 @@
{
void operator()(TargetT& collected, const SourceT& items)
{
- ITL_FUN_CALL(clear, collected);
+ itl::clear(collected);
ITL_const_FORALL(typename SourceT, item_, items)
//JODO itl::add(collected, *item_);
collected.add(*item_);
@@ -84,7 +85,7 @@
{
void operator()(TargetT& collected, const SourceT& items)
{
- ITL_FUN_CALL(clear, collected);
+ itl::clear(collected);
typename TargetT::iterator prior_ = collected.end();
ITL_const_FORALL(typename SourceT, item_, items)
//JODO prior_ = add(collected, prior_, *item_);
@@ -100,7 +101,7 @@
{
void operator()(TargetT& collected, const SourceT& items)
{
- ITL_FUN_CALL(clear, collected);
+ itl::clear(collected);
std::copy(items.begin(), items.end(), itl::adder(collected, collected.end()));
}
};
Modified: sandbox/itl/boost/validate/laws/law_violations.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/law_violations.hpp (original)
+++ sandbox/itl/boost/validate/laws/law_violations.hpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -146,7 +146,7 @@
iterator end() { return _violations.end(); }
const_iterator end()const { return _violations.begin(); }
- void clear() { ITL_FUN_CALL(clear, _violations); }
+ void clear() { itl::clear(_violations); }
bool empty()const { return ITL_FUN_REN(empty, is_empty, _violations); }
size_type size()const { return _violations.size(); }
Modified: sandbox/itl/boost/validate/validater/law_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/law_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/law_validater.hpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -136,9 +136,9 @@
template <class LawT, template<typename>class GentorT>
void LawValidater<LawT, GentorT>::init()
{
- ITL_FUN_CALL(clear, _frequencies);
+ itl::clear(_frequencies);
_lawViolations.clear();
- ITL_FUN_CALL(clear, _violations);
+ itl::clear(_violations);
}
// Runs law_instance_count * repeat_count validations on the law LawT
Modified: sandbox/itl/boost/validate/validater/sorted_associative_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/sorted_associative_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/sorted_associative_validater.hpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -30,7 +30,6 @@
public:
typedef typename Type::atomized_type atomic_type;
typedef typename atomic_type::value_type value_type;
- //CL typedef typename Type::domain_type domain_type;
typedef typename domain_type_of<Type>::type domain_type;
typedef typename Type::codomain_type codomain_type;
Modified: sandbox/itl/libs/itl/test/fastest_itl_interval_/fastest_itl_interval.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_itl_interval_/fastest_itl_interval.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_itl_interval_/fastest_itl_interval.cpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -119,8 +119,6 @@
//==============================================================================
//==============================================================================
-//JODO old tests are not adapted to static_intervals
-
BOOST_AUTO_TEST_CASE
(fastest_itl_interval_equal_4_integral_types)
{ interval_equal_4_integral_types<integral_type_2>(); }
@@ -141,11 +139,11 @@
BOOST_AUTO_TEST_CASE
(fastest_itl_interval_ctor_specific)
-{ interval_ctor_specific(); } //JODO static
+{ interval_ctor_specific(); }
BOOST_AUTO_TEST_CASE
(fastest_itl_interval_equal_4_bicremental_continuous_types)
-{ interval_equal_4_bicremental_continuous_types<bicremental_continuous_type_1>(); } //JODO static
+{ interval_equal_4_bicremental_continuous_types<bicremental_continuous_type_1>(); }
BOOST_AUTO_TEST_CASE
(fastest_itl_interval_infix_intersect_4_bicremental_types)
Modified: sandbox/itl/libs/itl/test/fastest_itl_map_/fastest_itl_map_cases.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_itl_map_/fastest_itl_map_cases.hpp (original)
+++ sandbox/itl/libs/itl/test/fastest_itl_map_/fastest_itl_map_cases.hpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -16,11 +16,4 @@
(fastest_itl_itl_map_find_4_bicremental_types)
{ itl_map_find_4_bicremental_types<discrete_type_1, int, partial_absorber, INTERVAL_MAP>();}
-//JODO CL or repair
-//BOOST_AUTO_TEST_CASE
-//(fastest_itl_itl_map_inclusion_compare_4_bicremental_types)
-//{ itl_map_inclusion_compare_4_bicremental_types<discrete_type_1, int, partial_absorber, INTERVAL_MAP>();}
-
-
-
#endif // BOOST_ITL_TEST_ITL_MAP_CASES_HPP_JOFA_090701
Modified: sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp (original)
+++ sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -35,8 +35,6 @@
#include <boost/itl/type_traits/is_key_container_of.hpp>
#include <boost/itl/type_traits/codomain_type_of.hpp>
#include <boost/itl/type_traits/is_icl_container.hpp>
-#include <boost/itl/type_traits/given.hpp>
-
#include <boost/itl_xt/detail/bit_element_iterator.hpp>
#include <boost/itl_xt/interval_bitset.hpp>
Modified: sandbox/itl/libs/itl/test/test_itl_interval.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_interval.hpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_interval.hpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -32,7 +32,4 @@
BOOST_CHECK_EQUAL(IntervalT(), IntervalT(lower_bound, itl::identity_element<T>::value()));
}
-/*JODO
-*/
-
#endif // __test_itl_interval_hpp_JOFA_081006__
Modified: sandbox/itl/libs/itl/test/test_itl_interval_/test_itl_interval.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_interval_/test_itl_interval.cpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_interval_/test_itl_interval.cpp 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -16,8 +16,6 @@
#include "../test_value_maker.hpp"
#include "../test_interval_laws.hpp"
-//CL #include <boost/itl/interval.hpp>
-
using namespace std;
using namespace boost;
using namespace unit_test;
@@ -147,7 +145,6 @@
//==============================================================================
//==============================================================================
-//JODO old tests are not adapted to static_intervals
BOOST_AUTO_TEST_CASE_TEMPLATE
(fastest_itl_interval_equal_4_integral_types, T, integral_types)
{ interval_equal_4_integral_types<T>(); }
Modified: sandbox/itl/libs/validate/example/labat_map_copy_conformity_/vc9_labat_map_copy_conformity.vcproj
==============================================================================
--- sandbox/itl/libs/validate/example/labat_map_copy_conformity_/vc9_labat_map_copy_conformity.vcproj (original)
+++ sandbox/itl/libs/validate/example/labat_map_copy_conformity_/vc9_labat_map_copy_conformity.vcproj 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -120,7 +120,7 @@
Name="VCCLCompilerTool"
WholeProgramOptimization="true"
AdditionalIncludeDirectories="../../../../; ../../../../boost_1_35_0"
- PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS"
+ PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
ExceptionHandling="1"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
Modified: sandbox/itl/libs/validate/test/Jamfile.v2
==============================================================================
--- sandbox/itl/libs/validate/test/Jamfile.v2 (original)
+++ sandbox/itl/libs/validate/test/Jamfile.v2 2010-10-14 09:16:06 EDT (Thu, 14 Oct 2010)
@@ -33,10 +33,10 @@
[ run test_val_relations_/test_val_relations.cpp ../src/gentor/gentorprofile.cpp ]
# 2.9 msvc9 compilation time: 1:01
- [ run test_set_copy_conformity_/test_set_copy_conformity.cpp ../src/gentor/gentorprofile.cpp ]
+ #[ run test_set_copy_conformity_/test_set_copy_conformity.cpp ../src/gentor/gentorprofile.cpp ]
# 3.6 msvc9 compilation time: 1:03
- [ run test_map_copy_conformity_/test_map_copy_conformity.cpp ../src/gentor/gentorprofile.cpp ]
+ #[ run test_map_copy_conformity_/test_map_copy_conformity.cpp ../src/gentor/gentorprofile.cpp ]
# 4.3 msvc9 compilation time: 1:05
[ run test_interval_bitset_/test_interval_bitset.cpp ../src/gentor/gentorprofile.cpp ]