matrix_assign.hpp

boost库提供标准的C++ API 配合dev c++使用,功能更加强大

    template<class F, class M, class E>
    // This function seems to be big. So we do not let the compiler inline it.
    // BOOST_UBLAS_INLINE
    void matrix_assign (F, M &m, const matrix_expression<E> &e, full, sparse_tag, column_major_tag) {
        BOOST_UBLAS_CHECK (m.size1 () == e ().size1 (), bad_size ());
        BOOST_UBLAS_CHECK (m.size2 () == e ().size2 (), bad_size ());
        typedef F functor_type;
        typedef typename M::value_type value_type;
#ifdef BOOST_UBLAS_TYPE_CHECK
        matrix<value_type, column_major> cm (m.size1 (), m.size2 ());
#ifndef BOOST_UBLAS_NO_ELEMENT_PROXIES
        indexing_matrix_assign (scalar_assign<typename matrix<value_type, column_major>::reference, value_type> (), cm, m, column_major_tag ());
        indexing_matrix_assign (functor_type::template make_debug_functor<typename matrix<value_type, column_major>::reference, value_type> (), cm, e, column_major_tag ());
#else
        indexing_matrix_assign (scalar_assign<value_type, value_type> (), cm, m, column_major_tag ());
        indexing_matrix_assign (functor_type (), cm, e, column_major_tag ());
#endif
#endif
        m.clear ();
        typename E::const_iterator2 it2e (e ().begin2 ());
        typename E::const_iterator2 it2e_end (e ().end2 ());
        while (it2e != it2e_end) {
#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
            typename E::const_iterator1 it1e (it2e.begin ());
            typename E::const_iterator1 it1e_end (it2e.end ());
#else
            typename E::const_iterator1 it1e (begin (it2e, iterator2_tag ()));
            typename E::const_iterator1 it1e_end (end (it2e, iterator2_tag ()));
#endif
            while (it1e != it1e_end) {
                value_type t (*it1e);
                if (t != value_type ())
                    m.insert (it1e.index1 (), it1e.index2 (), t);
                ++ it1e;
            }
            ++ it2e;
        }
#ifdef BOOST_UBLAS_TYPE_CHECK
        if (! disable_type_check)
            BOOST_UBLAS_CHECK (equals (m, cm), external_logic ());
#endif
    }
    // Sparse proxy row major case
    template<class F1, class M, class E, class F2>
    // This function seems to be big. So we do not let the compiler inline it.
    // BOOST_UBLAS_INLINE
    void matrix_assign (F1, M &m, const matrix_expression<E> &e, F2, sparse_proxy_tag, row_major_tag) {
        BOOST_UBLAS_CHECK (m.size1 () == e ().size1 (), bad_size ());
        BOOST_UBLAS_CHECK (m.size2 () == e ().size2 (), bad_size ());
        typedef F1 functor1_type;
        typedef F2 functor2_type;
        typedef typename M::size_type size_type;
        typedef typename M::value_type value_type;
#ifdef BOOST_UBLAS_TYPE_CHECK
        matrix<value_type, row_major> cm (m.size1 (), m.size2 ());
#ifndef BOOST_UBLAS_NO_ELEMENT_PROXIES
        indexing_matrix_assign (scalar_assign<typename matrix<value_type, row_major>::reference, value_type> (), cm, m, row_major_tag ());
        indexing_matrix_assign (functor1_type::template make_debug_functor<typename matrix<value_type, row_major>::reference, value_type> (), cm, e, row_major_tag ());
#else
        indexing_matrix_assign (scalar_assign<value_type, value_type> (), cm, m, row_major_tag ());
        indexing_matrix_assign (functor1_type (), cm, e, row_major_tag ());
#endif
#endif
        typename M::iterator1 it1 (m.begin1 ());
        typename M::iterator1 it1_end (m.end1 ());
        typename E::const_iterator1 it1e (e ().begin1 ());
        typename E::const_iterator1 it1e_end (e ().end1 ());
        while (it1 != it1_end && it1e != it1e_end) {
            int compare = it1.index1 () - it1e.index1 ();
            if (compare == 0) {
#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
                typename M::iterator2 it2 (it1.begin ());
                typename M::iterator2 it2_end (it1.end ());
                typename E::const_iterator2 it2e (it1e.begin ());
                typename E::const_iterator2 it2e_end (it1e.end ());
#else
                typename M::iterator2 it2 (begin (it1, iterator1_tag ()));
                typename M::iterator2 it2_end (end (it1, iterator1_tag ()));
                typename E::const_iterator2 it2e (begin (it1e, iterator1_tag ()));
                typename E::const_iterator2 it2e_end (end (it1e, iterator1_tag ()));
#endif
                while (it2 != it2_end && it2e != it2e_end) {
                    int compare = it2.index2 () - it2e.index2 ();
                    if (compare == 0) {
                        functor1_type () (*it2, *it2e);
                        ++ it2, ++ it2e;
                    } else if (compare < 0) {
                        functor1_type () (*it2, value_type ());
                        ++ it2;
                    } else if (compare > 0) {
#ifdef BOOST_UBLAS_NON_CONFORMANT_PROXIES
                        // Sparse proxies don't need to be conformant.
                        // Thanks to Michael Stevens for suggesting this.
                        size_type index1 (it2e.index1 ()), index2 (it2e.index2 ());
                        if (functor2_type::other (index1, index2)) {
                            // FIX: reduce fill in.
                            // functor1_type () (m (index1, index2), e () (index1, index2));
                            value_type t (*it2e);
                            if (t != value_type ()) {
                                functor1_type () (m (index1, index2), t);
                                restart (m, index1, index2, it1, it1_end, it2, it2_end, row_major_tag ());
                                // The proxies could reference the same container.
                                restart (e, index1, index2, it1e, it1e_end, it2e, it2e_end, row_major_tag ());
                            } else {
                                ++ it2e;
                            }
                        } else {
                            ++ it2e;
                        }
#else
                        ++ it2e;
#endif
                    }
                }
#ifdef BOOST_UBLAS_NON_CONFORMANT_PROXIES
                while (it2e != it2e_end) {
                    // Sparse proxies don't need to be conformant.
                    // Thanks to Michael Stevens for suggesting this.
                    size_type index1 (it2e.index1 ()), index2 (it2e.index2 ());
                    if (functor2_type::other (index1, index2)) {
                        // FIX: reduce fill in.
                        // functor1_type () (m (index1, index2), e () (index1, index2));
                        value_type t (*it2e);
                        if (t != value_type ()) {
                            functor1_type () (m (index1, index2), t);
                            // The proxies could reference the same container.
                            restart (e, index1, index2, it1e, it1e_end, it2e, it2e_end, row_major_tag ());
                            restart (m, index1, index2, it1, it1_end, it2, it2_end, row_major_tag ());
                        } else {
                            ++ it2e;
                        }
                    } else {
                        ++ it2e;
                    }
                }
#endif
                if (boost::is_same<BOOST_UBLAS_TYPENAME functor1_type::assign_category, assign_tag>::value) {
                    while (it2 != it2_end) {
                        functor1_type () (*it2, value_type ());
                        ++ it2;
                    }
                } else {
                    it2 = it2_end;
                }
                ++ it1, ++ it1e;
            } else if (compare < 0) {
#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
                typename M::iterator2 it2 (it1.begin ());
                typename M::iterator2 it2_end (it1.end ());
#else
                typename M::iterator2 it2 (begin (it1, iterator1_tag ()));
                typename M::iterator2 it2_end (end (it1, iterator1_tag ()));
#endif
                if (boost::is_same<BOOST_UBLAS_TYPENAME functor1_type::assign_category, assign_tag>::value) {
                    while (it2 != it2_end) {
                        functor1_type () (*it2, value_type ());
                        ++ it2;
                    }
                } else {
                    it2 = it2_end;
                }
                ++ it1;
            } else if (compare > 0) {
#ifdef BOOST_UBLAS_NON_CONFORMANT_PROXIES
                typename M::iterator2 it2;
                typename M::iterator2 it2_end;
#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
                typename E::const_iterator2 it2e (it1e.begin ());
                typename E::const_iterator2 it2e_end (it1e.end ());
#else
                typename E::const_iterator2 it2e (begin (it1e, iterator1_tag ()));
                typename E::const_iterator2 it2e_end (end (it1e, iterator1_tag ()));
#endif
                while (it2e != it2e_end) {
                    // Sparse proxies don't need to be conformant.
                    // Thanks to Michael Stevens for suggesting this.
                    size_type index1 (it2e.index1 ()), index2 (it2e.index2 ());
                    if (functor2_type::other (index1, index2)) {
                        // FIX: reduce fill in.
                        // functor1_type () (m (index1, index2), e () (index1, index2));
                        value_type t (*it2e);
                        if (t != value_type ()) {
                            functor1_type () (m (index1, index2), t);
                            // The proxies could reference the same container.
                            restart (e, index1, index2, it1e, it1e_end, it2e, it2e_end, row_major_tag ());
                            restart (m, index1, index2, it1, it1_end, it2, it2_end, row_major_tag ());
                        } else {
                            ++ it2e;
                        }
                    } else {
                        ++ it2e;
                    }
                }
#endif
                ++ it1e;
            }
        }
#ifdef BOOST_UBLAS_NON_CONFORMANT_PROXIES
        while (it1e != it1e_end) {
            typename M::iterator2 it2;
            typename M::iterator2 it2_end;
#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
            typename E::const_iterator2 it2e (it1e.begin ());
            typename E::const_iterator2 it2e_end (it1e.end ());
#else
            typename E::const_iterator2 it2e (begin (it1e, iterator1_tag ()));
            typename E::const_iterator2 it2e_end (end (it1e, iterator1_tag ()));
#endif
            while (it2e != it2e_end) {
                // Sparse proxies don't need to be conformant.
                // Thanks to Michael Stevens for suggesting this.
                size_type index1 (it2e.index1 ()), index2 (it2e.index2 ());
                if (functor2_type::other (index1, index2)) {
                    // FIX: reduce fill in.
                    // functor1_type () (m (index1, index2), e () (index1, index2));
                    value_type t (*it2e);
                    if (t != value_type ()) {
                        functor1_type () (m (index1, index2), t);
                        // The proxies could reference the same container.
                        restart (e, index1, index2, it1e, it1e_end, it2e, it2e_end, row_major_tag ());
                        restart (m, index1, index2, it1, it1_end, it2, it2_end, row_major_tag ());
                    } else {
                        ++ it2e;
                    }
                } else {
                    ++ it2e;
                }
            }
            ++ it1e;
        }
#endif
        if (boost::is_same<BOOST_UBLAS_TYPENAME functor1_type::assign_category, assign_tag>::value) {
            while (it1 != it1_end) {
#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
                typename M::iterator2 it2 (it1.begin ());
                typename M::iterator2 it2_end (it1.end ());
#else
                typename M::iterator2 it2 (begin (it1, iterator1_tag ()));
                typename M::iterator2 it2_end (end (it1, iterator1_tag ()));
#endif
                while (it2 != it2_end) {
                    functor1_type () (*it2, value_type ());
                    ++ it2;
                }
                ++ it1;
            }
        } else {
            it1 = it1_end;
        }
#ifdef BOOST_UBLAS_TYPE_CHECK
        if (! disable_type_check)
            BOOST_UBLAS_CHECK (equals (m, cm), external_logic ());
#endif
    }
    // Sparse proxy column major case
    template<class F1, class M, class E, class F2>
    // This function seems to be big. So we do not let the compiler inline it.
    // BOOST_UBLAS_INLINE
    void matrix_assign (F1, M &m, const matrix_expression<E> &e, F2, sparse_proxy_tag, column_major_tag) {
        BOOST_UBLAS_CHECK (m.size1 () == e ().size1 (), bad_size ());
        BOOST_UBLAS_CHECK (m.size2 () == e ().size2 (), bad_size ());
        typedef F1 functor1_type;
        typedef F2 functor2_type;
        typedef typename M::size_type size_type;
        typedef typename M::value_type value_type;
#ifdef BOOST_UBLAS_TYPE_CHECK
        matrix<value_type, column_major> cm (m.size1 (), m.size2 ());
#ifndef BOOST_UBLAS_NO_ELEMENT_PROXIES
        indexing_matrix_assign (scalar_assign<typename matrix<value_type, column_major>::reference, value_type> (), cm, m, column_major_tag ());
        indexing_matrix_assign (functor1_type::template make_debug_functor<typename matrix<value_type, column_major>::reference, value_type> (), cm, e, column_major_tag ());
#else
        indexing_matrix_assign (scalar_assign<value_type, value_type> (), cm, m, column_major_tag ());
        indexing_matrix_assign (functor1_type (), cm, e, column_major_tag ());