diff --git a/include/boost/range/concepts.hpp b/include/boost/range/concepts.hpp
new file mode 100755
index 0000000..c19766c
--- /dev/null
+++ b/include/boost/range/concepts.hpp
@@ -0,0 +1,155 @@
+// Boost.Range library concept checks
+//
+//  Copyright Daniel Walker 2006. Use, modification and distribution
+//  are subject to the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+
+#ifndef BOOST_RANGE_CONCEPTS_HPP
+#define BOOST_RANGE_CONCEPTS_HPP
+
+#include <boost/concept_check.hpp>
+#include <boost/iterator/iterator_concepts.hpp>
+#include <boost/range/functions.hpp>
+#include <boost/range/metafunctions.hpp>
+
+/*!
+ * \file
+ * \brief Concept checks for the Boost Range library.
+ *
+ * The structures in this file may be used in conjunction with the
+ * Boost Concept Check library to insure that the type of a function
+ * parameter is compatible with a range concept. If not, a meaningful
+ * compile time error is generated. Checks are provided for the range
+ * concepts related to iterator traversal categories. For example, the
+ * following line checks that the type T models the ForwardRange
+ * concept.
+ *
+ * \code
+ * function_requires<ForwardRangeConcept<T> >();
+ * \endcode
+ *
+ * An additional concept check is required for the value access
+ * property of the range. For example to check for a
+ * ForwardReadableRange, the following code is required.
+ *
+ * \code
+ * function_requires<ForwardRangeConcept<T> >();
+ * function_requires<
+ *     ReadableIteratorConcept<
+ *         typename range_iterator<T>::type
+ *     >
+ * >();
+ * \endcode
+ *
+ * \see http://www.boost.org/libs/range/doc/range.html for details
+ * about range concepts.
+ * \see http://www.boost.org/libs/iterator/doc/iterator_concepts.html
+ * for details about iterator concepts.
+ * \see http://www.boost.org/libs/concept_check/concept_check.htm for
+ * details about concept checks.
+ */
+
+namespace boost {
+
+    //! Check if a type T models the SinglePassRange range concept.
+    template<typename T>
+    struct SinglePassRangeConcept {
+        typedef typename range_value<T>::type range_value;
+        typedef typename range_iterator<T>::type range_iterator;
+        typedef typename range_const_iterator<T>::type range_const_iterator;
+        void constraints()
+        {
+            function_requires<
+                boost_concepts::SinglePassIteratorConcept<
+                    range_iterator
+                >
+            >();
+            i = begin(a);
+            i = end(a);
+            b = empty(a);
+            const_constraints(a);
+        }
+        void const_constraints(const T& a)
+        {
+            ci = begin(a);
+            ci = end(a);
+        }
+        T a;
+        range_iterator i;
+        range_const_iterator ci;
+        bool b;
+    };
+
+    //! Check if a type T models the ForwardRange range concept.
+    template<typename T>
+    struct ForwardRangeConcept {
+        typedef typename range_difference<T>::type range_difference;
+        typedef typename range_size<T>::type range_size;
+        void constraints()
+        {
+            function_requires<
+                SinglePassRangeConcept<T>
+            >();        
+            function_requires<
+                boost_concepts::ForwardTraversalConcept<
+                    typename range_iterator<T>::type
+                >
+            >();
+            s = size(a);
+        }
+        T a;
+        range_size s;
+    };
+
+    //! Check if a type T models the BidirectionalRange range concept.
+    template<typename T>
+    struct BidirectionalRangeConcept {
+        typedef typename range_reverse_iterator<T>::type range_reverse_iterator;
+        typedef typename range_const_reverse_iterator<T>::type range_const_reverse_iterator;
+        void constraints()
+        {
+            function_requires<
+                    ForwardRangeConcept<T>
+            >();        
+            function_requires<
+                boost_concepts::BidirectionalTraversalConcept<
+                    typename range_iterator<T>::type
+                >
+            >();
+            i = rbegin(a);
+            i = rend(a);
+            const_constraints(a);
+            }
+        void const_constraints(const T& a)
+        {
+            ci = rbegin(a);
+            ci = rend(a);
+        }
+        T a;
+        range_reverse_iterator i;
+        range_const_reverse_iterator ci;
+    };
+
+    //! Check if a type T models the RandomAccessRange range concept.
+    template<typename T>
+    struct RandomAccessRangeConcept {
+        void constraints()
+        {
+            function_requires<
+                BidirectionalRangeConcept<T>
+            >();        
+            function_requires<
+                boost_concepts::RandomAccessTraversalConcept<
+                    typename range_iterator<T>::type
+                >
+            >();
+            }
+    };
+
+} // namespace boost
+
+#endif // BOOST_RANGE_CONCEPTS_HPP