[Boost-commit] svn:boost r51181 - in sandbox/itl/boost/validate: laws validater

Subject: [Boost-commit] svn:boost r51181 - in sandbox/itl/boost/validate: laws validater
From: afojgo_at_[hidden]
Date: 2009-02-10 09:56:26

Author: jofaber
Date: 2009-02-10 09:56:24 EST (Tue, 10 Feb 2009)
New Revision: 51181
URL: http://svn.boost.org/trac/boost/changeset/51181

Log:
Refactored. Renamed order.h. Compiles {msvc-9.0}  

Added:
   sandbox/itl/boost/validate/laws/order.hpp   (props changed)
      - copied unchanged from r51048, /sandbox/itl/boost/validate/laws/order.h
Removed:
   sandbox/itl/boost/validate/laws/monoid.h
   sandbox/itl/boost/validate/laws/order.h
Text files modified: 
   sandbox/itl/boost/validate/validater/interval_morphic_validater.hpp  |     2 +-                                      
   sandbox/itl/boost/validate/validater/partial_order_validater.hpp     |     2 +-                                      
   sandbox/itl/boost/validate/validater/strict_weak_order_validater.hpp |     2 +-                                      
   3 files changed, 3 insertions(+), 3 deletions(-)

Deleted: sandbox/itl/boost/validate/laws/monoid.h
==============================================================================
--- sandbox/itl/boost/validate/laws/monoid.h	2009-02-10 09:56:24 EST (Tue, 10 Feb 2009)
+++ (empty file)
@@ -1,383 +0,0 @@
-/*----------------------------------------------------------------------------+
-A Law Based Test Automaton 'LaBatea'
-Author: Joachim Faulhaber
-Copyright (c) 2007-2008: 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 __itl_monoid_h_JOFA_070411__
-#define __itl_monoid_h_JOFA_070411__
-
-#include <boost/itl/type_traits/value_size.hpp>
-#include <boost/itl/functors.hpp>
-#include <boost/itl/predicates.hpp>
-#include <boost/validate/law.h>
-
-namespace boost{namespace itl
-{
-
-    /*  Monoid: (M,+,0) with .+.: M x M -> M   has these axioms
-        (1) Associativity
-        (2) Neutral element
-        A commutative monoid or abelian monoid has also
-        (3) Commutativity
-    */
-
-    template <typename Type>
-    class AdditionNeutrality 
-        : public Law<AdditionNeutrality<Type>, LOKI_TYPELIST_1(Type), LOKI_TYPELIST_1(Type)> 
-    {
-    public:
-        std::string name()const { return "Addition Neutrality"; }
-        std::string formula()const { return "a + 0 == 0"; }
-
-        std::string typeString()const
-        {
-            return "Neutrality<"+type_to_string<Type>::apply()+",+,0>";
-        }
-
-    public:
-        bool holds()
-        {
-            Type inVal = this->template getInputValue<0>();
-            Type outVal = inVal + Type();
-            this->template setOutputValue<0>(outVal);
-            return inVal == outVal;
-        }
-
-        bool debug_holds(){ return holds(); }
-
-        size_t size()const;
-
-        void setValue(const Type& inVal) { this->template setInputValue<0>(inVal); }
-        Type getResult()const { return this->template getOutputValue<0>(); }
-    };
-
-    template <> size_t AdditionNeutrality<int>::size()const 
-    { return getInputValue<0>(); }
-
-    template <class Type> size_t AdditionNeutrality<Type>::size()const 
-    { return this->template getInputValue<0>().size(); };
-
-    template <typename Type>
-    class AdditionCommutativity 
-        : public Law<AdditionCommutativity<Type>, LOKI_TYPELIST_2(Type,Type), LOKI_TYPELIST_2(Type,Type)> 
-    {
-        /** a + b == b + a 
-        Input  = (a := inVal1, b := inVal2)
-        Output = (sum_lhs, sum_rhs)
-        */
-    public:
-        std::string name()const { return "Addition Commutativity"; }
-        std::string formula()const { return "a + b == b + a"; }
-
-        std::string typeString()const
-        {
-            return "Commutativity<"+type_to_string<Type>::apply()+",+>";
-        }
-
-    public:
-        enum InputVarIndex  { operand_a, operand_b };
-        enum OutputVarIndex { lhs_sum, rhs_sum };
-
-        void setOperand_a(const Type& inVal) { this->template setInputValue<operand_a>(inVal); }
-        void setOperand_b(const Type& inVal) { this->template setInputValue<operand_b>(inVal); }
-        void setOperands(const Type& inVal_a, const Type& inVal_b) 
-        { this->template setInputValue<operand_b>(inVal_a); this->template setInputValue<operand_b>(inVal_b); }
-
-        Type getLhsSum()const { return this->template getOutputValue<lhs_sum>(); }
-        Type getRhsSum()const { return this->template getOutputValue<rhs_sum>(); }
-
-        bool holds()
-        {
-            this->template setOutputValue<lhs_sum>(this->template getInputValue<operand_a>() + this->template getInputValue<operand_b>());
-            this->template setOutputValue<rhs_sum>(this->template getInputValue<operand_b>() + this->template getInputValue<operand_a>());
-            return this->template getOutputValue<lhs_sum>() == this->template getOutputValue<rhs_sum>();
-        }
-
-        bool debug_holds(){ return holds(); }
-
-        size_t size()const 
-        { 
-            return value_size<Type>::apply(this->template getInputValue<operand_a>())+
-                   value_size<Type>::apply(this->template getInputValue<operand_b>());
-        }
-    };
-
-
-    template <typename TypeA, typename TypeB>
-    class MixedAdditionCommutativity 
-        : public Law<MixedAdditionCommutativity<TypeA, TypeB>, 
-                     LOKI_TYPELIST_2(TypeA,TypeB), LOKI_TYPELIST_2(TypeB,TypeB)> 
-    {
-        /** a + b == b + a 
-        Input  = (a := inVal1, b := inVal2)
-        Output = (sum_lhs, sum_rhs)
-        */
-    public:
-        std::string name()const { return "Mixed Addition Commutativity"; }
-        std::string formula()const { return "a + b == b + a for A a; B b; +: A x B -> B"; }
-
-        std::string typeString()const
-        {
-            return "Commutativity<"+type_to_string<TypeA>::apply()+","
-                                   +type_to_string<TypeB>::apply()+",+>";
-        }
-
-    public:
-        enum InputVarIndex  { operand_a, operand_b };
-        enum OutputVarIndex { lhs_sum, rhs_sum };
-
-        void setOperand_a(const TypeA& inVal) { this->template setInputValue<operand_a>(inVal); }
-        void setOperand_b(const TypeB& inVal) { this->template setInputValue<operand_b>(inVal); }
-        void setOperands(const TypeA& inVal_a, const TypeB& inVal_b) 
-        { this->template setInputValue<operand_b>(inVal_a); this->template setInputValue<operand_b>(inVal_b); }
-
-        TypeB getLhsSum()const { return this->template getOutputValue<lhs_sum>(); }
-        TypeB getRhsSum()const { return this->template getOutputValue<rhs_sum>(); }
-
-        bool holds()
-        {
-            this->template setOutputValue<lhs_sum>(this->template getInputValue<operand_a>() + this->template getInputValue<operand_b>());
-            this->template setOutputValue<rhs_sum>(this->template getInputValue<operand_b>() + this->template getInputValue<operand_a>());
-            return this->template getOutputValue<lhs_sum>() == this->template getOutputValue<rhs_sum>();
-        }
-
-        bool debug_holds(){ return holds(); }
-
-        size_t size()const 
-        { 
-            return value_size<TypeA>::get(this->template getInputValue<operand_a>())+
-                   value_size<TypeB>::get(this->template getInputValue<operand_b>());
-        }
-
-    };
-
-
-    // ---------------------------------------------------------------------------
-    // 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>, 
-                     LOKI_TYPELIST_1(Type), LOKI_TYPELIST_1(Type)>
-    {
-        /** a o 0 == a computed as
-        l=a; l o= 0; => l==a 
-        Input  = (a := inVal1)
-        Output = (lhs_result)
-        */
-    public:
-        std::string name()const { return "Inplace Op Neutrality"; }
-        std::string formula()const { return "a o 0 == a 'inplace'"; }
-
-        std::string typeString()const
-        {
-            return "Neutrality<"+type_to_string<Type>::apply()+","
-                                +unary_template_to_string<Accumulator>::apply()+","
-                                +unary_template_to_string<NeutronT>::apply()+">";
-        }
-
-    public:
-
-        enum InputVarIndex  { operand_a, operand_b };
-        enum OutputVarIndex { lhs_result, rhs_result };
-
-        void setOperand_a(const Type& inVal) { this->template setInputValue<operand_a>(inVal); }
-
-        Type getLhsResult()const { return this->template getOutputValue<lhs_result>(); }
-
-        size_t size()const 
-        { 
-            return value_size<Type>::apply(this->template getInputValue<operand_a>());
-        }
-
-        bool holds()
-        {
-            Type lhs = this->template getInputValue<operand_a>();
-            Accumulator<Type>()(lhs, neutron<Type>()());
-            this->template setOutputValue<lhs_result>(lhs);
-            return lhs == this->template getInputValue<operand_a>();
-        }
-
-        bool debug_holds(){ return holds(); }
-
-    };
-
-
-    template <typename Type, 
-              template<class>class Accumulator = inplace_plus, 
-              template<class>class Equality = itl::std_equal>
-    class InplaceAssociativity 
-        : public Law<InplaceAssociativity<Type,Accumulator,Equality>, 
-                     LOKI_TYPELIST_3(Type,Type,Type), LOKI_TYPELIST_2(Type,Type)>
-    {
-        /** (a o b) o c == a o (b o c) 'inplace'
-        Input  = (a := inVal1, b := inVal2, c := inVal3)
-        Output = (sum_lhs, sum_rhs)
-        */
-    public:
-        std::string name()const { return "Inplace Associativity"; }
-        std::string formula()const { return "(a o b) o c == a o (b o c) 'inplace'"; }
-
-        std::string typeString()const
-        {
-            return "Associativity<"+type_to_string<Type>::apply()+","
-                                   +unary_template_to_string<Accumulator>::apply()+","
-                                   +unary_template_to_string<Equality>::apply()+">";
-        }
-
-    public:
-
-        enum InputVarIndex  { operand_a, operand_b, operand_c };
-        enum OutputVarIndex { lhs_sum, rhs_sum };
-
-        void setOperand_a(const Type& inVal) { this->template setInputValue<operand_a>(inVal); }
-        void setOperand_b(const Type& inVal) { this->template setInputValue<operand_b>(inVal); }
-        void setOperand_c(const Type& inVal) { this->template setInputValue<operand_c>(inVal); }
-        void setOperands(const Type& inVal_a, const Type& inVal_b, const Type& inVal_c) 
-        { this->template setInputValue<operand_b>(inVal_a); this->template setInputValue<operand_b>(inVal_b); this->template setInputValue<operand_b>(inVal_c); }
-
-        Type getLhsSum()const { return this->template getOutputValue<lhs_sum>(); }
-        Type getRhsSum()const { return this->template getOutputValue<rhs_sum>(); }
-
-        size_t size()const 
-        { 
-            return 
-                value_size<Type>::apply(this->template getInputValue<operand_a>())+
-                value_size<Type>::apply(this->template getInputValue<operand_b>())+
-                value_size<Type>::apply(this->template getInputValue<operand_b>());
-        }
-
-        bool holds()
-        {
-            Type lsum = this->template getInputValue<operand_a>();
-            Accumulator<Type>()(lsum, this->template getInputValue<operand_b>());
-            Accumulator<Type>()(lsum, this->template getInputValue<operand_c>());
-
-            Type rsum = this->template getInputValue<operand_a>();
-            Type b_plus_c = this->template getInputValue<operand_b>();
-            Accumulator<Type>()(b_plus_c, this->template getInputValue<operand_c>());
-            Accumulator<Type>()(rsum, b_plus_c);
-
-            this->template setOutputValue<lhs_sum>(lsum);
-            this->template setOutputValue<rhs_sum>(rsum);
-
-            return Equality<Type>()(lsum, rsum);
-        }
-
-        bool debug_holds()
-        {
-            std::cout << typeString() << std::endl;
-            std::cout << formula() << std::endl;
-            std::cout << "a: " << this->template getInputValue<operand_a>().as_string() << std::endl;
-            std::cout << "b: " << this->template getInputValue<operand_b>().as_string() << std::endl;
-            std::cout << "c: " << this->template getInputValue<operand_c>().as_string() << std::endl;
-
-            Type lsum = this->template getInputValue<operand_a>();
-            Accumulator<Type>()(lsum, this->template getInputValue<operand_b>());
-            std::cout << "a o b: " << lsum.as_string() << std::endl;
-
-            Accumulator<Type>()(lsum, this->template getInputValue<operand_c>());
-            std::cout << "(a o b) o c: " << lsum.as_string() << std::endl;
-
-            Type rsum = this->template getInputValue<operand_a>();
-            Type b_plus_c = this->template getInputValue<operand_b>();
-            Accumulator<Type>()(b_plus_c, this->template getInputValue<operand_c>());
-            std::cout << "b o c: " << b_plus_c.as_string() << std::endl;
-            Accumulator<Type>()(rsum, b_plus_c);
-            std::cout << "a o (b o c): " << rsum.as_string() << std::endl;
-
-            this->template setOutputValue<lhs_sum>(lsum);
-            this->template setOutputValue<rhs_sum>(rsum);
-
-            return Equality<Type>()(lsum, rsum);
-        }
-
-    };
-
-
-    template <typename Type, template<class>class Accumulator = inplace_plus>
-    class InplaceCommutativity 
-        : public Law<InplaceCommutativity<Type,Accumulator>, 
-                     LOKI_TYPELIST_2(Type,Type), LOKI_TYPELIST_2(Type,Type)>
-    {
-        /** a o b == b o a computed as
-        lsum=a; lsum+=b; rsum=b; rsum+=a => lsum==rsum 
-        Input  = (a := inVal1, b := inVal2)
-        Output = (sum_lhs, sum_rhs)
-        */
-    public:
-        std::string name()const { return "Inplace Commutativity"; }
-        std::string formula()const { return "a o b == b o a 'inplace'"; }
-
-        std::string typeString()const
-        {
-            return "Commutativity<"+type_to_string<Type>::apply()+","
-                                   +unary_template_to_string<Accumulator>::apply()+">";
-        }
-
-    public:
-
-        enum InputVarIndex  { operand_a, operand_b };
-        enum OutputVarIndex { lhs_sum, rhs_sum };
-
-        void setOperand_a(const Type& inVal) { this->template setInputValue<operand_a>(inVal); }
-        void setOperand_b(const Type& inVal) { this->template setInputValue<operand_b>(inVal); }
-        void setOperands(const Type& inVal_a, const Type& inVal_b) 
-        { this->template setInputValue<operand_b>(inVal_a); this->template setInputValue<operand_b>(inVal_b); }
-
-        Type getLhsSum()const { return this->template getOutputValue<lhs_sum>(); }
-        Type getRhsSum()const { return this->template getOutputValue<rhs_sum>(); }
-
-        size_t size()const 
-        { 
-            return value_size<Type>::apply(this->template getInputValue<operand_a>())+
-                value_size<Type>::apply(this->template getInputValue<operand_b>());
-        }
-
-        bool holds()
-        {
-            Type lsum = this->template getInputValue<operand_a>();
-            lsum += this->template getInputValue<operand_b>();
-            Type rsum = this->template getInputValue<operand_b>();
-            rsum += this->template getInputValue<operand_a>();
-
-            this->template setOutputValue<lhs_sum>(lsum);
-            this->template setOutputValue<rhs_sum>(rsum);
-
-            return lsum == rsum;
-        }
-
-        bool debug_holds()
-        { 
-            std::cout << typeString() << std::endl;
-            std::cout << formula() << std::endl;
-            std::cout << "a: " << this->template getInputValue<operand_a>().as_string() << std::endl;
-            std::cout << "b: " << this->template getInputValue<operand_b>().as_string() << std::endl;
-
-            Type lsum = this->template getInputValue<operand_a>();
-            lsum += this->template getInputValue<operand_b>();
-            std::cout << "a o b: " << lsum.as_string() << std::endl;
-
-            Type rsum = this->template getInputValue<operand_b>();
-            rsum += this->template getInputValue<operand_a>();
-            std::cout << "b o a: " << rsum.as_string() << std::endl;
-
-            this->template setOutputValue<lhs_sum>(lsum);
-            this->template setOutputValue<rhs_sum>(rsum);
-
-            return lsum == rsum;
-        }
-
-    };
-
-}} // namespace itl boost
-
-#endif // __itl_monoid_h_JOFA_070411__
-

Deleted: sandbox/itl/boost/validate/laws/order.h
==============================================================================
--- sandbox/itl/boost/validate/laws/order.h	2009-02-10 09:56:24 EST (Tue, 10 Feb 2009)
+++ (empty file)
@@ -1,210 +0,0 @@
-/*----------------------------------------------------------------------------+
-A Law Based Test Automaton 'LaBatea'
-Author: Joachim Faulhaber
-Copyright (c) 2007-2008: 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 __itl_order_h_JOFA_071129__
-#define __itl_order_h_JOFA_071129__
-
-#include <boost/itl/type_traits/value_size.hpp>
-#include <boost/validate/law.h>
-
-namespace boost{namespace itl
-{
-
-    /*  Orders (Orderings): .<. : M x M -> bool */
-
-
-    template <typename Type, template<class>class Relation>
-    class Reflexivity 
-        : public Law<Reflexivity<Type,Relation>, 
-                     LOKI_TYPELIST_1(Type), Loki::NullType> 
-    {
-    public:
-        std::string name()const { return "Reflexivity"; }
-        std::string formula()const { return "a <= a"; }
-
-        std::string typeString()const
-        {
-            return "Reflexivity<"+type_to_string<Type>::apply()+","
-                                 +unary_template_to_string<Relation>::apply()+">";
-        }
-
-    public:
-        bool holds()
-        {
-            Type a = this->template getInputValue<operand_a>();
-            return Relation<Type>()(a,a);
-        }
-
-        bool debug_holds(){ return holds(); }
-
-        size_t size()const 
-        { return value_size<Type>::apply(this->template getInputValue<operand_a>());    }
-    };
-
-    template<> 
-    std::string unary_template_to_string<std::less_equal>::apply()  { return "<="; }
-    template<> 
-    std::string unary_template_to_string<std::less>::apply()        { return "<"; }
-
-    // ---------------------------------------------------------------------------
-    template <typename Type, template<class>class Relation>
-    class Irreflexivity 
-        : public Law<Irreflexivity<Type,Relation>, 
-                     LOKI_TYPELIST_1(Type), Loki::NullType> 
-    {
-    public:
-        std::string name()const { return "Irreflexivity"; }
-        std::string formula()const { return "!(a < a)"; }
-
-        std::string typeString()const
-        {
-            return "Irreflexivity<"+type_to_string<Type>::apply()+","
-                                   +unary_template_to_string<Relation>::apply()+">";
-        }
-
-    public:
-        bool holds()
-        {
-            Type a = this->template getInputValue<operand_a>();
-            return !Relation<Type>()(a,a);
-        }
-
-        bool debug_holds(){ return holds(); }
-
-        size_t size()const 
-        { return value_size<Type>::apply(this->template getInputValue<operand_a>());    }
-    };
-
-    // ---------------------------------------------------------------------------
-    template <typename Type, 
-		      template<class>class Relation,
-			  template<class>class Equality = itl::std_equal>
-    class Antisymmetry 
-        : public Law<Antisymmetry<Type,Relation,Equality>, 
-                     LOKI_TYPELIST_2(Type,Type), Loki::NullType> 
-    {
-        /** a <= b && b <= a  =>  a == b 
-        Input  = (a := inVal1, b := inVal2)
-        Output = ()
-        */
-    public:
-        std::string name()const { return "Antisymmetry"; }
-        std::string formula()const { return "(a <= b && b <= a)  =>  a == b"; }
-
-        std::string typeString()const
-        {
-            return "Antisymmetry<"+type_to_string<Type>::apply()+"," 
-                                  +unary_template_to_string<Relation>::apply()+","
-                                  +unary_template_to_string<Equality>::apply()+">";
-        }
-
-    public:
-
-        bool holds()
-        {
-            Type a = this->template getInputValue<operand_a>();
-            Type b = this->template getInputValue<operand_b>();
-
-            return !(Relation<Type>()(a,b) && Relation<Type>()(b,a)) || Equality<Type>()(a,b);
-        }
-
-        bool debug_holds(){ return holds(); }
-
-        size_t size()const 
-        { 
-            return value_size<Type>::apply(this->template getInputValue<operand_a>())+
-                   value_size<Type>::apply(this->template getInputValue<operand_b>());
-        }
-    };
-
-    // ---------------------------------------------------------------------------
-    template <typename Type, template<class>class Relation>
-    class Asymmetry 
-        : public Law<Asymmetry<Type,Relation>, 
-                     LOKI_TYPELIST_2(Type,Type), LOKI_TYPELIST_1(Type)> 
-    {
-        /** a < b  => !(b < a) 
-        Input  = (a := inVal1, b := inVal2)
-        Output = ()
-        */
-    public:
-        std::string name()const { return "Asymmetry"; }
-        std::string formula()const { return " a < b  => !(b < a)"; }
-
-        std::string typeString()const
-        {
-            return "Asymmetry<"+type_to_string<Type>::apply()+","
-                               +unary_template_to_string<Relation>::apply()+">";
-        }
-
-    public:
-
-        bool holds()
-        {
-            Type a = this->template getInputValue<operand_a>();
-            Type b = this->template getInputValue<operand_a>();
-
-            return !(Relation<Type>()(a,b) && Relation<Type>()(b,a));
-        }
-
-        bool debug_holds(){ return holds(); }
-
-        size_t size()const 
-        { 
-            return value_size<Type>::apply(this->template getInputValue<operand_a>())+
-                value_size<Type>::apply(this->template getInputValue<operand_b>());
-        }
-    };
-
-
-    // ---------------------------------------------------------------------------
-    template <typename Type, template<class>class Relation>
-    class Transitivity 
-        : public Law<Transitivity<Type,Relation>, 
-                     LOKI_TYPELIST_3(Type,Type,Type), Loki::NullType> 
-    {
-        /** a < b && b < c  =>  a < c 
-        Input  = (a := inVal1, b := inVal2, c := inVal3)
-        Output = ()
-        */
-    public:
-        std::string name()const { return "Transitivity"; }
-        std::string formula()const { return "a < b && b < c  =>  a < c"; }
-
-        std::string typeString()const
-        {
-            return "Transitivity<"+type_to_string<Type>::apply()+","
-                                  +unary_template_to_string<Relation>::apply()+">";
-        }
-
-    public:
-
-        bool holds()
-        {
-            Type a = this->template getInputValue<operand_a>();
-            Type b = this->template getInputValue<operand_a>();
-            Type c = this->template getInputValue<operand_c>();
-
-            return !(Relation<Type>()(a,b) && Relation<Type>()(b,c)) || Relation<Type>()(a,c);
-        }
-
-        bool debug_holds(){ return holds(); }
-
-        size_t size()const 
-        { 
-            return value_size<Type>::apply(this->template getInputValue<operand_a>())+
-                value_size<Type>::apply(this->template getInputValue<operand_b>())+
-                value_size<Type>::apply(this->template getInputValue<operand_c>());
-        }
-    };
-
-}} // namespace itl boost
-
-#endif // __itl_order_h_JOFA_071129__
-

Modified: sandbox/itl/boost/validate/validater/interval_morphic_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/interval_morphic_validater.hpp	(original)
+++ sandbox/itl/boost/validate/validater/interval_morphic_validater.hpp	2009-02-10 09:56:24 EST (Tue, 10 Feb 2009)
@@ -16,7 +16,7 @@
 #include <boost/itl/functors.hpp>
 #include <boost/itl/interval_morphism.hpp>
 #include <boost/validate/laws/set_laws.hpp>
-#include <boost/validate/laws/order.h>
+#include <boost/validate/laws/order.hpp>
 #include <boost/validate/laws/pushouts.h>
 #include <boost/validate/validater/law_validater.hpp>
 #include <boost/validate/validater/algebra_validater.hpp>

Modified: sandbox/itl/boost/validate/validater/partial_order_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/partial_order_validater.hpp	(original)
+++ sandbox/itl/boost/validate/validater/partial_order_validater.hpp	2009-02-10 09:56:24 EST (Tue, 10 Feb 2009)
@@ -14,7 +14,7 @@
 #include <boost/itl/type_traits/is_continuous.hpp>
 #include <boost/itl/type_traits/has_inverse.hpp>
 #include <boost/itl/functors.hpp>
-#include <boost/validate/laws/order.h>
+#include <boost/validate/laws/order.hpp>
 #include <boost/validate/validater/law_validater.hpp>
 #include <boost/validate/validater/algebra_validater.hpp>
 

Modified: sandbox/itl/boost/validate/validater/strict_weak_order_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/strict_weak_order_validater.hpp	(original)
+++ sandbox/itl/boost/validate/validater/strict_weak_order_validater.hpp	2009-02-10 09:56:24 EST (Tue, 10 Feb 2009)
@@ -14,7 +14,7 @@
 #include <boost/itl/type_traits/is_continuous.hpp>
 #include <boost/itl/type_traits/has_inverse.hpp>
 #include <boost/itl/functors.hpp>
-#include <boost/validate/laws/order.h>
+#include <boost/validate/laws/order.hpp>
 #include <boost/validate/validater/law_validater.hpp>
 #include <boost/validate/validater/algebra_validater.hpp>