New URL for NEMO forge!   http://forge.nemo-ocean.eu

Since March 2022 along with NEMO 4.2 release, the code development moved to a self-hosted GitLab.
This present forge is now archived and remained online for history.
definitions.hpp in vendors/XIOS/current/extern/boost/include/boost/numeric/ublas/detail – NEMO

source: vendors/XIOS/current/extern/boost/include/boost/numeric/ublas/detail/definitions.hpp @ 3428

Last change on this file since 3428 was 3428, checked in by rblod, 12 years ago

importing initial XIOS vendor drop

File size: 6.4 KB
Line 
1//
2//  Copyright (c) 2000-2002
3//  Joerg Walter, Mathias Koch
4//
5//  Distributed under the Boost Software License, Version 1.0. (See
6//  accompanying file LICENSE_1_0.txt or copy at
7//  http://www.boost.org/LICENSE_1_0.txt)
8//
9//  The authors gratefully acknowledge the support of
10//  GeNeSys mbH & Co. KG in producing this work.
11//
12
13#ifndef _BOOST_UBLAS_DEFINITIONS_
14#define _BOOST_UBLAS_DEFINITIONS_
15
16
17namespace boost { namespace numeric { namespace ublas {
18
19    namespace detail {
20        /* Borrowed from boost/concept_checks.hpp
21           "inline" is used for ignore_unused_variable_warning()
22           to make sure there is no overhead with g++.
23         */
24        template <class T> inline
25        void ignore_unused_variable_warning(const T&) {}
26    } // namespace detail
27
28    // Borrowed from Dave Abraham's noncopyable.
29    // I believe this should be part of utility.hpp one day...
30    namespace nonassignable_  // protection from unintended ADL
31    {
32        class nonassignable {
33        protected:
34            nonassignable () {}
35            ~nonassignable () {}
36        private:  // emphasize the following members are private
37            const nonassignable& operator= (const nonassignable &);
38        }; // nonassignable
39    }
40    typedef nonassignable_::nonassignable nonassignable;
41
42
43    // Assignment proxy.
44    // Provides temporary free assigment when LHS has no alias on RHS
45    template<class C>
46    class noalias_proxy:
47        private nonassignable {
48    public:
49        typedef typename C::closure_type closure_type;
50
51        BOOST_UBLAS_INLINE
52        noalias_proxy (C& lval):
53            nonassignable (), lval_ (lval) {}
54        BOOST_UBLAS_INLINE
55        noalias_proxy (const noalias_proxy& p):
56            nonassignable (), lval_ (p.lval_) {}
57
58        template <class E>
59        BOOST_UBLAS_INLINE
60        closure_type &operator= (const E& e) {
61            lval_.assign (e);
62            return lval_;
63        }
64
65        template <class E>
66        BOOST_UBLAS_INLINE
67        closure_type &operator+= (const E& e) {
68            lval_.plus_assign (e);
69            return lval_;
70        }
71
72        template <class E>
73        BOOST_UBLAS_INLINE
74        closure_type &operator-= (const E& e) {
75            lval_.minus_assign (e);
76            return lval_;
77        }
78
79    private:
80        closure_type lval_;
81    };
82
83    // Improve syntax of efficient assignment where no aliases of LHS appear on the RHS
84    //  noalias(lhs) = rhs_expression
85    template <class C>
86    BOOST_UBLAS_INLINE
87    noalias_proxy<C> noalias (C& lvalue) {
88        return noalias_proxy<C> (lvalue);
89    }
90    template <class C>
91    BOOST_UBLAS_INLINE
92    noalias_proxy<const C> noalias (const C& lvalue) {
93        return noalias_proxy<const C> (lvalue);
94    }
95
96    // Possible future compatible syntax where lvalue possible has an unsafe alias on the RHS
97    //  safe(lhs) = rhs_expression
98    template <class C>
99    BOOST_UBLAS_INLINE
100    C& safe (C& lvalue) {
101        return lvalue;
102    }
103    template <class C>
104    BOOST_UBLAS_INLINE
105    const C& safe (const C& lvalue) {
106        return lvalue;
107    }
108
109
110    // Dimension accessors
111    namespace dimension {
112
113        // Generic accessors
114        template<unsigned dimension>
115        struct dimension_properties {};
116       
117        template<>
118        struct dimension_properties<1> {
119            template <class E>
120            BOOST_UBLAS_INLINE static
121            typename E::size_type size (const vector_expression<E> &e) {
122                return e ().size ();
123            }
124            template <class E>
125            BOOST_UBLAS_INLINE static
126            typename E::size_type size (const matrix_expression<E> &e) {
127                return e ().size1 ();
128            }
129            // Note: Index functions cannot deduce dependant template parameter V or M from i
130            template <class V>
131            BOOST_UBLAS_INLINE static
132            typename V::size_type index (const typename V::iterator &i) {
133                return i.index ();
134            }
135            template <class M>
136            BOOST_UBLAS_INLINE static
137            typename M::size_type index (const typename M::iterator1 &i) {
138                return i.index1 ();
139            }
140            template <class M>
141            BOOST_UBLAS_INLINE static
142            typename M::size_type index (const typename M::iterator2 &i) {
143                return i.index1 ();
144            }
145        };
146        template<>
147        struct dimension_properties<2> {
148            template <class E>
149            BOOST_UBLAS_INLINE static
150            typename E::size_type size (const vector_expression<E> &) {
151                return 1;
152            }
153            template <class E>
154            BOOST_UBLAS_INLINE static
155            typename E::size_type size (const matrix_expression<E> &e) {
156                return e ().size2 ();
157            }
158            template <class V>
159            BOOST_UBLAS_INLINE static
160            typename V::size_type index (const typename V::iterator &) {
161                return 1;
162            }
163            template <class M>
164            BOOST_UBLAS_INLINE static
165            typename M::size_type index (const typename M::iterator1 &i) {
166                return i.index2 ();
167            }
168            template <class M>
169            BOOST_UBLAS_INLINE static
170            typename M::size_type index (const typename M::iterator2 &i) {
171                return i.index2 ();
172            }
173        };
174
175        template<unsigned dimension, class E>
176        BOOST_UBLAS_INLINE
177        typename E::size_type size (const E& e) {
178            return dimension_properties<dimension>::size (e);
179        }
180
181        template<unsigned dimension, class I>
182        BOOST_UBLAS_INLINE
183        typename I::container_type::size_type
184        index (const I& i) {
185            typedef typename I::container_type container_type;
186            return dimension_properties<dimension>::template index<container_type> (i);
187        }
188
189
190        // Named accessors - just syntactic sugar
191        template<class V>
192        typename V::size_type num_elements (const V &v) {
193            return v.size ();
194        }
195        template<class M>
196        typename M::size_type num_rows (const M &m) {
197            return m.size1 ();
198        }
199        template<class M>
200        typename M::size_type num_columns (const M &m) {
201            return m.size2 ();
202        }
203        template<class MV>
204        typename MV::size_type num_non_zeros (const MV &mv) {
205            return mv.non_zeros ();
206        }
207    }
208
209
210}}}
211
212#endif
Note: See TracBrowser for help on using the repository browser.