Subject: [Boost-commit] svn:boost r56725 - in sandbox/itl: boost/itl boost/itl_xt boost/itl_xt/std boost/validate/driver boost/validate/gentor boost/validate/laws boost/validate/type boost/validate/validater libs/validate/example/labat_single_
From: afojgo_at_[hidden]
Date: 2009-10-11 17:55:36
Author: jofaber
Date: 2009-10-11 17:55:35 EDT (Sun, 11 Oct 2009)
New Revision: 56725
URL: http://svn.boost.org/trac/boost/changeset/56725
Log:
Boostifying: Replaced 'Tabs' for the latest changes (law based tests for std::copy and interval_maps of bitsets). Stable {msvc-8.0, 9.0; gcc-3.4.4}
Text files modified:
sandbox/itl/boost/itl/functors.hpp | 104 ++++++++++++++++++++--------------------
sandbox/itl/boost/itl/map.hpp | 2
sandbox/itl/boost/itl_xt/bits_gentor.hpp | 16 +++---
sandbox/itl/boost/itl_xt/seqgentor.hpp | 2
sandbox/itl/boost/itl_xt/std/pair_gentor.hpp | 12 ++--
sandbox/itl/boost/validate/driver/bit_collector_driver.hpp | 14 ++--
sandbox/itl/boost/validate/driver/itl_order_driver.hpp | 14 ++--
sandbox/itl/boost/validate/gentor/randomgentor.hpp | 62 +++++++++++-----------
sandbox/itl/boost/validate/laws/law_violations.hpp | 2
sandbox/itl/boost/validate/laws/set_laws.hpp | 20 +++---
sandbox/itl/boost/validate/laws/symmetric_difference.hpp | 8 +-
sandbox/itl/boost/validate/type/bits.hpp | 28 +++++-----
sandbox/itl/boost/validate/validater/bit_collector_validater.hpp | 2
sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp | 20 +++---
14 files changed, 153 insertions(+), 153 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:55:35 EDT (Sun, 11 Oct 2009)
@@ -304,16 +304,16 @@
// 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)
+ // 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;
@@ -346,42 +346,42 @@
template<class Combiner>
struct conversion
{
- 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> 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;
+ typedef typename base_type::argument_type argument_type;
- argument_type operator()(const argument_type& value)
- { return base_type::proversion(value); }
- };
+ 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;}};
@@ -392,17 +392,17 @@
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> > : public conversion<itl::inplace_minus<Type> >
+ struct version<itl::inplace_minus<Type> > : public conversion<itl::inplace_minus<Type> >
{
- typedef version<itl::inplace_minus<Type> > type;
+ typedef version<itl::inplace_minus<Type> > type;
typedef conversion<itl::inplace_minus<Type> > base_type;
- typedef typename base_type::argument_type argument_type;
+ typedef typename base_type::argument_type argument_type;
- Type operator()(const Type& value)
- {
- return base_type::inversion(value);
- }
- };
+ Type operator()(const Type& value)
+ {
+ return base_type::inversion(value);
+ }
+ };
}} // 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:55:35 EDT (Sun, 11 Oct 2009)
@@ -459,7 +459,7 @@
return prior_;
iterator inserted_ = base_insert(prior_, value_type(val.first, Combiner::neutron()));
- Combiner()(inserted_->second, val.second);
+ Combiner()(inserted_->second, val.second);
if(Traits::absorbs_neutrons && inserted_->second == Combiner::neutron())
{
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 2009-10-11 17:55:35 EDT (Sun, 11 Oct 2009)
@@ -22,19 +22,19 @@
{
public:
- typedef itl::bits<NaturalT> bits_type;
+ typedef itl::bits<NaturalT> bits_type;
- void some(bits_type& value)
- {
- value = bits_type(_natural_gentor(_value_range));
- };
+ void some(bits_type& value)
+ {
+ value = bits_type(_natural_gentor(_value_range));
+ };
- void set_range(const itl::interval<NaturalT>& range)
- { _value_range = range; }
+ void set_range(const itl::interval<NaturalT>& range)
+ { _value_range = range; }
private:
NumberGentorT<NaturalT> _natural_gentor;
- itl::interval<NaturalT> _value_range;
+ itl::interval<NaturalT> _value_range;
};
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:55:35 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(itl::right_open)); 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_gentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/std/pair_gentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/std/pair_gentor.hpp 2009-10-11 17:55:35 EDT (Sun, 11 Oct 2009)
@@ -21,7 +21,7 @@
{
public:
- typedef std::pair<FirstT,SecondT> pair_type;
+ 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; }
@@ -38,11 +38,11 @@
_second_gentor = gentor;
}
- void some(pair_type& value)
- {
- _first_gentor->some(value.first);
- _second_gentor->some(value.second);
- };
+ void some(pair_type& value)
+ {
+ _first_gentor->some(value.first);
+ _second_gentor->some(value.second);
+ };
private:
RandomGentorAT<FirstT>* _first_gentor;
Modified: sandbox/itl/boost/validate/driver/bit_collector_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/bit_collector_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/bit_collector_driver.hpp 2009-10-11 17:55:35 EDT (Sun, 11 Oct 2009)
@@ -103,9 +103,9 @@
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> >;
+ 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> >;
+ 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
@@ -113,19 +113,19 @@
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> >;
+ 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> >;
+ 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_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> >;
+ 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
Modified: sandbox/itl/boost/validate/driver/itl_order_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/itl_order_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/itl_order_driver.hpp 2009-10-11 17:55:35 EDT (Sun, 11 Oct 2009)
@@ -28,13 +28,13 @@
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;
+ _rootChoice[RootType::itl_set] = 14;
+ _rootChoice[RootType::interval_set] = 14;
+ _rootChoice[RootType::separate_interval_set] = 14;
+ _rootChoice[RootType::split_interval_set] = 14;
+ _rootChoice[RootType::itl_map] = 14;
+ _rootChoice[RootType::interval_map] = 15;
+ _rootChoice[RootType::split_interval_map] = 15;
setRootTypeNames();
_rootChoice.init();
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:55:35 EDT (Sun, 11 Oct 2009)
@@ -48,8 +48,8 @@
// -------------------------------------------------------------------------
template <class NaturalT>
- class RandomGentor<itl::bits<NaturalT> > :
- public bits_gentor<itl::bits<NaturalT> > {};
+ class RandomGentor<itl::bits<NaturalT> > :
+ public bits_gentor<itl::bits<NaturalT> > {};
// -------------------------------------------------------------------------
template <class DomainT>
@@ -58,7 +58,7 @@
// -------------------------------------------------------------------------
template <class DomainT, class CodomainT>
- class RandomGentor< std::pair<DomainT,CodomainT> > :
+ class RandomGentor< std::pair<DomainT,CodomainT> > :
public std_pair_gentor<DomainT,CodomainT> {};
#ifdef LAW_BASED_TEST_BOOST_POLYGON
@@ -123,7 +123,7 @@
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>
+ 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> > {};
@@ -153,20 +153,20 @@
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
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> > :
+ 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>
+ 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.
+ //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.
// ------------------------------------------------------------------------
@@ -230,12 +230,12 @@
};
template <class BitsT>
- struct Calibrater<itl::bits<BitsT>, RandomGentor>
+ 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));
+ gentor.set_range(itl::interval<BitsT>::rightopen(0, sizeof BitsT));
}
};
@@ -563,12 +563,12 @@
};
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>
+ 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)
+ Compare,Combine,Section> >& gentor)
{
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
@@ -667,7 +667,7 @@
};
template <typename NumericDomainT, typename NumericCodomainT, class Neutronizer,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section>
+ 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,Compare,Combine,Section> >& gentor)
@@ -692,12 +692,12 @@
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>
+ 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)
+ static void apply(RandomGentor<interval_map<NumericDomainT,itl::bits<BitsT>,
+ Neutronizer,Compare,Combine,Section> >& gentor)
{
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
@@ -709,7 +709,7 @@
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
bits_gentor<BitsT>* codomainGentor = new bits_gentor<BitsT>;
- codomainGentor->set_range(interval<BitsT>::closed(0, (numeric_limits<BitsT>::max)()));
+ codomainGentor->set_range(interval<BitsT>::closed(0, (numeric_limits<BitsT>::max)()));
gentor.setDomainGentor(itvGentor);
gentor.setCodomainGentor(codomainGentor);
@@ -717,12 +717,12 @@
};
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>
+ 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)
+ static void apply(RandomGentor<split_interval_map<NumericDomainT,itl::bits<BitsT>,
+ Neutronizer,Compare,Combine,Section> >& gentor)
{
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
@@ -734,7 +734,7 @@
itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
bits_gentor<BitsT>* codomainGentor = new bits_gentor<BitsT>;
- codomainGentor->set_range(interval<BitsT>::closed(0, (numeric_limits<BitsT>::max)()));
+ codomainGentor->set_range(interval<BitsT>::closed(0, (numeric_limits<BitsT>::max)()));
gentor.setDomainGentor(itvGentor);
gentor.setCodomainGentor(codomainGentor);
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:55:35 EDT (Sun, 11 Oct 2009)
@@ -175,7 +175,7 @@
std::basic_ostream<CharType, CharTraits>& operator <<
(std::basic_ostream<CharType, CharTraits>& stream, const PolyLawViolations& object)
{
- return stream << "operator<<: not implemented for itl::PolyLawViolations!";
+ return stream << "operator<<: not implemented for itl::PolyLawViolations!";
}
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:55:35 EDT (Sun, 11 Oct 2009)
@@ -175,14 +175,14 @@
}
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;
+ 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);
@@ -194,11 +194,11 @@
// --- 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;
+ 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;
+ cout << "a-c = " << a_minus_c << endl;
// rhs := (a - b) & (a - c)
Type rhs = a_minus_b;
@@ -208,7 +208,7 @@
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:55:35 EDT (Sun, 11 Oct 2009)
@@ -19,10 +19,10 @@
// ---------------------------------------------------------------------------
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>
+ 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)>
Modified: sandbox/itl/boost/validate/type/bits.hpp
==============================================================================
--- sandbox/itl/boost/validate/type/bits.hpp (original)
+++ sandbox/itl/boost/validate/type/bits.hpp 2009-10-11 17:55:35 EDT (Sun, 11 Oct 2009)
@@ -20,19 +20,19 @@
template<class NaturalT> class bits
{
public:
- bits():_bits(){}
- explicit bits(NaturalT value):_bits(value){}
+ 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;}
+ 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;
+ NaturalT _bits;
};
typedef bits<unsigned char> bits8;
@@ -43,10 +43,10 @@
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;
+ 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;
}
Modified: sandbox/itl/boost/validate/validater/bit_collector_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/bit_collector_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/bit_collector_validater.hpp 2009-10-11 17:55:35 EDT (Sun, 11 Oct 2009)
@@ -74,7 +74,7 @@
}
- //JODO DEL complete: spezielle instanzen werden nicht benoetigt!
+ //JODO DEL complete: spezielle instanzen werden nicht benoetigt!
LawValidaterI* chooseValidater()
{
switch(_lawChoice.some())
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:55:35 EDT (Sun, 11 Oct 2009)
@@ -78,8 +78,8 @@
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;
+ std::less, inplace_bit_add, inplace_bit_and>,
+ inplace_bit_add, inplace_bit_and> TestLawT;
LawValidater<TestLawT, RandomGentor> test_law;
//typedef IntersectsDefined
@@ -98,14 +98,14 @@
// <interval_set<int>, itl::interval<int> > 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;
+ //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 = 10000;