Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r56724 - in sandbox/itl: boost/itl boost/itl/type_traits boost/itl_xt boost/itl_xt/std boost/validate boost/validate/driver boost/validate/gentor boost/validate/itl boost/validate/laws boost/validate/type boost/validate/validater libs/itl/build/win32 libs/validate/example/labat_bit_collector_ libs/validate/example/labat_polygon_ libs/validate/example/labat_single_
From: afojgo_at_[hidden]
Date: 2009-10-11 17:15:25


Author: jofaber
Date: 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
New Revision: 56724
URL: http://svn.boost.org/trac/boost/changeset/56724

Log:
Added law based tests testing equivalence of copying via std::copy and loops.
Added law based tests for interval_maps of bitsets.
Fixed bug in itl::map hinted insert and hinted add.
Stable {msvc-8.0, 9.0}.

Added:
   sandbox/itl/boost/itl_xt/bits_gentor.hpp (contents, props changed)
   sandbox/itl/boost/itl_xt/std/pair_gentor.hpp (contents, props changed)
   sandbox/itl/boost/validate/driver/bit_collector_driver.hpp (contents, props changed)
   sandbox/itl/boost/validate/type/bits.hpp (contents, props changed)
   sandbox/itl/boost/validate/validater/bit_collector_validater.hpp (contents, props changed)
   sandbox/itl/libs/validate/example/labat_bit_collector_/
   sandbox/itl/libs/validate/example/labat_bit_collector_/labat_bit_collector.cpp (contents, props changed)
   sandbox/itl/libs/validate/example/labat_bit_collector_/vc9_labat_bit_collector.vcproj (contents, props changed)
Text files modified:
   sandbox/itl/boost/itl/functors.hpp | 106 +++++++++++------
   sandbox/itl/boost/itl/map.hpp | 30 ----
   sandbox/itl/boost/itl/map_algo.hpp | 244 ----------------------------------------
   sandbox/itl/boost/itl/type_traits/to_string.hpp | 2
   sandbox/itl/boost/itl/type_traits/type_to_string.hpp | 23 ++-
   sandbox/itl/boost/itl_xt/list.hpp | 1
   sandbox/itl/boost/itl_xt/seqgentor.hpp | 2
   sandbox/itl/boost/itl_xt/std/pair.hpp | 1
   sandbox/itl/boost/validate/driver/collector_driver.hpp | 5
   sandbox/itl/boost/validate/driver/map_copy_conformity_driver.hpp | 27 +--
   sandbox/itl/boost/validate/gentor/randomgentor.hpp | 184 +++++++++++++++++++++++++----
   sandbox/itl/boost/validate/gentor/rangegentor.hpp | 2
   sandbox/itl/boost/validate/itl/functors.hpp | 2
   sandbox/itl/boost/validate/laws/law_violations.hpp | 11 +
   sandbox/itl/boost/validate/laws/monoid.hpp | 3
   sandbox/itl/boost/validate/laws/set_laws.hpp | 51 +++++++-
   sandbox/itl/boost/validate/laws/symmetric_difference.hpp | 30 ++--
   sandbox/itl/boost/validate/type/nat.hpp | 1
   sandbox/itl/boost/validate/validater/collector_validater.hpp | 4
   sandbox/itl/boost/validate/validater/function_equality_validater.hpp | 2
   sandbox/itl/boost/validate/validater/signed_quantifier_validater.hpp | 1
   sandbox/itl/boost/validate/validation_counts.hpp | 8 +
   sandbox/itl/libs/itl/build/win32/vc9_all.sln | 6
   sandbox/itl/libs/validate/example/labat_polygon_/point_gentor.hpp | 2
   sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp | 26 ++-
   25 files changed, 364 insertions(+), 410 deletions(-)

Modified: sandbox/itl/boost/itl/functors.hpp
==============================================================================
--- sandbox/itl/boost/itl/functors.hpp (original)
+++ sandbox/itl/boost/itl/functors.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -303,6 +303,18 @@
     //--------------------------------------------------------------------------
     // Positive or negative functor trait
     //--------------------------------------------------------------------------
+
+ // A binary operation - is negative (or inverting) with respect to the
+ // neutral element iff it yields the inverse element if it is applied to the
+ // neutron element:
+ // 0 - x = -x
+ // For a functor that wraps the inpleace of op-assign verision this is
+ // equivalent to
+ //
+ // T x = ..., y;
+ // y = Functor::neutron();
+ // Functor()(y, x); // y == inverse_of(x)
+
     template<class Functor> struct is_negative;
 
     template<class Functor>
@@ -329,51 +341,69 @@
     //--------------------------------------------------------------------------
     // Pro- or in-version functor
     //--------------------------------------------------------------------------
- template<class Combiner> struct version;
+ template<class Combiner> struct conversion;
 
     template<class Combiner>
- struct version
+ struct conversion
     {
- typedef version<Combiner> type;
- typedef typename
- remove_const<
- typename remove_reference<typename Combiner::first_argument_type
- >::type
- >::type
- argument_type;
- // The pro-version of an contruction functor lets the value unchanged
- // 0 o= x == x;
- argument_type operator()(const argument_type& value){ return value; }
- };
+ typedef conversion<Combiner> type;
+ typedef typename
+ remove_const<
+ typename remove_reference<typename Combiner::first_argument_type
+ >::type
+ >::type
+ argument_type;
+ // The proversion of an op-assign functor o= lets the value unchanged
+ // (0 o= x) == x;
+ // Example += : (0 += x) == x
+ static argument_type proversion(const argument_type& value)
+ {
+ return value;
+ }
+
+ // The inversion of an op-assign functor o= inverts the value x
+ // to it's inverse element -x
+ // (0 o= x) == -x;
+ // Example -= : (0 -= x) == -x
+ static argument_type inversion(const argument_type& value)
+ {
+ argument_type inverse = Combiner::neutron();
+ Combiner()(inverse, value);
+ return inverse;
+ }
+ };
+
+ template<class Combiner> struct version : public conversion<Combiner>
+ {
+ typedef version<Combiner> type;
+ typedef conversion<Combiner> base_type;
+ typedef typename base_type::argument_type argument_type;
+
+ argument_type operator()(const argument_type& value)
+ { return base_type::proversion(value); }
+ };
+
+ template<>struct version<itl::inplace_minus<short > >{short operator()(short val){return -val;}};
+ template<>struct version<itl::inplace_minus<int > >{int operator()(int val){return -val;}};
+ template<>struct version<itl::inplace_minus<long > >{long operator()(long val){return -val;}};
+ template<>struct version<itl::inplace_minus<long long > >{long long operator()(long long val){return -val;}};
+ template<>struct version<itl::inplace_minus<float > >{float operator()(float val){return -val;}};
+ template<>struct version<itl::inplace_minus<double > >{double operator()(double val){return -val;}};
+ template<>struct version<itl::inplace_minus<long double> >{long double operator()(long double val){return -val;}};
 
     template<class Type>
- struct version<itl::inplace_minus<Type> >
+ struct version<itl::inplace_minus<Type> > : public conversion<itl::inplace_minus<Type> >
     {
- typedef version type;
- typedef itl::inplace_minus<Type> Combiner;
-
- Type operator()(const Type& value)
- {
- Type inverse = Combiner::neutron();
- Combiner()(inverse, value);
- return inverse;
- }
- };
+ typedef version<itl::inplace_minus<Type> > type;
+ typedef conversion<itl::inplace_minus<Type> > base_type;
+ typedef typename base_type::argument_type argument_type;
+
+ Type operator()(const Type& value)
+ {
+ return base_type::inversion(value);
+ }
+ };
 
- template<class Type>
- struct version<itl::inplace_bit_subtract<Type> >
- {
- typedef version type;
- typedef itl::inplace_bit_subtract<Type> Combiner;
-
- Type operator()(const Type& value)
- {
- Type inverse = Combiner::neutron();
- Combiner()(inverse, value);
- return inverse;
- }
- };
-
 
 }} // namespace itl boost
 

Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -271,7 +271,7 @@
     iterator insert(iterator prior, const value_type& value_pair)
     {
         if(Traits::absorbs_neutrons && value_pair.second == codomain_combine::neutron())
- return prior;
+ return end();
         else
             return base_type::insert(prior, value_pair);
     }
@@ -459,39 +459,17 @@
         return prior_;
 
     iterator inserted_ = base_insert(prior_, value_type(val.first, Combiner::neutron()));
- Combiner()(inserted_->second, val.second);
- if(Traits::absorbs_neutrons && inserted_->second == Combiner::neutron())
- {
- erase(inserted_);
- return prior_;
- }
- else
- return inserted_;
-}
-
-/*JODO CONT
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
- template <class Combiner>
-std::pair<typename map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::iterator, bool>
- map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
- ::add(iterator prior_, const domain_type& val, const codomain_type& co_val)
-{
- if(Traits::absorbs_neutrons && co_val == Combiner::neutron())
- return std::pair<iterator,bool>(prior_, false);
+ Combiner()(inserted_->second, val.second);
 
- iterator inserted_ = base_insert(prior_, value_type(val.first, Combiner::neutron()));
     if(Traits::absorbs_neutrons && inserted_->second == Combiner::neutron())
     {
         erase(inserted_);
- return prior_;
+ return end();
     }
     else
- {
- Combiner()(inserted_->second, val.second);
         return inserted_;
- }
 }
-*/
+
 
 //==============================================================================
 //= Subtraction

Modified: sandbox/itl/boost/itl/map_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/map_algo.hpp (original)
+++ sandbox/itl/boost/itl/map_algo.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -184,250 +184,6 @@
     return left_ == left.end() && right_ == right.end();
 }
 
-/*CL
-//------------------------------------------------------------------------------
-template<class LeftT, class RightT>
-class subset_comparer
-{
-public:
- typedef typename LeftT::const_iterator LeftIterT;
- typedef typename RightT::const_iterator RightIterT;
-
- subset_comparer(const LeftT& left,
- const RightT& right,
- const LeftIterT& left_end,
- const RightIterT& right_end)
- : _left(left), _right(right),
- _left_end(left_end), _right_end(right_end),
- _compare_codomain(false), _result(equal)
- {}
-
- enum{nextboth, nextleft, nextright, stop};
-
- enum
- {
- unrelated = inclusion::unrelated,
- subset = inclusion::subset, // left is_subset_of right
- superset = inclusion::superset, // left is_superset_of right
- equal = inclusion::equal // equal = subset | superset
- };
-
- void set_compare_codomain(bool truth=true)
- { _compare_codomain = truth; }
-
- bool compare_codomain()const { return _compare_codomain; }
-
- int result()const{ return _result; }
-
-
- int co_compare(LeftIterT& left, RightIterT& right)
- {
- using namespace boost::mpl;
-
- return
- if_<
- bool_<is_concept_equivalent<is_interval_map,LeftT,RightT>::value>,
- map_codomain_compare<LeftT,RightT>,
- empty_codomain_compare<LeftT,RightT>
- >
- ::type::apply(left,right);
- }
-
- int restrict_result(int state) { return _result &= state; }
-
- int proceed(LeftIterT& left, RightIterT& right)
- {
- if(LeftT::key_value(left).upper_less(RightT::key_value(right)))
- { // left ..)
- // right .....)
- _prior_left = left;
- ++left;
- return nextleft;
- }
- else if(RightT::key_value(right).upper_less(LeftT::key_value(left)))
- { // left .....)
- // right ..)
- _prior_right = right;
- ++right;
- return nextright;
- }
- else//LeftT::key_value(left).upper_equal(RightT::key_value(right))
- { // left ..)
- // right ..)
- ++left;
- ++right;
- return nextboth;
- }
- }
-
- int next_both(LeftIterT& left, RightIterT& right)
- {
- if(left == _left_end && right == _right_end)
- return stop;
- else if(left == _left_end)
- { // left: ....end left could be subset
- // right:....[..
- restrict_result(subset);
- return stop;
- }
- else if(right == _right_end)
- { // left: ....[.. left could be superset
- // right:....end
- restrict_result(superset);
- return stop;
- }
- else if(LeftT::key_value(left).exclusive_less(RightT::key_value(right)))
- { // left: [..) . . .[---) left could be superset
- // right: [..).... if [---) exists
- restrict_result(superset);
- if(unrelated == _result)
- return stop;
- else
- {
- LeftIterT joint_ = _left.lower_bound(RightT::key_value(right));
- if(joint_ == _left.end())
- {
- _result = unrelated;
- return stop;
- }
- else
- {
- left = joint_;
- return nextboth;
- }
- }
- }
- else if(RightT::key_value(right).exclusive_less(LeftT::key_value(left)))
- { // left: [.. left could be subset
- // right:....) . . .[---) if [---) exists
- restrict_result(subset);
- if(unrelated == _result)
- return stop;
- else
- {
- RightIterT joint_ = _right.lower_bound(LeftT::key_value(left));
- if(joint_ == _right.end())
- {
- _result = unrelated;
- return stop;
- }
- else
- {
- right = joint_;
- return nextboth;
- }
- }
- }
-
- // left and right have intervals with nonempty intersection:
- if(compare_codomain())
- if(unrelated == restrict_result(co_compare(left,right)))
- return stop;
-
- // examine left borders only. Right borders are checked in proceed
- if(LeftT::key_value(left).lower_less(RightT::key_value(right)))
- { // left: ....[... left could be superset
- // right:.... [..
- if(unrelated == restrict_result(superset))
- return stop;
- }
- else if(RightT::key_value(right).lower_less(LeftT::key_value(left)))
- { // left: .... [.. left can be subset
- // right:....[...
- if(unrelated == restrict_result(subset))
- return stop;
- }
- //else LeftT::key_value(right).lower_equal(RightT::key_value(left))
- // left: ....[.. both can be equal
- // right:....[..
- // nothing to do: proceed
-
- return proceed(left, right);
- }
-
- int next_left(LeftIterT& left, RightIterT& right)
- {
- if(left == _left_end)
- { // left: ..)end left could be subset
- // right:......)
- restrict_result(subset);
- return stop;
- }
- else if(!LeftT::key_value(_prior_left).touches(LeftT::key_value(left)))
- { // left: ..) [..
- // right:.........)
- if(RightT::key_value(right).lower_less(LeftT::key_value(left)))
- { // ..) [.. left could be subset
- // ..........)
- if(unrelated == restrict_result(subset))
- return stop;
- }
- //else ..) [...
- // [..
- if(compare_codomain() && !LeftT::key_value(left).is_disjoint(RightT::key_value(right)) )
- if(unrelated == restrict_result(co_compare(left,right)))
- return stop;
- }
- else
- { // left: ..)[.. left could be subset
- // right:.......)
- if(compare_codomain() && !LeftT::key_value(left).is_disjoint(RightT::key_value(right)) )
- if(unrelated == restrict_result(co_compare(left,right)))
- return stop;
- }
-
- return proceed(left, right);
- }
-
-
- int next_right(LeftIterT& left, RightIterT& right)
- {
- if(right == _right_end)
- { // left: ......) left could be superset
- // right:..)end
- restrict_result(superset);
- return stop;
- }
- else if(!RightT::key_value(_prior_right).touches(RightT::key_value(right)))
- { // left: .........)
- // right:..) [..
- if(LeftT::key_value(left).lower_less(RightT::key_value(right)))
- { // [....) left could be superset
- // ..) [..
- if(unrelated == restrict_result(superset))
- return stop;
- }
- //else [....)
- // ..) [..
- if(compare_codomain() && !LeftT::key_value(left).is_disjoint(RightT::key_value(right)) )
- if(unrelated == restrict_result(co_compare(left,right)))
- return stop;
- }
- else
- {
- if(compare_codomain() && !LeftT::key_value(left).is_disjoint(RightT::key_value(right)) )
- if(unrelated == restrict_result(co_compare(left,right)))
- return stop;
- }
-
- return proceed(left, right);
- }
-
-private:
- const LeftT& _left;
- const RightT& _right;
- LeftIterT _left_end;
- RightIterT _right_end;
- bool _compare_codomain;
- LeftIterT _prior_left;
- RightIterT _prior_right;
- int _result;
-};
-
-
-
-*/
-
 } // namespace Map
 }} // namespace boost itl
 

Modified: sandbox/itl/boost/itl/type_traits/to_string.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/to_string.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/to_string.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -28,7 +28,7 @@
 struct to_string
 {
     /** Converts all values of types to std::string that implement an operator << */
- static const std::string apply(const Type& value)
+ static std::string apply(const Type& value)
     {
         std::stringstream repr;
         repr << value;

Modified: sandbox/itl/boost/itl/type_traits/type_to_string.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/type_to_string.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/type_to_string.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -28,14 +28,21 @@
 
 
     //--------------------------------------------------------------------------
- template<>
- inline std::string type_to_string<int>::apply() { return "int"; }
- template<>
- inline std::string type_to_string<unsigned int>::apply() { return "int+"; }
- template<>
- inline std::string type_to_string<double>::apply() { return "dbl"; }
- template<>
- inline std::string type_to_string<std::string>::apply() { return "string"; }
+ template<>inline std::string type_to_string<char>::apply() { return "char"; }
+ template<>inline std::string type_to_string<short>::apply(){ return "short"; }
+ template<>inline std::string type_to_string<int>::apply() { return "int"; }
+ template<>inline std::string type_to_string<long>::apply() { return "long"; }
+ template<>inline std::string type_to_string<long long>::apply(){ return "Long"; }
+
+ template<>inline std::string type_to_string<unsigned char>::apply(){ return "char+"; }
+ template<>inline std::string type_to_string<unsigned short>::apply(){ return "short+"; }
+ template<>inline std::string type_to_string<unsigned int>::apply() { return "int+"; }
+ template<>inline std::string type_to_string<unsigned long>::apply() { return "long+"; }
+ template<>inline std::string type_to_string<unsigned long long>::apply(){ return "Long+"; }
+
+ template<>inline std::string type_to_string<float>::apply() { return "flt"; }
+ template<>inline std::string type_to_string<double>::apply() { return "dbl"; }
+ template<>inline std::string type_to_string<std::string>::apply() { return "string"; }
 
     //-------------------------------------------------------------------------
     template<template<class> class Templ>

Added: sandbox/itl/boost/itl_xt/bits_gentor.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/itl_xt/bits_gentor.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -0,0 +1,45 @@
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2009-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENCE.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
++-----------------------------------------------------------------------------*/
+#ifndef BOOST_ITL_XT_BITS_GENTOR_HPP_JOFA_091009
+#define BOOST_ITL_XT_BITS_GENTOR_HPP_JOFA_091009
+
+#include <boost/itl/type_traits/to_string.hpp>
+#include <boost/itl_xt/gentorit.hpp>
+#include <boost/itl_xt/numbergentor.hpp>
+#include <boost/validate/type/bits.hpp>
+
+namespace boost{namespace itl
+{
+
+
+template <class NaturalT>
+class bits_gentor: public RandomGentorAT<itl::bits<NaturalT> >
+{
+public:
+
+ typedef itl::bits<NaturalT> bits_type;
+
+ void some(bits_type& value)
+ {
+ value = bits_type(_natural_gentor(_value_range));
+ };
+
+ void set_range(const itl::interval<NaturalT>& range)
+ { _value_range = range; }
+
+private:
+ NumberGentorT<NaturalT> _natural_gentor;
+ itl::interval<NaturalT> _value_range;
+};
+
+
+}} // namespace itl boost
+
+#endif
+
+

Modified: sandbox/itl/boost/itl_xt/list.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/list.hpp (original)
+++ sandbox/itl/boost/itl_xt/list.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -322,7 +322,6 @@
             else
             {
                 iterator fromThis_ = cur_; fromThis_++;
- DataT dbg_from = *fromThis_;
                 iterator perm_ = first_common_element(fromThis_, end(), perm.begin(), perm.end());
                 if(perm_ == perm.end())
                     perm.push_front(cand);

Modified: sandbox/itl/boost/itl_xt/seqgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/seqgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/seqgentor.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -62,7 +62,7 @@
     void setRangeOfSampleSize(int lwb, int upb)
     { m_sampleSizeRange = interval<int>::rightopen(lwb,upb); }
     void setRangeOfSampleSize(const interval<int>& szRange)
- { BOOST_ASSERT(szRange.is_rightopen()); m_sampleSizeRange = szRange; }
+ { BOOST_ASSERT(szRange.is(itl::right_open)); m_sampleSizeRange = szRange; }
 
     void setUnique(bool truth) { m_unique = truth; }
 

Modified: sandbox/itl/boost/itl_xt/std/pair.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/std/pair.hpp (original)
+++ sandbox/itl/boost/itl_xt/std/pair.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -22,7 +22,6 @@
 std::basic_ostream<CharType, CharTraits>& operator <<
   (std::basic_ostream<CharType, CharTraits>& stream, const std::pair<FirstT,SecondT>& object)
 {
- typedef std::pair<FirstT,SecondT> ObjectT;
     return stream << "(" << object.first << "," << object.second << ")";
 }
 

Added: sandbox/itl/boost/itl_xt/std/pair_gentor.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/itl_xt/std/pair_gentor.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -0,0 +1,57 @@
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2009-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENCE.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
++-----------------------------------------------------------------------------*/
+#ifndef BOOST_ITL_XT_STD_PAIR_GENTOR_HPP_JOFA_091009
+#define BOOST_ITL_XT_STD_PAIR_GENTOR_HPP_JOFA_091009
+
+#include <boost/itl/type_traits/to_string.hpp>
+#include <boost/itl_xt/std/pair.hpp>
+#include <boost/itl_xt/gentorit.hpp>
+
+namespace boost{namespace itl
+{
+
+
+template <class FirstT, class SecondT>
+class std_pair_gentor: public RandomGentorAT<std::pair<FirstT,SecondT> >
+{
+public:
+
+ typedef std::pair<FirstT,SecondT> pair_type;
+
+ std_pair_gentor(): _first_gentor(NULL), _second_gentor(NULL) {}
+ ~std_pair_gentor() { delete _first_gentor; delete _second_gentor; }
+
+ void set_first_gentor(RandomGentorAT<FirstT>* gentor)
+ {
+ delete _first_gentor;
+ _first_gentor = gentor;
+ }
+
+ void set_second_gentor(RandomGentorAT<SecondT>* gentor)
+ {
+ delete _second_gentor;
+ _second_gentor = gentor;
+ }
+
+ void some(pair_type& value)
+ {
+ _first_gentor->some(value.first);
+ _second_gentor->some(value.second);
+ };
+
+private:
+ RandomGentorAT<FirstT>* _first_gentor;
+ RandomGentorAT<SecondT>* _second_gentor;
+};
+
+
+}} // namespace itl boost
+
+#endif
+
+

Added: sandbox/itl/boost/validate/driver/bit_collector_driver.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/validate/driver/bit_collector_driver.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -0,0 +1,145 @@
+/*-----------------------------------------------------------------------------+
+A Law Based Test Automaton 'LaBatea'
+Author: Joachim Faulhaber
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENCE.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
++-----------------------------------------------------------------------------*/
+#ifndef BOOST_VALIDATE_DRIVER_BIT_COLLECTOR_DRIVER_HPP_JOFA_091009
+#define BOOST_VALIDATE_DRIVER_BIT_COLLECTOR_DRIVER_HPP_JOFA_091009
+
+#include <iostream>
+#include <stdio.h>
+#include <time.h>
+#include <boost/validate/type/bits.hpp>
+#include <boost/validate/validater/collector_validater.hpp>
+#include <boost/validate/driver/itl_driver.hpp>
+#include <boost/validate/utility.hpp>
+
+namespace boost{namespace itl
+{
+
+ class bit_collector_driver : public itl_driver
+ {
+ public:
+ bit_collector_driver() { setProfile(); }
+
+ void setProfile()
+ {
+ setValid(true);
+ _rootChoice.setSize(RootType::Types_size);
+ _rootChoice.setMaxWeights(100);
+ _rootChoice[RootType::itl_set] = 0;
+ _rootChoice[RootType::interval_set] = 0;
+ _rootChoice[RootType::separate_interval_set] = 0;
+ _rootChoice[RootType::split_interval_set] = 0;
+ _rootChoice[RootType::itl_map] = 33;
+ _rootChoice[RootType::interval_map] = 33;
+ _rootChoice[RootType::split_interval_map] = 34;
+ setRootTypeNames();
+ _rootChoice.init();
+
+ _domainChoice.setSize(DomainType::DomainTypes_size);
+ _domainChoice.setMaxWeights(100);
+ _domainChoice[DomainType::Int] = 100;
+ _domainChoice[DomainType::Double] = 0;
+ setDomainTypeNames();
+ _domainChoice.init();
+
+ _codomainChoice.setSize(CodomainType::CodomainTypes_size);
+ _codomainChoice.setMaxWeights(100);
+ _codomainChoice[CodomainType::Int] = 100;
+ _codomainChoice[CodomainType::Double] = 0;
+ _codomainChoice[CodomainType::set_int] = 0;
+ setCodomainTypeNames();
+ _codomainChoice.init();
+
+ _neutronizerChoice.setSize(NeutronHandlerType::NeutronHandlerTypes_size);
+ _neutronizerChoice.setMaxWeights(100);
+ _neutronizerChoice[NeutronHandlerType::partial_absorber] = 50;
+ _neutronizerChoice[NeutronHandlerType::partial_enricher] = 50;
+ _neutronizerChoice[NeutronHandlerType::total_absorber] = 0;
+ _neutronizerChoice[NeutronHandlerType::total_enricher] = 0;
+ setNeutronHandlerTypeNames();
+ _neutronizerChoice.init();
+
+ if(!_rootChoice.is_consistent())
+ {
+ setValid(false);
+ std::cout << _rootChoice.inconsitencyMessage("bit_collector_driver::setProfile()") << std::endl;
+ }
+
+ if(!_domainChoice.is_consistent())
+ {
+ setValid(false);
+ std::cout << _domainChoice.inconsitencyMessage("bit_collector_driver::setProfile()") << std::endl;
+ }
+
+ if(!_codomainChoice.is_consistent())
+ {
+ setValid(false);
+ std::cout << _codomainChoice.inconsitencyMessage("bit_collector_driver::setProfile()") << std::endl;
+ }
+
+ if(!_neutronizerChoice.is_consistent())
+ {
+ setValid(false);
+ std::cout << _neutronizerChoice.inconsitencyMessage("bit_collector_driver::setProfile()") << std::endl;
+ }
+
+ }
+
+
+ algebra_validater* chooseValidater()
+ {
+ int rootChoice = _rootChoice.some();
+ int neutronizerChoice = _neutronizerChoice.some();
+
+ switch(rootChoice)
+ {
+ ////-----------------------------------------------------------------
+ case RootType::itl_map: {
+ switch(neutronizerChoice) {
+ case NeutronHandlerType::partial_absorber:
+ return new collector_validater< itl::map<int, itl::bits8, partial_absorber, std::less, inplace_bit_add, inplace_bit_and> >;
+ case NeutronHandlerType::partial_enricher:
+ return new collector_validater< itl::map<int, itl::bits32, partial_enricher, std::less, inplace_bit_add, inplace_bit_and> >;
+ default: return choiceError(ITL_LOCATION("\nRootType::itl_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
+ }//switch neutronizerChoice
+ }//case itl_map
+ ////-----------------------------------------------------------------
+ case RootType::interval_map: {
+ switch(neutronizerChoice) {
+ case NeutronHandlerType::partial_absorber:
+ return new collector_validater<interval_map<int, itl::bits64, partial_absorber, std::less, inplace_bit_add, inplace_bit_and> >;
+ case NeutronHandlerType::partial_enricher:
+ return new collector_validater<interval_map<int, itl::bits16, partial_enricher, std::less, inplace_bit_add, inplace_bit_and> >;
+ default: return choiceError(ITL_LOCATION("\nRootType::interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
+ }//switch neutronizerChoice
+ }//case interval_map
+ ////-----------------------------------------------------------------
+ case RootType::split_interval_map: {
+ switch(neutronizerChoice) {
+ case NeutronHandlerType::partial_absorber:
+ return new collector_validater<split_interval_map<int, itl::bits32, partial_absorber, std::less, inplace_bit_add, inplace_bit_and> >;
+ case NeutronHandlerType::partial_enricher:
+ return new collector_validater<split_interval_map<double, itl::bits8, partial_enricher, std::less, inplace_bit_add, inplace_bit_and> >;
+ default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
+ }//switch neutronizerChoice
+ }//case split_interval_map
+ //-----------------------------------------------------------------
+
+ default: return choiceError(ITL_LOCATION("rootChoice:\n"), rootChoice, _rootChoice);
+ } //switch()
+
+ return NULL; //just to please the compiler ;)
+ }
+
+ };
+
+
+}} // namespace itl boost
+
+#endif // BOOST_VALIDATE_DRIVER_BIT_COLLECTOR_DRIVER_HPP_JOFA_091009

Modified: sandbox/itl/boost/validate/driver/collector_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/collector_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/collector_driver.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -7,7 +7,8 @@
       (See accompanying file LICENCE.txt or copy at
            http://www.boost.org/LICENSE_1_0.txt)
 +-----------------------------------------------------------------------------*/
-#pragma once
+#ifndef BOOST_VALIDATE_DRIVER_COLLECTOR_DRIVER_HPP_JOFA_091009
+#define BOOST_VALIDATE_DRIVER_COLLECTOR_DRIVER_HPP_JOFA_091009
 
 #include <iostream>
 #include <stdio.h>
@@ -24,7 +25,6 @@
     public:
         collector_driver() { setProfile(); }
 
-
         void setProfile()
         {
             setValid(true);
@@ -140,3 +140,4 @@
 
 }} // namespace itl boost
 
+#endif // BOOST_VALIDATE_DRIVER_COLLECTOR_DRIVER_HPP_JOFA_091009

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 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -36,9 +36,9 @@
             _rootChoice[RootType::interval_set] = 0;
             _rootChoice[RootType::separate_interval_set] = 0;
             _rootChoice[RootType::split_interval_set] = 0;
- _rootChoice[RootType::itl_map] = 0;
- _rootChoice[RootType::interval_map] = 50;
- _rootChoice[RootType::split_interval_map] = 50;
+ _rootChoice[RootType::itl_map] = 33;
+ _rootChoice[RootType::interval_map] = 33;
+ _rootChoice[RootType::split_interval_map] = 34;
             setRootTypeNames();
             _rootChoice.init();
 
@@ -92,26 +92,23 @@
 
         }
 
-
         algebra_validater* chooseValidater()
         {
             int rootChoice = _rootChoice.some();
- //int domainChoice = _domainChoice.some(); // not used
- int codomainChoice = _codomainChoice.some();
             int neutronizerChoice = _neutronizerChoice.some();
 
             switch(rootChoice)
             {
             //-----------------------------------------------------------------
- //case RootType::itl_map: {
- // switch(neutronizerChoice) {
- // case NeutronHandlerType::partial_absorber: return new function_equality_validater<itl::list<std::pair<double,int> >, itl::map<int, int,partial_absorber> >;
- // case NeutronHandlerType::partial_enricher: return new function_equality_validater<itl::list<std::pair<double,int> >, itl::map<int, int,partial_enricher> >;
- // case NeutronHandlerType::total_absorber: return new function_equality_validater<itl::list<std::pair<int, int> >, itl::map<double,int,total_absorber > >;
- // case NeutronHandlerType::total_enricher: return new function_equality_validater<itl::list<std::pair<int, int> >, itl::map<double,int,total_enricher > >;
- // default: return choiceError(ITL_LOCATION("\nRootType::itl_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- // }//switch neutronizerChoice
- //}//case itl_map
+ case RootType::itl_map: {
+ switch(neutronizerChoice) {
+ case NeutronHandlerType::partial_absorber: return new function_equality_validater<itl::list<std::pair<int,int> >, itl::map<int,int,partial_absorber> >;
+ case NeutronHandlerType::partial_enricher: return new function_equality_validater<itl::list<std::pair<int,int> >, itl::map<int,int,partial_enricher> >;
+ case NeutronHandlerType::total_absorber: return new function_equality_validater<itl::list<std::pair<int,int> >, itl::map<int,int,total_absorber > >;
+ case NeutronHandlerType::total_enricher: return new function_equality_validater<itl::list<std::pair<int,int> >, itl::map<int,int,total_enricher > >;
+ default: return choiceError(ITL_LOCATION("\nRootType::itl_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
+ }//switch neutronizerChoice
+ }//case itl_map
             //-----------------------------------------------------------------
             case RootType::interval_map: {
                 switch(neutronizerChoice) {

Modified: sandbox/itl/boost/validate/gentor/randomgentor.hpp
==============================================================================
--- sandbox/itl/boost/validate/gentor/randomgentor.hpp (original)
+++ sandbox/itl/boost/validate/gentor/randomgentor.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -10,12 +10,15 @@
 #pragma once
 
 
+#include <limits>
 #include <boost/itl/detail/notate.hpp>
 #include <boost/itl_xt/numbergentor.hpp>
+#include <boost/itl_xt/bits_gentor.hpp>
 #include <boost/itl_xt/setgentor.hpp>
 #include <boost/itl_xt/mapgentor.hpp>
 #include <boost/itl_xt/seqgentor.hpp>
 #include <boost/itl_xt/itvgentor.hpp>
+#include <boost/itl_xt/std/pair_gentor.hpp>
 #include <boost/itl_xt/map_segment_gentor.hpp>
 
 #ifdef LAW_BASED_TEST_BOOST_POLYGON
@@ -44,10 +47,20 @@
     template <> class RandomGentor<double> : public NumberGentorT<double> {};
 
     // -------------------------------------------------------------------------
+ template <class NaturalT>
+ class RandomGentor<itl::bits<NaturalT> > :
+ public bits_gentor<itl::bits<NaturalT> > {};
+
+ // -------------------------------------------------------------------------
     template <class DomainT>
     class RandomGentor<itl::interval<DomainT> > :
         public ItvGentorT<DomainT> {};
 
+ // -------------------------------------------------------------------------
+ template <class DomainT, class CodomainT>
+ class RandomGentor< std::pair<DomainT,CodomainT> > :
+ public std_pair_gentor<DomainT,CodomainT> {};
+
 #ifdef LAW_BASED_TEST_BOOST_POLYGON
     // -------------------------------------------------------------------------
     template <class DomainT>
@@ -72,6 +85,10 @@
     class RandomGentor<itl::list<std::pair<itl::interval<DomainT>, CodomainT> > > :
         public SeqGentorT<itl::list<std::pair<itl::interval<DomainT>, CodomainT> > > {};
 
+ template <class DomainT, class CodomainT>
+ class RandomGentor<itl::list<std::pair<DomainT,CodomainT> > > :
+ public SeqGentorT<itl::list<std::pair<DomainT,CodomainT> > > {};
+
     // ----- sets --------------------------------------------------------------
     //template <class DomainT, template<class>class Set>
     //class RandomGentor<Set<DomainT> > :
@@ -105,6 +122,11 @@
     class RandomGentor<itl::map<DomainT,itl::set<int>,Neutronizer> > :
         public MapGentorT<itl::map<DomainT,itl::set<int>,Neutronizer> > {};
 
+ template <class DomainT, class BitsT, class Neutronizer,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section>
+ class RandomGentor<itl::map<DomainT,itl::bits<BitsT>,Neutronizer,Compare,Combine,Section> > :
+ public MapGentorT<itl::map<DomainT,itl::bits<BitsT>,Neutronizer,Compare,Combine,Section> > {};
+
     template <class DomainT, class CodomainT, class Neutronizer>
     class RandomGentor<itl::map<DomainT,CodomainT,Neutronizer> > :
         public MapGentorT<itl::map<DomainT,CodomainT,Neutronizer> > {};
@@ -128,6 +150,24 @@
     class RandomGentor<split_interval_map<DomainT,CodomainT,Neutronizer> > :
         public MapGentorT<split_interval_map<DomainT,CodomainT,Neutronizer> > {};
 
+ // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
+ template <class NumericDomainT, class BitsT, class Neutronizer,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section>
+ class RandomGentor<split_interval_map<NumericDomainT,itl::bits<BitsT>,Neutronizer,Compare,Combine,Section> > :
+ public MapGentorT<split_interval_map<NumericDomainT,itl::bits<BitsT>,Neutronizer,Compare,Combine,Section> > {};
+
+ template <class NumericDomainT, class BitsT, class Neutronizer,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section>
+ class RandomGentor<interval_map<NumericDomainT,itl::bits<BitsT>,Neutronizer,Compare,Combine,Section> > :
+ public MapGentorT<interval_map<NumericDomainT,itl::bits<BitsT>,Neutronizer,Compare,Combine,Section> > {};
+
+ //NOTE: All trials to reduce code replication for RandomGentor
+ // and Calibrater by introducing a fancy
+ // template template IntervalMap shipwrecked due to compilers
+ // disability to resolve the resulting instantiations. Compilers
+ // always see ambiguities where there seems to be a resolution.
+
 
     // ------------------------------------------------------------------------
     // class template SomeValue:
@@ -189,6 +229,16 @@
         }
     };
 
+ template <class BitsT>
+ struct Calibrater<itl::bits<BitsT>, RandomGentor>
+ {
+ 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>::rightopen(0, sizeof BitsT));
+ }
+ };
+
 
     template <>
     struct Calibrater<itl::interval<int>, RandomGentor>
@@ -256,6 +306,12 @@
     // lists
     //--------------------------------------------------------------------------
     template <>
+ struct Calibrater<std::pair<int,int>, RandomGentor>
+ {
+ static void apply(RandomGentor< std::pair<int,int> >& gentor){}
+ };
+
+ template <>
     struct Calibrater<std::pair<itl::interval<int>, int>, RandomGentor>
     {
         static void apply(RandomGentor< std::pair<itl::interval<int>, int> >& gentor){}
@@ -285,6 +341,23 @@
     };
 
     template <>
+ struct Calibrater<itl::list<std::pair<int, int> >, RandomGentor>
+ {
+ static void apply(RandomGentor< itl::list< std::pair<int, int> > >& gentor)
+ {
+ gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
+ std_pair_gentor<int,int>* pair_gentor = new std_pair_gentor<int,int>;
+ NumberGentorT<int>* int_gentor_1 = new NumberGentorT<int>;
+ NumberGentorT<int>* int_gentor_2 = new NumberGentorT<int>;
+ int_gentor_1->setRange(GentorProfileSgl::it()->range_int());
+ int_gentor_2->setRange(GentorProfileSgl::it()->range_int());
+ pair_gentor->set_first_gentor(int_gentor_1);
+ pair_gentor->set_second_gentor(int_gentor_2);
+ gentor.setDomainGentor(pair_gentor);
+ }
+ };
+
+ template <>
     struct Calibrater<itl::list<std::pair<itl::interval<int>, int> >, RandomGentor>
     {
         static void apply(RandomGentor< itl::list<std::pair<itl::interval<int>, int> > >& gentor)
@@ -338,7 +411,7 @@
             ItvGentorT<int>* itvGentor = new ItvGentorT<int>;
             interval<int> valRange = GentorProfileSgl::it()->range_interval_int();
             itvGentor->setValueRange(valRange.lower(), valRange.upper());
- itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength()); //JODO
+ itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
             gentor.setDomainGentor(itvGentor);
         }
     };
@@ -366,7 +439,7 @@
             ItvGentorT<int>* itvGentor = new ItvGentorT<int>;
             interval<int> valRange = GentorProfileSgl::it()->range_interval_int();
             itvGentor->setValueRange(valRange.lower(), valRange.upper());
- itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength()); //JODO
+ itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
             gentor.setDomainGentor(itvGentor);
         }
     };
@@ -383,7 +456,7 @@
             ItvGentorT<double>* itvGentor = new ItvGentorT<double>;
             interval<double> valRange = GentorProfileSgl::it()->range_interval_double();
             itvGentor->setValueRange(valRange.lower(), valRange.upper());
- itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength()); //JODO
+ itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
             gentor.setDomainGentor(itvGentor);
         }
     };
@@ -394,9 +467,6 @@
         static void apply(RandomGentor<split_interval_set<int> >& gentor)
         {
             // Set the range within which the sizes of the generated object varies.
- // interval<int> range = rightOpenInterval<int>(0,10); //JODO: From SysCalibrater
- //JODO gentor.calibrate(profile);
-
             gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
 
             // If it is a container: (Create and) Pass the generator(s) for their contents
@@ -404,7 +474,7 @@
             ItvGentorT<int>* itvGentor = new ItvGentorT<int>;
             interval<int> valRange = GentorProfileSgl::it()->range_interval_int();
             itvGentor->setValueRange(valRange.lower(), valRange.upper());
- itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength()); //JODO
+ itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
             gentor.setDomainGentor(itvGentor);
         }
     };
@@ -421,7 +491,7 @@
             ItvGentorT<double>* itvGentor = new ItvGentorT<double>;
             interval<double> valRange = GentorProfileSgl::it()->range_interval_double();
             itvGentor->setValueRange(valRange.lower(), valRange.upper());
- itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength()); //JODO
+ itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
             gentor.setDomainGentor(itvGentor);
         }
     };
@@ -455,9 +525,6 @@
         static void apply(RandomGentor<itl::map<NumericDomainT,itl::set<int>,Neutronizer> >& gentor)
         {
             // Set the range within which the sizes of the generated object varies.
- // interval<int> range = rightOpenInterval<int>(0,10); //JODO: From SysCalibrater
- //JODO gentor.calibrate(profile);
-
             gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
 
             // If it is a container: (Create and) Pass the generator(s) for their contents
@@ -495,6 +562,27 @@
         }
     };
 
+ template <typename NumericDomainT, typename BitsT, class Neutronizer,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section>
+ struct Calibrater<itl::map<NumericDomainT,itl::bits<BitsT>,Neutronizer,
+ Compare,Combine,Section>, RandomGentor>
+ {
+ static void apply(RandomGentor<itl::map<NumericDomainT,itl::bits<BitsT>,Neutronizer,
+ Compare,Combine,Section> >& gentor)
+ {
+ gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
+
+ // If it is a container: (Create and) Pass the generator(s) for their contents
+ // NumberGentorT<int> intGentor;
+ 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, (numeric_limits<BitsT>::max)()));
+ gentor.setDomainGentor(domainGentor);
+ gentor.setCodomainGentor(codomainGentor);
+ }
+ };
+
 
     //----------------------------------------------------------------------------
     // itl::interval_map<DomainT,CodomainT,Neutronizer>
@@ -505,9 +593,6 @@
         static void apply(RandomGentor<interval_map<NumericDomainT,itl::set<int>,Neutronizer> >& gentor)
         {
             // Set the range within which the sizes of the generated object varies.
- // interval<int> range = rightOpenInterval<int>(0,10); //JODO: From SysCalibrater
- //JODO gentor.calibrate(profile);
-
             gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
 
             // If it is a container: (Create and) Pass the generator(s) for their contents
@@ -515,7 +600,7 @@
             ItvGentorT<NumericDomainT>* itvGentor = new ItvGentorT<NumericDomainT>;
             interval<NumericDomainT> valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
             itvGentor->setValueRange(valRange.lower(), valRange.upper());
- itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength()); //JODO
+ itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
 
             SetGentorT<itl::set<int> >* codomainGentor = new SetGentorT<itl::set<int> >;
             NumberGentorT<int>* elementGentor = new NumberGentorT<int>;
@@ -535,9 +620,6 @@
         static void apply(RandomGentor<interval_map<NumericDomainT,NumericCodomainT,Neutronizer> >& gentor)
         {
             // Set the range within which the sizes of the generated object varies.
- // interval<int> range = rightOpenInterval<int>(0,10); //JODO: From SysCalibrater
- //JODO gentor.calibrate(profile);
-
             gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
 
             // If it is a container: (Create and) Pass the generator(s) for their contents
@@ -545,7 +627,7 @@
             ItvGentorT<NumericDomainT>* itvGentor = new ItvGentorT<NumericDomainT>;
             interval<NumericDomainT> valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
             itvGentor->setValueRange(valRange.lower(), valRange.upper());
- itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength()); //JODO
+ itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
 
             NumberGentorT<NumericCodomainT>* codomainGentor = new NumberGentorT<NumericCodomainT>;
             codomainGentor->setRange(GentorProfileSgl_numeric_range<NumericCodomainT>::get());
@@ -584,15 +666,13 @@
         }
     };
 
- template <typename NumericDomainT, typename NumericCodomainT, class Neutronizer>
- struct Calibrater<split_interval_map<NumericDomainT,NumericCodomainT,Neutronizer>, RandomGentor>
+ template <typename NumericDomainT, typename NumericCodomainT, class Neutronizer,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section>
+ struct Calibrater<split_interval_map<NumericDomainT,NumericCodomainT,Neutronizer,Compare,Combine,Section>, RandomGentor>
     {
- static void apply(RandomGentor<split_interval_map<NumericDomainT,NumericCodomainT,Neutronizer> >& gentor)
+ static void apply(RandomGentor<split_interval_map<NumericDomainT,NumericCodomainT,Neutronizer,Compare,Combine,Section> >& gentor)
         {
             // Set the range within which the sizes of the generated object varies.
- // interval<int> range = rightOpenInterval<int>(0,10); //JODO: From SysCalibrater
- //JODO gentor.calibrate(profile);
-
             gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
 
             // If it is a container: (Create and) Pass the generator(s) for their contents
@@ -600,7 +680,7 @@
             ItvGentorT<NumericDomainT>* itvGentor = new ItvGentorT<NumericDomainT>;
             interval<NumericDomainT> valRange = GentorProfileSgl_numeric_range<NumericDomainT>::get();
             itvGentor->setValueRange(valRange.lower(), valRange.upper());
- itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength()); //JODO
+ itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
 
             NumberGentorT<NumericCodomainT>* codomainGentor = new NumberGentorT<NumericCodomainT>;
             codomainGentor->setRange(GentorProfileSgl_numeric_range<NumericCodomainT>::get());
@@ -609,6 +689,58 @@
             gentor.setCodomainGentor(codomainGentor);
         }
     };
+
+
+ template <typename NumericDomainT, typename BitsT, class Neutronizer,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section>
+ struct Calibrater<interval_map<NumericDomainT,itl::bits<BitsT>,
+ Neutronizer,Compare,Combine,Section>, RandomGentor>
+ {
+ static void apply(RandomGentor<interval_map<NumericDomainT,itl::bits<BitsT>,
+ Neutronizer,Compare,Combine,Section> >& gentor)
+ {
+ gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
+
+ // If it is a container: (Create and) Pass the generator(s) for their contents
+ // NumberGentorT<int> intGentor;
+ ItvGentorT<NumericDomainT>* itvGentor = new ItvGentorT<NumericDomainT>;
+ interval<NumericDomainT> 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, (numeric_limits<BitsT>::max)()));
+
+ gentor.setDomainGentor(itvGentor);
+ gentor.setCodomainGentor(codomainGentor);
+ }
+ };
+
+ template <typename NumericDomainT, typename BitsT, class Neutronizer,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section>
+ struct Calibrater<split_interval_map<NumericDomainT,itl::bits<BitsT>,
+ Neutronizer,Compare,Combine,Section>, RandomGentor>
+ {
+ static void apply(RandomGentor<split_interval_map<NumericDomainT,itl::bits<BitsT>,
+ Neutronizer,Compare,Combine,Section> >& gentor)
+ {
+ gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
+
+ // If it is a container: (Create and) Pass the generator(s) for their contents
+ // NumberGentorT<int> intGentor;
+ ItvGentorT<NumericDomainT>* itvGentor = new ItvGentorT<NumericDomainT>;
+ interval<NumericDomainT> 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, (numeric_limits<BitsT>::max)()));
+
+ gentor.setDomainGentor(itvGentor);
+ gentor.setCodomainGentor(codomainGentor);
+ }
+ };
     // ---------------------------------------------------------------------------
 
+
 }} // namespace itl boost

Modified: sandbox/itl/boost/validate/gentor/rangegentor.hpp
==============================================================================
--- sandbox/itl/boost/validate/gentor/rangegentor.hpp (original)
+++ sandbox/itl/boost/validate/gentor/rangegentor.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -37,8 +37,6 @@
 
 namespace boost{namespace itl
 {
- //JODO: RangeGentor is similat to ItvGentorT. RangeGentor might be replaced by ItvGentorT
- // with some modifications applied to ItvGentorT.
 
     template <class Type>
     class RangeGentor: public RandomGentorAT<interval<Type> >

Modified: sandbox/itl/boost/validate/itl/functors.hpp
==============================================================================
--- sandbox/itl/boost/validate/itl/functors.hpp (original)
+++ sandbox/itl/boost/validate/itl/functors.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -63,7 +63,7 @@
 template<>
 inline std::string binary_template_to_string<copy_insertion>::apply() { return "ci"; }
 
-/*JODO URG
+/*JODO
 template <typename SourceT, typename TargetT>
 struct trans_insertion
 {

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 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -40,7 +40,7 @@
     public:
         PolyLawViolations(): p_violations(NULL){}
         PolyLawViolations(LawViolationsI* vios): p_violations(vios) {}
- ~PolyLawViolations() {} //JODO delete p_violations; }
+ ~PolyLawViolations() {}
 
         void destroy() { delete p_violations; p_violations = NULL; }
 
@@ -170,6 +170,15 @@
         size_t _violationsCount;
     };
 
+
+template<class CharType, class CharTraits>
+std::basic_ostream<CharType, CharTraits>& operator <<
+ (std::basic_ostream<CharType, CharTraits>& stream, const PolyLawViolations& object)
+{
+ return stream << "operator<<: not implemented for itl::PolyLawViolations!";
+}
+
+
 }} // namespace itl boost
 
 #endif //BOOST_ITL_LAW_VIOLATIONS_HPP_JOFA_070411

Modified: sandbox/itl/boost/validate/laws/monoid.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/monoid.hpp (original)
+++ sandbox/itl/boost/validate/laws/monoid.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -159,9 +159,6 @@
     // ---------------------------------------------------------------------------
     // Inplace variant of laws for operator o=
     // ---------------------------------------------------------------------------
- //JODO MEMO USENET: Kein Patternmatching auf templateparameter-level! Beispiel
- // TypeAsString!
- //template <typename Type, template<class>class Accumulator = inplace_plus, int aux=0>
     template <typename Type, template<class>class Accumulator = inplace_plus, template<class>class NeutronT = neutron>
     class InplaceNeutrality
         : public Law<InplaceNeutrality<Type,Accumulator,NeutronT>,

Modified: sandbox/itl/boost/validate/laws/set_laws.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/set_laws.hpp (original)
+++ sandbox/itl/boost/validate/laws/set_laws.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -118,11 +118,12 @@
     };
 
     // ---------------------------------------------------------------------------
- template <typename Type, template<class>class Operator1 = inplace_plus,
- template<class>class Operator2 = inplace_et,
- template<class>class Equality = itl::std_equal>
+ template <typename Type, template<class>class Operator1 = inplace_plus,
+ template<class>class Operator2 = inplace_et,
+ template<class>class Subtraction = inplace_minus,
+ template<class>class Equality = itl::std_equal>
     class InplaceDeMorgan
- : public Law<InplaceDeMorgan<Type,Operator1,Operator2,Equality>,
+ : public Law<InplaceDeMorgan<Type,Operator1,Operator2,Subtraction,Equality>,
                      LOKI_TYPELIST_3(Type,Type,Type), LOKI_TYPELIST_2(Type,Type)>
     {
         /** a - (b + c) == (a - b) & (a - c)
@@ -154,14 +155,14 @@
 
             // lhs := a - (b + c)
             Type lhs = this->template getInputValue<operand_a>();
- lhs -= b_plus_c;
+ Subtraction<Type>()(lhs, b_plus_c);
 
             // --- right hand side -----------------------
             Type a_minus_b = this->template getInputValue<operand_a>();
- a_minus_b -= this->template getInputValue<operand_b>();
+ Subtraction<Type>()(a_minus_b, this->template getInputValue<operand_b>());
 
             Type a_minus_c = this->template getInputValue<operand_a>();
- a_minus_c -= this->template getInputValue<operand_c>();
+ Subtraction<Type>()(a_minus_c, this->template getInputValue<operand_c>());
 
             // rhs := (a - b) & (a - c)
             Type rhs = a_minus_b;
@@ -173,7 +174,41 @@
             return Equality<Type>()(lhs, rhs);
         }
 
- bool debug_holds(){ return holds(); }
+ bool debug_holds()
+ {
+ // a - (b + c) == (a - b) & (a - c)
+ Type val_a = this->template getInputValue<operand_a>();
+ Type val_b = this->template getInputValue<operand_b>();
+ Type val_c = this->template getInputValue<operand_c>();
+ cout << "a = " << val_a << endl;
+ cout << "b = " << val_b << endl;
+ cout << "c = " << val_c << endl;
+ // --- left hand side ------------------------
+ Type b_plus_c = val_b;
+ Operator1<Type>()(b_plus_c, val_c);
+
+ // lhs := a - (b + c)
+ Type lhs = this->template getInputValue<operand_a>();
+ Subtraction<Type>()(lhs, b_plus_c);
+
+ // --- right hand side -----------------------
+ Type a_minus_b = this->template getInputValue<operand_a>();
+ Subtraction<Type>()(a_minus_b, this->template getInputValue<operand_b>());
+ cout << "a-b = " << a_minus_b << endl;
+
+ Type a_minus_c = this->template getInputValue<operand_a>();
+ Subtraction<Type>()(a_minus_c, this->template getInputValue<operand_c>());
+ cout << "a-c = " << a_minus_c << endl;
+
+ // rhs := (a - b) & (a - c)
+ Type rhs = a_minus_b;
+ Operator2<Type>()(rhs, a_minus_c);
+
+ this->template setOutputValue<lhs_result>(lhs);
+ this->template setOutputValue<rhs_result>(rhs);
+
+ return Equality<Type>()(lhs, rhs);
+ }
 
         size_t size()const
         {

Modified: sandbox/itl/boost/validate/laws/symmetric_difference.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/symmetric_difference.hpp (original)
+++ sandbox/itl/boost/validate/laws/symmetric_difference.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -18,7 +18,11 @@
 {
 
     // ---------------------------------------------------------------------------
- template <typename Type, template<class>class Equality = itl::std_equal>
+ template <typename Type,
+ template<class>class Addition = itl::inplace_plus,
+ template<class>class Subtraction = itl::inplace_minus,
+ template<class>class Intersection = itl::inplace_et,
+ template<class>class Equality = itl::std_equal>
     class InplaceSymmetricDifference
         : public Law<InplaceSymmetricDifference<Type>,
                      LOKI_TYPELIST_2(Type,Type), LOKI_TYPELIST_2(Type,Type)>
@@ -44,23 +48,23 @@
         {
             // --- left hand side ------------------------
             Type a_plus_b = this->template getInputValue<operand_a>();
- a_plus_b += this->template getInputValue<operand_b>();
+ Addition<Type>()(a_plus_b, this->template getInputValue<operand_b>());
 
             Type a_sec_b = this->template getInputValue<operand_a>();
- a_sec_b &= this->template getInputValue<operand_b>();
+ Intersection<Type>()(a_sec_b, this->template getInputValue<operand_b>());
 
             Type lhs = a_plus_b;
- lhs -= a_sec_b;
+ Subtraction<Type>()(lhs, a_sec_b);
 
             // --- right hand side -----------------------
             Type a_minus_b = this->template getInputValue<operand_a>();
- a_minus_b -= this->template getInputValue<operand_b>();
+ Subtraction<Type>()(a_minus_b, this->template getInputValue<operand_b>());
 
             Type b_minus_a = this->template getInputValue<operand_b>();
- b_minus_a -= this->template getInputValue<operand_a>();
+ Subtraction<Type>()(b_minus_a, this->template getInputValue<operand_a>());
 
             Type rhs = a_minus_b;
- rhs += b_minus_a;
+ Addition<Type>()(rhs, b_minus_a);
 
             this->template setOutputValue<lhs_result>(lhs);
             this->template setOutputValue<rhs_result>(rhs);
@@ -73,31 +77,31 @@
         {
             // --- left hand side ------------------------
             Type a_plus_b = this->template getInputValue<operand_a>();
- a_plus_b += this->template getInputValue<operand_b>();
+ Addition<Type>()(a_plus_b, this->template getInputValue<operand_b>());
 
             std::cout << "a_plus_b=" << a_plus_b.as_string() << std::endl;
 
             Type a_sec_b = this->template getInputValue<operand_a>();
- a_sec_b &= this->template getInputValue<operand_b>();
+ Intersection<Type>()(a_sec_b, this->template getInputValue<operand_b>());
 
             std::cout << "a_sec_b=" << a_sec_b.as_string() << std::endl;
 
             Type lhs = a_plus_b;
- lhs -= a_sec_b;
+ Subtraction<Type>()(lhs, a_sec_b);
 
             std::cout << "lhs=" << lhs.as_string() << std::endl;
 
             // --- right hand side -----------------------
             Type a_minus_b = this->template getInputValue<operand_a>();
- a_minus_b -= this->template getInputValue<operand_b>();
+ Subtraction<Type>()(a_minus_b, this->template getInputValue<operand_b>());
             std::cout << "a_minus_b=" << a_minus_b.as_string() << std::endl;
 
             Type b_minus_a = this->template getInputValue<operand_b>();
- b_minus_a -= this->template getInputValue<operand_a>();
+ Subtraction<Type>()(b_minus_a, this->template getInputValue<operand_a>());
             std::cout << "b_minus_a=" << b_minus_a.as_string() << std::endl;
 
             Type rhs = a_minus_b;
- rhs += b_minus_a;
+ Addition<Type>()(rhs, b_minus_a);
             std::cout << "rhs=" << rhs.as_string() << std::endl;
 
             this->template setOutputValue<lhs_result>(lhs);

Added: sandbox/itl/boost/validate/type/bits.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/validate/type/bits.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -0,0 +1,76 @@
+/*-----------------------------------------------------------------------------+
+Author: Joachim Faulhaber
+Copyright (c) 2009-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENCE.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
++-----------------------------------------------------------------------------*/
+#ifndef BOOST_ITL_XT_TEST_BITS_HPP_JOFA_091009
+#define BOOST_ITL_XT_TEST_BITS_HPP_JOFA_091009
+
+#include <boost/itl/type_traits/type_to_string.hpp>
+#include <boost/itl/type_traits/to_string.hpp>
+#include <boost/itl/type_traits/is_set.hpp>
+#include <boost/itl/detail/relation_state.hpp>
+
+namespace boost{namespace itl
+{
+
+template<class NaturalT> class bits
+{
+public:
+ bits():_bits(){}
+ explicit bits(NaturalT value):_bits(value){}
+
+ NaturalT number()const{ return _bits; }
+ bits& operator |= (const bits& value){_bits |= value._bits; return *this;}
+ bits& operator &= (const bits& value){_bits &= value._bits; return *this;}
+ bits& operator ^= (const bits& value){_bits ^= value._bits; return *this;}
+ bits operator ~ ()const { return bits(~_bits); }
+ bool operator < (const bits& value)const{return _bits < value._bits;}
+ bool operator == (const bits& value)const{return _bits == value._bits;}
+
+private:
+ NaturalT _bits;
+};
+
+typedef bits<unsigned char> bits8;
+typedef bits<unsigned short> bits16;
+typedef bits<unsigned long> bits32;
+typedef bits<unsigned long long> bits64;
+
+template<class NaturalT>
+int inclusion_compare(itl::bits<NaturalT> left, itl::bits<NaturalT> right)
+{
+ if(0 ==(left.number() & right.number())) return inclusion::unrelated;
+ else if(left.number() < right.number() ) return inclusion::subset;
+ else if(left.number() > right.number() ) return inclusion::superset;
+ else return inclusion::equal;
+}
+
+
+template<class CharType, class CharTraits, class NaturalT>
+std::basic_ostream<CharType, CharTraits>& operator <<
+(std::basic_ostream<CharType, CharTraits>& stream, const itl::bits<NaturalT>& object)
+{
+ return stream << object.number();
+}
+
+template<class NaturalT>
+struct is_set<bits<NaturalT> >
+{
+ typedef is_set<bits<NaturalT> > type;
+ BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template <>struct type_to_string<itl::bits<unsigned char> > {static std::string apply(){ return "bit8"; }};
+template <>struct type_to_string<itl::bits<unsigned short> >{static std::string apply(){ return "bit16"; }};
+template <>struct type_to_string<itl::bits<unsigned int> > {static std::string apply(){ return "bit32"; }};
+template <>struct type_to_string<itl::bits<unsigned long> > {static std::string apply(){ return "bitl32"; }};
+template <>struct type_to_string<itl::bits<unsigned long long> > {static std::string apply(){ return "bit64"; }};
+
+
+}} // namespace itl boost
+
+#endif // BOOST_ITL_LIBS_VALIDATE_TEST_BITS_HPP_JOFA_091009

Modified: sandbox/itl/boost/validate/type/nat.hpp
==============================================================================
--- sandbox/itl/boost/validate/type/nat.hpp (original)
+++ sandbox/itl/boost/validate/type/nat.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -53,7 +53,6 @@
         return *this;
     }
 
- //CL
     operator int()const{ return (_value); }
 
     std::string as_string()const { return to_string<int>::apply(_value); }

Added: sandbox/itl/boost/validate/validater/bit_collector_validater.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/validate/validater/bit_collector_validater.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -0,0 +1,139 @@
+/*-----------------------------------------------------------------------------+
+A Law Based Test Automaton 'LaBatea'
+Author: Joachim Faulhaber
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENCE.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
++-----------------------------------------------------------------------------*/
+#ifndef BOOST_VALIDATE_VALIDATER_BIT_COLLECTOR_VALIDATER_HPP_JOFA_091009
+#define BOOST_VALIDATE_VALIDATER_BIT_COLLECTOR_VALIDATER_HPP_JOFA_091009
+
+#include <boost/itl/functors.hpp>
+#include <boost/validate/laws/monoid.hpp>
+#include <boost/validate/laws/inversion_laws.hpp>
+#include <boost/validate/laws/symmetric_difference.hpp>
+#include <boost/validate/laws/set_laws.hpp>
+#include <boost/validate/validater/law_validater.hpp>
+#include <boost/validate/validater/algebra_validater.hpp>
+
+namespace boost{namespace itl
+{
+
+typedef WeightedNumberGentor<int> ChoiceT;
+
+template <typename Type>
+class collector_validater : public algebra_validater
+{
+public:
+
+ enum Laws
+ {
+ inplacePlusAssociativity,
+ inplacePlusNeutrality,
+ inplacePlusCommutativity,
+ inplaceEtAssociativity,
+ inplaceEtCommutativity,
+ inplaceNaturalInversion,
+ inplaceSymmetricDifference,
+ inplaceFlip,
+ inplacePlusDistributivity,
+ inplaceEtDistributivity,
+ inplacePlusDashRightDistrib,
+ inplaceEtDashRightDistrib,
+ inplacePlusDeMorgan,
+ inplaceEtDeMorgan,
+ Laws_size
+ };
+
+ collector_validater() {setProfile();}
+
+ void setProfile()
+ {
+ const int sum_of_shares = 100;
+ _lawChoice.setSize(Laws_size);
+ _lawChoice.setMaxWeights(sum_of_shares);
+
+ int rest_shares = sum_of_shares, item_index = 0;
+ _lawChoice[inplacePlusAssociativity] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[inplacePlusNeutrality] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[inplacePlusCommutativity] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[inplaceEtAssociativity] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[inplaceEtCommutativity] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[inplaceNaturalInversion] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[inplaceSymmetricDifference] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[inplaceFlip] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[inplacePlusDistributivity] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[inplaceEtDistributivity] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[inplacePlusDashRightDistrib]= share(Laws_size, item_index, rest_shares);
+ _lawChoice[inplaceEtDashRightDistrib] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[inplacePlusDeMorgan] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[inplaceEtDeMorgan] = share(Laws_size, item_index, rest_shares);
+ _lawChoice.init();
+ }
+
+
+ //JODO DEL complete: spezielle instanzen werden nicht benoetigt!
+ LawValidaterI* chooseValidater()
+ {
+ switch(_lawChoice.some())
+ {
+ case inplacePlusAssociativity: return new LawValidater<InplaceAssociativity<Type, inplace_bit_add>, RandomGentor>;
+ case inplacePlusNeutrality: return new LawValidater<InplaceNeutrality <Type, inplace_bit_add>, RandomGentor>;
+ case inplacePlusCommutativity: return new LawValidater<InplaceCommutativity<Type, inplace_bit_add>, RandomGentor>;
+ case inplaceEtAssociativity: return new LawValidater<InplaceAssociativity<Type, inplace_bit_and>, RandomGentor>;
+ case inplaceEtCommutativity: return new LawValidater<InplaceCommutativity<Type, inplace_bit_and>, RandomGentor>;
+ case inplaceSymmetricDifference:return new LawValidater<InplaceSymmetricDifference<Type, inplace_bit_add, inplace_bit_subtract, inplace_bit_and>, RandomGentor>;
+ case inplaceFlip: return new LawValidater<InplaceFlip<Type>, RandomGentor>;
+ case inplaceEtDistributivity:
+ if(itl::is_interval_splitter<Type>::value && absorbs_neutrons<Type>::value && !is_total<Type>::value)
+ return new LawValidater<InplaceDistributivity<Type, inplace_bit_and, inplace_bit_add, element_equal>, RandomGentor>;
+ else return new LawValidater<InplaceDistributivity<Type, inplace_bit_and, inplace_bit_add, std_equal>, RandomGentor>;
+ case inplacePlusDashRightDistrib:
+ if(itl::is_interval_splitter<Type>::value && absorbs_neutrons<Type>::value && !is_total<Type>::value)
+ return new LawValidater<InplaceRightDistributivity<Type, inplace_bit_add, inplace_bit_subtract, element_equal>, RandomGentor>;
+ else return new LawValidater<InplaceRightDistributivity<Type, inplace_bit_add, inplace_bit_subtract, std_equal>, RandomGentor>;
+ case inplaceEtDashRightDistrib: return new LawValidater<InplaceRightDistributivity<Type, inplace_bit_and, inplace_bit_subtract>, RandomGentor>;
+ case inplacePlusDeMorgan: return new LawValidater<InplaceDeMorgan<Type, inplace_bit_add, inplace_bit_and, inplace_bit_subtract, itl::std_equal>, RandomGentor>;
+ case inplaceEtDeMorgan:
+ if(itl::is_interval_splitter<Type>::value || itl::is_interval_separator<Type>::value)
+ return new LawValidater<InplaceDeMorgan<Type, inplace_bit_and, inplace_bit_add, inplace_bit_subtract, itl::element_equal>, RandomGentor>;
+ else return new LawValidater<InplaceDeMorgan<Type, inplace_bit_and, inplace_bit_add, inplace_bit_subtract, itl::std_equal>, RandomGentor>;
+
+ default: return NULL;
+ }
+ }
+
+ void validate()
+ {
+ _validater = chooseValidater();
+ if(_validater)
+ {
+ _validater->run();
+ _validater->addFrequencies(_frequencies);
+ _validater->addViolations(_violationsCount, _violations);
+ delete _validater;
+ }
+ }
+
+ void addFrequencies(ValidationCounterT& summary) { summary += _frequencies; }
+ void addViolations(ViolationCounterT& summary, ViolationMapT& collector)
+ {
+ summary += _violationsCount;
+ collector += _violations;
+ }
+
+
+private:
+ ChoiceT _lawChoice;
+ LawValidaterI* _validater;
+ ValidationCounterT _frequencies;
+ ViolationCounterT _violationsCount;
+ ViolationMapT _violations;
+};
+
+
+}} // namespace itl boost
+
+#endif BOOST_VALIDATE_VALIDATER_BIT_COLLECTOR_VALIDATER_HPP_JOFA_091009

Modified: sandbox/itl/boost/validate/validater/collector_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/collector_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/collector_validater.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -92,8 +92,8 @@
             if(itl::is_interval_splitter<Type>::value && absorbs_neutrons<Type>::value && !is_total<Type>::value)
                                         return new LawValidater<InplaceRightDistributivity<Type, inplace_plus, inplace_minus, element_equal>, RandomGentor>;
             else return new LawValidater<InplaceRightDistributivity<Type, inplace_plus, inplace_minus, std_equal>, RandomGentor>;
- case inplaceEtDashRightDistrib: return new LawValidater<InplaceRightDistributivity<Type, inplace_et, inplace_minus>, RandomGentor>;
- case inplacePlusDeMorgan: return new LawValidater<InplaceDeMorgan<Type, inplace_plus, inplace_et, itl::std_equal>, RandomGentor>;
+ case inplaceEtDashRightDistrib: return new LawValidater<InplaceRightDistributivity<Type, inplace_et, inplace_minus>, RandomGentor>;
+ case inplacePlusDeMorgan: return new LawValidater<InplaceDeMorgan<Type, inplace_plus, inplace_et, itl::std_equal>, RandomGentor>;
         case inplaceEtDeMorgan:
             if(itl::is_interval_splitter<Type>::value || itl::is_interval_separator<Type>::value)
                                         return new LawValidater<InplaceDeMorgan<Type, inplace_et, inplace_plus, itl::element_equal>, RandomGentor>;

Modified: sandbox/itl/boost/validate/validater/function_equality_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/function_equality_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/function_equality_validater.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -74,7 +74,7 @@
         void addFrequencies(ValidationCounterT& summary) { summary += _frequencies; }
         void addViolations(ViolationCounterT& summary, ViolationMapT& collector)
         {
- summary += _violationsCount;
+ summary += _violationsCount;
             collector += _violations;
         }
 

Modified: sandbox/itl/boost/validate/validater/signed_quantifier_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/signed_quantifier_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/signed_quantifier_validater.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -61,7 +61,6 @@
         if(!is_total<Type>::value && absorbs_neutrons<Type>::value)
             et_assoc_share = 0;
         //NOTE: An Inverse exists only for a total signed quantifier
- //CL if(!is_total<Type>::value)
         if(!is_total<Type>::value || !has_inverse<typename Type::codomain_type>::value)
             inv_ex_share = 0;
 

Modified: sandbox/itl/boost/validate/validation_counts.hpp
==============================================================================
--- sandbox/itl/boost/validate/validation_counts.hpp (original)
+++ sandbox/itl/boost/validate/validation_counts.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -39,6 +39,14 @@
 bool operator == (const validation_counts& left, const validation_counts& right)
 { return left.time()==right.time() && left.count()==right.count(); }
 
+template<class CharType, class CharTraits>
+std::basic_ostream<CharType, CharTraits>& operator <<
+ (std::basic_ostream<CharType, CharTraits>& stream, const validation_counts& object)
+{
+ return stream << "(time=" << object.time() << "count=" << object.count() << ")";
+}
+
+
 
 }} // namespace itl boost
 

Modified: sandbox/itl/libs/itl/build/win32/vc9_all.sln
==============================================================================
--- sandbox/itl/libs/itl/build/win32/vc9_all.sln (original)
+++ sandbox/itl/libs/itl/build/win32/vc9_all.sln 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -135,6 +135,8 @@
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vc9_labat_map_copy_conformity", "..\..\..\validate\example\labat_map_copy_conformity_\vc9_labat_map_copy_conformity.vcproj", "{BF42574F-66E2-42DD-90D9-3A8FCE6F472F}"
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vc9_labat_bit_collector", "..\..\..\validate\example\labat_bit_collector_\vc9_labat_bit_collector.vcproj", "{9EF72937-0585-487D-B887-5359BFA569E9}"
+EndProject
 Global
         GlobalSection(SolutionConfigurationPlatforms) = preSolution
                 Debug|Win32 = Debug|Win32
@@ -409,6 +411,10 @@
                 {BF42574F-66E2-42DD-90D9-3A8FCE6F472F}.Debug|Win32.Build.0 = Debug|Win32
                 {BF42574F-66E2-42DD-90D9-3A8FCE6F472F}.Release|Win32.ActiveCfg = Release|Win32
                 {BF42574F-66E2-42DD-90D9-3A8FCE6F472F}.Release|Win32.Build.0 = Release|Win32
+ {9EF72937-0585-487D-B887-5359BFA569E9}.Debug|Win32.ActiveCfg = Debug|Win32
+ {9EF72937-0585-487D-B887-5359BFA569E9}.Debug|Win32.Build.0 = Debug|Win32
+ {9EF72937-0585-487D-B887-5359BFA569E9}.Release|Win32.ActiveCfg = Release|Win32
+ {9EF72937-0585-487D-B887-5359BFA569E9}.Release|Win32.Build.0 = Release|Win32
         EndGlobalSection
         GlobalSection(SolutionProperties) = preSolution
                 HideSolutionNode = FALSE

Added: sandbox/itl/libs/validate/example/labat_bit_collector_/labat_bit_collector.cpp
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/validate/example/labat_bit_collector_/labat_bit_collector.cpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -0,0 +1,37 @@
+/*-----------------------------------------------------------------------------+
+A Law Based Test Automaton 'LaBatea'
+Author: Joachim Faulhaber
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENCE.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
++-----------------------------------------------------------------------------*/
+#include <iostream>
+#include <stdio.h>
+#include <boost/validate/driver/bit_collector_driver.hpp>
+
+using namespace std;
+using namespace boost;
+using namespace boost::itl;
+
+void test_bit_collector_driver()
+{
+ bit_collector_driver validater;
+ cout <<
+ ">> ------------------------------------------------------ <<\n"
+ ">> -------- Law based test automaton 'LaBatea' ---------- <<\n"
+ ">> Output will be generated in a few seconds\n"
+ ">> terminate by typing <CTRL>C\n"
+ ">> ------------------------------------------------------ <<\n";
+ GentorProfileSgl::it()->set_std_profile(6,1);
+ GentorProfileSgl::it()->report_profile();
+ validater.validate();
+};
+
+
+int main()
+{
+ test_bit_collector_driver();
+ return 0;
+}

Added: sandbox/itl/libs/validate/example/labat_bit_collector_/vc9_labat_bit_collector.vcproj
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/validate/example/labat_bit_collector_/vc9_labat_bit_collector.vcproj 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -0,0 +1,248 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+ ProjectType="Visual C++"
+ Version="9,00"
+ Name="vc9_labat_bit_collector"
+ ProjectGUID="{9EF72937-0585-487D-B887-5359BFA569E9}"
+ RootNamespace="vc9_labat_bit_collector"
+ Keyword="Win32Proj"
+ TargetFrameworkVersion="131072"
+ >
+ <Platforms>
+ <Platform
+ Name="Win32"
+ />
+ </Platforms>
+ <ToolFiles>
+ </ToolFiles>
+ <Configurations>
+ <Configuration
+ Name="Debug|Win32"
+ OutputDirectory="../../../../bin/debug"
+ IntermediateDirectory="../../../../bin/obj/$(ProjectName)/debug"
+ ConfigurationType="1"
+ CharacterSet="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ AdditionalOptions="/bigobj"
+ Optimization="0"
+ AdditionalIncludeDirectories="../../../../; ../../../../boost_1_35_0"
+ PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+ MinimalRebuild="true"
+ BasicRuntimeChecks="3"
+ RuntimeLibrary="3"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ Detect64BitPortabilityProblems="false"
+ DebugInformationFormat="4"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLinkerTool"
+ LinkIncremental="2"
+ AdditionalLibraryDirectories="../../../../lib; ../../../../stage/lib"
+ GenerateDebugInformation="true"
+ SubSystem="1"
+ RandomizedBaseAddress="1"
+ DataExecutionPrevention="0"
+ TargetMachine="1"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCManifestTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCFxCopTool"
+ />
+ <Tool
+ Name="VCAppVerifierTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ </Configuration>
+ <Configuration
+ Name="Release|Win32"
+ OutputDirectory="../../../../bin/release"
+ IntermediateDirectory="../../../../bin/obj/$(ProjectName)/release"
+ ConfigurationType="1"
+ CharacterSet="1"
+ WholeProgramOptimization="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ WholeProgramOptimization="true"
+ AdditionalIncludeDirectories="../../../../; ../../../../boost_1_35_0"
+ PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+ ExceptionHandling="1"
+ RuntimeLibrary="2"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ Detect64BitPortabilityProblems="false"
+ DebugInformationFormat="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLinkerTool"
+ LinkIncremental="1"
+ AdditionalLibraryDirectories="../../../../lib; ../../../../stage/lib"
+ GenerateDebugInformation="true"
+ SubSystem="1"
+ OptimizeReferences="2"
+ EnableCOMDATFolding="2"
+ LinkTimeCodeGeneration="1"
+ RandomizedBaseAddress="1"
+ DataExecutionPrevention="0"
+ TargetMachine="1"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCManifestTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCFxCopTool"
+ />
+ <Tool
+ Name="VCAppVerifierTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ </Configuration>
+ </Configurations>
+ <References>
+ </References>
+ <Files>
+ <Filter
+ Name="Quelldateien"
+ Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+ >
+ <File
+ RelativePath="..\..\src\gentor\gentorprofile.cpp"
+ >
+ </File>
+ <File
+ RelativePath="..\labat_bit_collector_\labat_bit_collector.cpp"
+ >
+ </File>
+ </Filter>
+ <Filter
+ Name="Headerdateien"
+ Filter="h;hpp;hxx;hm;inl;inc;xsd"
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+ >
+ <File
+ RelativePath="..\..\..\..\boost\validate\law.h"
+ >
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\validate\lawvalidater.h"
+ >
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\validate\lawviolations.h"
+ >
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\validate\laws\monoid.h"
+ >
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\validate\laws\order.h"
+ >
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\validate\laws\pushouts.h"
+ >
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\validate\realmvalidater.h"
+ >
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\validate\laws\set_laws.h"
+ >
+ </File>
+ <File
+ RelativePath="..\..\..\..\boost\validate\typevalidater.h"
+ >
+ </File>
+ </Filter>
+ <Filter
+ Name="Ressourcendateien"
+ Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+ UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+ >
+ </Filter>
+ <File
+ RelativePath=".\ReadMe.txt"
+ >
+ </File>
+ </Files>
+ <Globals>
+ </Globals>
+</VisualStudioProject>

Modified: sandbox/itl/libs/validate/example/labat_polygon_/point_gentor.hpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_polygon_/point_gentor.hpp (original)
+++ sandbox/itl/libs/validate/example/labat_polygon_/point_gentor.hpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -23,8 +23,6 @@
 template<class DomainT>
 struct point
 {
- //CL typedef DomainT coordinate_type;
-
     std::string as_string()const
     {
         return std::string(

Modified: sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp 2009-10-11 17:15:22 EDT (Sun, 11 Oct 2009)
@@ -76,9 +76,11 @@
     //typedef Balance<itl::tree<int> > TestLawT;
     //LawValidater<TestLawT, RandomGentor> test_law;
 
- //typedef InplaceDeMorgan
- // <itl::interval_map<int, int> > TestLawT;
- //LawValidater<TestLawT, RandomGentor> test_law;
+ typedef InplaceDeMorgan
+ <itl::split_interval_map<int, itl::bits16, partial_enricher,
+ std::less, inplace_bit_add, inplace_bit_and>,
+ inplace_bit_add, inplace_bit_and> TestLawT;
+ LawValidater<TestLawT, RandomGentor> test_law;
 
     //typedef IntersectsDefined
     // <itl::interval_map<int, int, total_absorber> > TestLawT;
@@ -96,17 +98,17 @@
     // <interval_set<int>, itl::interval<int> > TestLawT;
     //LawValidater<TestLawT, RandomGentor> test_law;
 
- typedef FunctionEquality
- <
- itl::list<std::pair<itl::interval<int>,int> >,
- interval_map<int,int,total_absorber>,
- base_addition,
- hint_addition
- > TestLawT;
- LawValidater<TestLawT, RandomGentor> test_law;
+ //typedef FunctionEquality
+ //<
+ // itl::list<std::pair<int,int> >,
+ // itl::map<int,int,partial_absorber>,
+ // base_insertion,
+ // hint_insertion
+ //> TestLawT;
+ //LawValidater<TestLawT, RandomGentor> test_law;
 
     //-----------------------------------------------------------------------------
- int test_count = 50000;
+ int test_count = 10000;
     ptime start, stop;
 
     GentorProfileSgl::it()->set_std_profile(4,1);


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk