boost.cxx 0.0.2 → 1.90.1

package/boost/numeric/ublas/operation_blocked.hpp

@@ -0,0 +1,266 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under 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)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#ifndef _BOOST_UBLAS_OPERATION_BLOCKED_
+#define _BOOST_UBLAS_OPERATION_BLOCKED_
+
+#include <boost/numeric/ublas/traits.hpp>
+#include <boost/numeric/ublas/detail/vector_assign.hpp> // indexing_vector_assign
+#include <boost/numeric/ublas/detail/matrix_assign.hpp> // indexing_matrix_assign
+
+
+namespace boost { namespace numeric { namespace ublas {
+
+    template<class V, typename V::size_type BS, class E1, class E2>
+    BOOST_UBLAS_INLINE
+    V
+    block_prod (const matrix_expression<E1> &e1,
+                const vector_expression<E2> &e2) {
+        typedef V vector_type;
+        typedef const E1 expression1_type;
+        typedef const E2 expression2_type;
+        typedef typename V::size_type size_type;
+        typedef typename V::value_type value_type;
+        const size_type block_size = BS;
+
+        V v (e1 ().size1 ());
+#if BOOST_UBLAS_TYPE_CHECK
+        vector<value_type> cv (v.size ());
+        typedef typename type_traits<value_type>::real_type real_type;
+        real_type verrorbound (norm_1 (v) + norm_1 (e1) * norm_1 (e2));
+        indexing_vector_assign<scalar_assign> (cv, prod (e1, e2));
+#endif
+        size_type i_size = e1 ().size1 ();
+        size_type j_size = BOOST_UBLAS_SAME (e1 ().size2 (), e2 ().size ());
+        for (size_type i_begin = 0; i_begin < i_size; i_begin += block_size) {
+            size_type i_end = i_begin + (std::min) (i_size - i_begin, block_size);
+            // FIX: never ignore Martin Weiser's advice ;-(
+#ifdef BOOST_UBLAS_NO_CACHE
+            vector_range<vector_type> v_range (v, range (i_begin, i_end));
+#else
+            // vector<value_type, bounded_array<value_type, block_size> > v_range (i_end - i_begin);
+            vector<value_type> v_range (i_end - i_begin);
+#endif
+            v_range.assign (zero_vector<value_type> (i_end - i_begin));
+            for (size_type j_begin = 0; j_begin < j_size; j_begin += block_size) {
+                size_type j_end = j_begin + (std::min) (j_size - j_begin, block_size);
+#ifdef BOOST_UBLAS_NO_CACHE
+                const matrix_range<expression1_type> e1_range (e1 (), range (i_begin, i_end), range (j_begin, j_end));
+                const vector_range<expression2_type> e2_range (e2 (), range (j_begin, j_end));
+                v_range.plus_assign (prod (e1_range, e2_range));
+#else
+                // const matrix<value_type, row_major, bounded_array<value_type, block_size * block_size> > e1_range (project (e1 (), range (i_begin, i_end), range (j_begin, j_end)));
+                // const vector<value_type, bounded_array<value_type, block_size> > e2_range (project (e2 (), range (j_begin, j_end)));
+                const matrix<value_type, row_major> e1_range (project (e1 (), range (i_begin, i_end), range (j_begin, j_end)));
+                const vector<value_type> e2_range (project (e2 (), range (j_begin, j_end)));
+                v_range.plus_assign (prod (e1_range, e2_range));
+#endif
+            }
+#ifndef BOOST_UBLAS_NO_CACHE
+            project (v, range (i_begin, i_end)).assign (v_range);
+#endif
+        }
+#if BOOST_UBLAS_TYPE_CHECK
+        BOOST_UBLAS_CHECK (norm_1 (v - cv) <= 2 * std::numeric_limits<real_type>::epsilon () * verrorbound, internal_logic ());
+#endif
+        return v;
+    }
+
+    template<class V, typename V::size_type BS, class E1, class E2>
+    BOOST_UBLAS_INLINE
+    V
+    block_prod (const vector_expression<E1> &e1,
+                const matrix_expression<E2> &e2) {
+        typedef V vector_type;
+        typedef const E1 expression1_type;
+        typedef const E2 expression2_type;
+        typedef typename V::size_type size_type;
+        typedef typename V::value_type value_type;
+        const size_type block_size = BS;
+
+        V v (e2 ().size2 ());
+#if BOOST_UBLAS_TYPE_CHECK
+        vector<value_type> cv (v.size ());
+        typedef typename type_traits<value_type>::real_type real_type;
+        real_type verrorbound (norm_1 (v) + norm_1 (e1) * norm_1 (e2));
+        indexing_vector_assign<scalar_assign> (cv, prod (e1, e2));
+#endif
+        size_type i_size = BOOST_UBLAS_SAME (e1 ().size (), e2 ().size1 ());
+        size_type j_size = e2 ().size2 ();
+        for (size_type j_begin = 0; j_begin < j_size; j_begin += block_size) {
+            size_type j_end = j_begin + (std::min) (j_size - j_begin, block_size);
+            // FIX: never ignore Martin Weiser's advice ;-(
+#ifdef BOOST_UBLAS_NO_CACHE
+            vector_range<vector_type> v_range (v, range (j_begin, j_end));
+#else
+            // vector<value_type, bounded_array<value_type, block_size> > v_range (j_end - j_begin);
+            vector<value_type> v_range (j_end - j_begin);
+#endif
+            v_range.assign (zero_vector<value_type> (j_end - j_begin));
+            for (size_type i_begin = 0; i_begin < i_size; i_begin += block_size) {
+                size_type i_end = i_begin + (std::min) (i_size - i_begin, block_size);
+#ifdef BOOST_UBLAS_NO_CACHE
+                const vector_range<expression1_type> e1_range (e1 (), range (i_begin, i_end));
+                const matrix_range<expression2_type> e2_range (e2 (), range (i_begin, i_end), range (j_begin, j_end));
+#else
+                // const vector<value_type, bounded_array<value_type, block_size> > e1_range (project (e1 (), range (i_begin, i_end)));
+                // const matrix<value_type, column_major, bounded_array<value_type, block_size * block_size> > e2_range (project (e2 (), range (i_begin, i_end), range (j_begin, j_end)));
+                const vector<value_type> e1_range (project (e1 (), range (i_begin, i_end)));
+                const matrix<value_type, column_major> e2_range (project (e2 (), range (i_begin, i_end), range (j_begin, j_end)));
+#endif
+                v_range.plus_assign (prod (e1_range, e2_range));
+            }
+#ifndef BOOST_UBLAS_NO_CACHE
+            project (v, range (j_begin, j_end)).assign (v_range);
+#endif
+        }
+#if BOOST_UBLAS_TYPE_CHECK
+        BOOST_UBLAS_CHECK (norm_1 (v - cv) <= 2 * std::numeric_limits<real_type>::epsilon () * verrorbound, internal_logic ());
+#endif
+        return v;
+    }
+
+    template<class M, typename M::size_type BS, class E1, class E2>
+    BOOST_UBLAS_INLINE
+    M
+    block_prod (const matrix_expression<E1> &e1,
+                const matrix_expression<E2> &e2,
+                row_major_tag) {
+        typedef M matrix_type;
+        typedef const E1 expression1_type;
+        typedef const E2 expression2_type;
+        typedef typename M::size_type size_type;
+        typedef typename M::value_type value_type;
+        const size_type block_size = BS;
+
+        M m (e1 ().size1 (), e2 ().size2 ());
+#if BOOST_UBLAS_TYPE_CHECK
+        matrix<value_type, row_major> cm (m.size1 (), m.size2 ());
+        typedef typename type_traits<value_type>::real_type real_type;
+        real_type merrorbound (norm_1 (m) + norm_1 (e1) * norm_1 (e2));
+        indexing_matrix_assign<scalar_assign> (cm, prod (e1, e2), row_major_tag ());
+        disable_type_check<bool>::value = true;
+#endif
+        size_type i_size = e1 ().size1 ();
+        size_type j_size = e2 ().size2 ();
+        size_type k_size = BOOST_UBLAS_SAME (e1 ().size2 (), e2 ().size1 ());
+        for (size_type i_begin = 0; i_begin < i_size; i_begin += block_size) {
+            size_type i_end = i_begin + (std::min) (i_size - i_begin, block_size);
+            for (size_type j_begin = 0; j_begin < j_size; j_begin += block_size) {
+                size_type j_end = j_begin + (std::min) (j_size - j_begin, block_size);
+                // FIX: never ignore Martin Weiser's advice ;-(
+#ifdef BOOST_UBLAS_NO_CACHE
+                matrix_range<matrix_type> m_range (m, range (i_begin, i_end), range (j_begin, j_end));
+#else
+                // matrix<value_type, row_major, bounded_array<value_type, block_size * block_size> > m_range (i_end - i_begin, j_end - j_begin);
+                matrix<value_type, row_major> m_range (i_end - i_begin, j_end - j_begin);
+#endif
+                m_range.assign (zero_matrix<value_type> (i_end - i_begin, j_end - j_begin));
+                for (size_type k_begin = 0; k_begin < k_size; k_begin += block_size) {
+                    size_type k_end = k_begin + (std::min) (k_size - k_begin, block_size);
+#ifdef BOOST_UBLAS_NO_CACHE
+                    const matrix_range<expression1_type> e1_range (e1 (), range (i_begin, i_end), range (k_begin, k_end));
+                    const matrix_range<expression2_type> e2_range (e2 (), range (k_begin, k_end), range (j_begin, j_end));
+#else
+                    // const matrix<value_type, row_major, bounded_array<value_type, block_size * block_size> > e1_range (project (e1 (), range (i_begin, i_end), range (k_begin, k_end)));
+                    // const matrix<value_type, column_major, bounded_array<value_type, block_size * block_size> > e2_range (project (e2 (), range (k_begin, k_end), range (j_begin, j_end)));
+                    const matrix<value_type, row_major> e1_range (project (e1 (), range (i_begin, i_end), range (k_begin, k_end)));
+                    const matrix<value_type, column_major> e2_range (project (e2 (), range (k_begin, k_end), range (j_begin, j_end)));
+#endif
+                    m_range.plus_assign (prod (e1_range, e2_range));
+                }
+#ifndef BOOST_UBLAS_NO_CACHE
+                project (m, range (i_begin, i_end), range (j_begin, j_end)).assign (m_range);
+#endif
+            }
+        }
+#if BOOST_UBLAS_TYPE_CHECK
+        disable_type_check<bool>::value = false;
+        BOOST_UBLAS_CHECK (norm_1 (m - cm) <= 2 * std::numeric_limits<real_type>::epsilon () * merrorbound, internal_logic ());
+#endif
+        return m;
+    }
+
+    template<class M, typename M::size_type BS, class E1, class E2>
+    BOOST_UBLAS_INLINE
+    M
+    block_prod (const matrix_expression<E1> &e1,
+                const matrix_expression<E2> &e2,
+                column_major_tag) {
+        typedef M matrix_type;
+        typedef const E1 expression1_type;
+        typedef const E2 expression2_type;
+        typedef typename M::size_type size_type;
+        typedef typename M::value_type value_type;
+        const size_type block_size = BS;
+
+        M m (e1 ().size1 (), e2 ().size2 ());
+#if BOOST_UBLAS_TYPE_CHECK
+        matrix<value_type, column_major> cm (m.size1 (), m.size2 ());
+        typedef typename type_traits<value_type>::real_type real_type;
+        real_type merrorbound (norm_1 (m) + norm_1 (e1) * norm_1 (e2));
+        indexing_matrix_assign<scalar_assign> (cm, prod (e1, e2), column_major_tag ());
+        disable_type_check<bool>::value = true;
+#endif
+        size_type i_size = e1 ().size1 ();
+        size_type j_size = e2 ().size2 ();
+        size_type k_size = BOOST_UBLAS_SAME (e1 ().size2 (), e2 ().size1 ());
+        for (size_type j_begin = 0; j_begin < j_size; j_begin += block_size) {
+            size_type j_end = j_begin + (std::min) (j_size - j_begin, block_size);
+            for (size_type i_begin = 0; i_begin < i_size; i_begin += block_size) {
+                size_type i_end = i_begin + (std::min) (i_size - i_begin, block_size);
+                // FIX: never ignore Martin Weiser's advice ;-(
+#ifdef BOOST_UBLAS_NO_CACHE
+                matrix_range<matrix_type> m_range (m, range (i_begin, i_end), range (j_begin, j_end));
+#else
+                // matrix<value_type, column_major, bounded_array<value_type, block_size * block_size> > m_range (i_end - i_begin, j_end - j_begin);
+                matrix<value_type, column_major> m_range (i_end - i_begin, j_end - j_begin);
+#endif
+                m_range.assign (zero_matrix<value_type> (i_end - i_begin, j_end - j_begin));
+                for (size_type k_begin = 0; k_begin < k_size; k_begin += block_size) {
+                    size_type k_end = k_begin + (std::min) (k_size - k_begin, block_size);
+#ifdef BOOST_UBLAS_NO_CACHE
+                    const matrix_range<expression1_type> e1_range (e1 (), range (i_begin, i_end), range (k_begin, k_end));
+                    const matrix_range<expression2_type> e2_range (e2 (), range (k_begin, k_end), range (j_begin, j_end));
+#else
+                    // const matrix<value_type, row_major, bounded_array<value_type, block_size * block_size> > e1_range (project (e1 (), range (i_begin, i_end), range (k_begin, k_end)));
+                    // const matrix<value_type, column_major, bounded_array<value_type, block_size * block_size> > e2_range (project (e2 (), range (k_begin, k_end), range (j_begin, j_end)));
+                    const matrix<value_type, row_major> e1_range (project (e1 (), range (i_begin, i_end), range (k_begin, k_end)));
+                    const matrix<value_type, column_major> e2_range (project (e2 (), range (k_begin, k_end), range (j_begin, j_end)));
+#endif
+                    m_range.plus_assign (prod (e1_range, e2_range));
+                }
+#ifndef BOOST_UBLAS_NO_CACHE
+                project (m, range (i_begin, i_end), range (j_begin, j_end)).assign (m_range);
+#endif
+            }
+        }
+#if BOOST_UBLAS_TYPE_CHECK
+        disable_type_check<bool>::value = false;
+        BOOST_UBLAS_CHECK (norm_1 (m - cm) <= 2 * std::numeric_limits<real_type>::epsilon () * merrorbound, internal_logic ());
+#endif
+        return m;
+    }
+
+    // Dispatcher
+    template<class M, typename M::size_type BS, class E1, class E2>
+    BOOST_UBLAS_INLINE
+    M
+    block_prod (const matrix_expression<E1> &e1,
+                const matrix_expression<E2> &e2) {
+        typedef typename M::orientation_category orientation_category;
+        return block_prod<M, BS> (e1, e2, orientation_category ());
+    }
+
+}}}
+
+#endif

package/boost/numeric/ublas/operation_sparse.hpp

@@ -0,0 +1,198 @@
+//
+//  Copyright (c) 2000-2002
+//  Joerg Walter, Mathias Koch
+//
+//  Distributed under 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)
+//
+//  The authors gratefully acknowledge the support of
+//  GeNeSys mbH & Co. KG in producing this work.
+//
+
+#ifndef _BOOST_UBLAS_OPERATION_SPARSE_
+#define _BOOST_UBLAS_OPERATION_SPARSE_
+
+#include <boost/numeric/ublas/traits.hpp>
+
+// These scaled additions were borrowed from MTL unashamedly.
+// But Alexei Novakov had a lot of ideas to improve these. Thanks.
+
+namespace boost { namespace numeric { namespace ublas {
+
+    template<class M, class E1, class E2, class TRI>
+    BOOST_UBLAS_INLINE
+    M &
+    sparse_prod (const matrix_expression<E1> &e1,
+                 const matrix_expression<E2> &e2,
+                 M &m, TRI,
+                 row_major_tag) {
+        typedef M matrix_type;
+        typedef TRI triangular_restriction;
+        typedef const E1 expression1_type;
+        typedef const E2 expression2_type;
+        typedef typename M::size_type size_type;
+        typedef typename M::value_type value_type;
+
+        // ISSUE why is there a dense vector here?
+        vector<value_type> temporary (e2 ().size2 ());
+        temporary.clear ();
+        typename expression1_type::const_iterator1 it1 (e1 ().begin1 ());
+        typename expression1_type::const_iterator1 it1_end (e1 ().end1 ());
+        while (it1 != it1_end) {
+            size_type jb (temporary.size ());
+            size_type je (0);
+#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
+            typename expression1_type::const_iterator2 it2 (it1.begin ());
+            typename expression1_type::const_iterator2 it2_end (it1.end ());
+#else
+            typename expression1_type::const_iterator2 it2 (boost::numeric::ublas::begin (it1, iterator1_tag ()));
+            typename expression1_type::const_iterator2 it2_end (boost::numeric::ublas::end (it1, iterator1_tag ()));
+#endif
+            while (it2 != it2_end) {
+                // temporary.plus_assign (*it2 * row (e2 (), it2.index2 ()));
+                matrix_row<expression2_type> mr (e2 (), it2.index2 ());
+                typename matrix_row<expression2_type>::const_iterator itr (mr.begin ());
+                typename matrix_row<expression2_type>::const_iterator itr_end (mr.end ());
+                while (itr != itr_end) {
+                    size_type j (itr.index ());
+                    temporary (j) += *it2 * *itr;
+                    jb = (std::min) (jb, j);
+                    je = (std::max) (je, j);
+                    ++ itr;
+                }
+                ++ it2;
+            }
+            for (size_type j = jb; j < je + 1; ++ j) {
+                if (temporary (j) != value_type/*zero*/()) {
+                    // FIXME we'll need to extend the container interface!
+                    // m.push_back (it1.index1 (), j, temporary (j));
+                    // FIXME What to do with adaptors?
+                    // m.insert (it1.index1 (), j, temporary (j));
+                    if (triangular_restriction::other (it1.index1 (), j))
+                        m (it1.index1 (), j) = temporary (j);
+                    temporary (j) = value_type/*zero*/();
+                }
+            }
+            ++ it1;
+        }
+        return m;
+    }
+
+    template<class M, class E1, class E2, class TRI>
+    BOOST_UBLAS_INLINE
+    M &
+    sparse_prod (const matrix_expression<E1> &e1,
+                 const matrix_expression<E2> &e2,
+                 M &m, TRI,
+                 column_major_tag) {
+        typedef M matrix_type;
+        typedef TRI triangular_restriction;
+        typedef const E1 expression1_type;
+        typedef const E2 expression2_type;
+        typedef typename M::size_type size_type;
+        typedef typename M::value_type value_type;
+
+        // ISSUE why is there a dense vector here?
+        vector<value_type> temporary (e1 ().size1 ());
+        temporary.clear ();
+        typename expression2_type::const_iterator2 it2 (e2 ().begin2 ());
+        typename expression2_type::const_iterator2 it2_end (e2 ().end2 ());
+        while (it2 != it2_end) {
+            size_type ib (temporary.size ());
+            size_type ie (0);
+#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
+            typename expression2_type::const_iterator1 it1 (it2.begin ());
+            typename expression2_type::const_iterator1 it1_end (it2.end ());
+#else
+            typename expression2_type::const_iterator1 it1 (boost::numeric::ublas::begin (it2, iterator2_tag ()));
+            typename expression2_type::const_iterator1 it1_end (boost::numeric::ublas::end (it2, iterator2_tag ()));
+#endif
+            while (it1 != it1_end) {
+                // column (m, it2.index2 ()).plus_assign (*it1 * column (e1 (), it1.index1 ()));
+                matrix_column<expression1_type> mc (e1 (), it1.index1 ());
+                typename matrix_column<expression1_type>::const_iterator itc (mc.begin ());
+                typename matrix_column<expression1_type>::const_iterator itc_end (mc.end ());
+                while (itc != itc_end) {
+                    size_type i (itc.index ());
+                    temporary (i) += *it1 * *itc;
+                    ib = (std::min) (ib, i);
+                    ie = (std::max) (ie, i);
+                    ++ itc;
+                }
+                ++ it1;
+            }
+            for (size_type i = ib; i < ie + 1; ++ i) {
+                if (temporary (i) != value_type/*zero*/()) {
+                    // FIXME we'll need to extend the container interface!
+                    // m.push_back (i, it2.index2 (), temporary (i));
+                    // FIXME What to do with adaptors?
+                    // m.insert (i, it2.index2 (), temporary (i));
+                    if (triangular_restriction::other (i, it2.index2 ()))
+                        m (i, it2.index2 ()) = temporary (i);
+                    temporary (i) = value_type/*zero*/();
+                }
+            }
+            ++ it2;
+        }
+        return m;
+    }
+
+    // Dispatcher
+    template<class M, class E1, class E2, class TRI>
+    BOOST_UBLAS_INLINE
+    M &
+    sparse_prod (const matrix_expression<E1> &e1,
+                 const matrix_expression<E2> &e2,
+                 M &m, TRI, bool init = true) {
+        typedef typename M::value_type value_type;
+        typedef TRI triangular_restriction;
+        typedef typename M::orientation_category orientation_category;
+
+        if (init)
+            m.assign (zero_matrix<value_type> (e1 ().size1 (), e2 ().size2 ()));
+        return sparse_prod (e1, e2, m, triangular_restriction (), orientation_category ());
+    }
+    template<class M, class E1, class E2, class TRI>
+    BOOST_UBLAS_INLINE
+    M
+    sparse_prod (const matrix_expression<E1> &e1,
+                 const matrix_expression<E2> &e2,
+                 TRI) {
+        typedef M matrix_type;
+        typedef TRI triangular_restriction;
+
+        matrix_type m (e1 ().size1 (), e2 ().size2 ());
+        // FIXME needed for c_matrix?!
+        // return sparse_prod (e1, e2, m, triangular_restriction (), false);
+        return sparse_prod (e1, e2, m, triangular_restriction (), true);
+    }
+    template<class M, class E1, class E2>
+    BOOST_UBLAS_INLINE
+    M &
+    sparse_prod (const matrix_expression<E1> &e1,
+                 const matrix_expression<E2> &e2,
+                 M &m, bool init = true) {
+        typedef typename M::value_type value_type;
+        typedef typename M::orientation_category orientation_category;
+
+        if (init)
+            m.assign (zero_matrix<value_type> (e1 ().size1 (), e2 ().size2 ()));
+        return sparse_prod (e1, e2, m, full (), orientation_category ());
+    }
+    template<class M, class E1, class E2>
+    BOOST_UBLAS_INLINE
+    M
+    sparse_prod (const matrix_expression<E1> &e1,
+                 const matrix_expression<E2> &e2) {
+        typedef M matrix_type;
+
+        matrix_type m (e1 ().size1 (), e2 ().size2 ());
+        // FIXME needed for c_matrix?!
+        // return sparse_prod (e1, e2, m, full (), false);
+        return sparse_prod (e1, e2, m, full (), true);
+    }
+
+}}}
+
+#endif

package/boost/numeric/ublas/operations.hpp

@@ -0,0 +1,26 @@
+/**
+ * -*- c++ -*-
+ *
+ * \file operations.hpp
+ *
+ * \brief This header includes several headers from the operation directory.
+ *
+ * Copyright (c) 2009, Gunter Winkler
+ *
+ * Distributed under 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)
+ *
+ * \author Gunter Winkler (guwi17 at gmx dot de)
+ */
+
+#ifndef BOOST_NUMERIC_UBLAS_OPERATIONS_HPP
+#define BOOST_NUMERIC_UBLAS_OPERATIONS_HPP
+
+#include <boost/numeric/ublas/operation/begin.hpp>
+#include <boost/numeric/ublas/operation/end.hpp>
+#include <boost/numeric/ublas/operation/num_columns.hpp>
+#include <boost/numeric/ublas/operation/num_rows.hpp>
+#include <boost/numeric/ublas/operation/size.hpp>
+
+#endif