← Back to branch summary

~ubuntu-branches/ubuntu/maverick/freecad/maverick

« back to all changes in this revision

Viewing changes to src/3rdParty/boost/numeric/bindings/traits/symm_herm_raw.hpp

  • Committer: Bazaar Package Importer
  • Author(s): Teemu Ikonen
  • Date: 2009-07-16 18:37:41 UTC
  • Revision ID: james.westby@ubuntu.com-20090716183741-oww9kcxqrk991i1n
Tags: upstream-0.8.2237
Import upstream version 0.8.2237

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/3rdParty/boost/numeric/bindings/traits/symm_herm_raw.hpp
 
1
//
 
2
//  Copyright (c) 2002-2003
 
3
//  Toon Knapen, Kresimir Fresl, Joerg Walter
 
4
//
 
5
// Distributed under the Boost Software License, Version 1.0. 
 
6
// (See accompanying file LICENSE_1_0.txt or copy at 
 
7
// http://www.boost.org/LICENSE_1_0.txt)
 
8
//
 
9
 
 
10
#ifndef BOOST_NUMERIC_BINDINGS_TRAITS_SYMM_HERM_RAW_HPP
 
11
#define BOOST_NUMERIC_BINDINGS_TRAITS_SYMM_HERM_RAW_HPP
 
12
 
 
13
#include <boost/numeric/bindings/traits/matrix_raw.hpp> 
 
14
#ifndef BOOST_UBLAS_HAVE_BINDINGS
 
15
#  include <boost/numeric/ublas/symmetric.hpp> 
 
16
#  include <boost/numeric/ublas/hermitian.hpp> 
 
17
#endif 
 
18
 
 
19
namespace boost { namespace numeric { namespace bindings { namespace traits {
 
20
 
 
21
  namespace ublas = boost::numeric::ublas; 
 
22
 
 
23
  template <typename M, typename F>
 
24
  BOOST_UBLAS_INLINE
 
25
  int leading_dimension (const ublas::symmetric_adaptor<M, F> &m) {
 
26
    return bindings::traits::leading_dimension (m.data());
 
27
  }
 
28
 
 
29
  template <typename M, typename F>
 
30
  BOOST_UBLAS_INLINE
 
31
  int leading_dimension (const ublas::hermitian_adaptor<M, F> &m) {
 
32
    return bindings::traits::leading_dimension (m.data());
 
33
  }
 
34
 
 
35
 
 
36
 
 
37
  template <typename M, typename F>
 
38
  BOOST_UBLAS_INLINE
 
39
  int matrix_storage_size (const ublas::symmetric_adaptor<M, F> &m) {
 
40
    return matrix_storage_size (m.data()); 
 
41
  }
 
42
 
 
43
  template <typename M, typename F>
 
44
  BOOST_UBLAS_INLINE
 
45
  int matrix_storage_size (const ublas::hermitian_adaptor<M, F> &m) {
 
46
    return matrix_storage_size (m.data()); 
 
47
  }
 
48
 
 
49
  template<typename T, typename F1, typename F2, typename A>
 
50
  BOOST_UBLAS_INLINE
 
51
  int matrix_storage_size (const ublas::symmetric_matrix<T,F1,F2,A> &m) {
 
52
    return (int) ((m.size1() * (m.size1() + 1)) / 2); 
 
53
  }
 
54
 
 
55
  template<typename T, typename F1, typename F2, typename A>
 
56
  BOOST_UBLAS_INLINE
 
57
  int matrix_storage_size (const ublas::hermitian_matrix<T,F1,F2,A> &m) {
 
58
    return (int) ((m.size1() * (m.size1() + 1)) / 2); 
 
59
  }
 
60
 
 
61
 
 
62
 
 
63
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
64
  template<typename T, typename F1, typename F2, typename A>
 
65
  BOOST_UBLAS_INLINE
 
66
  typename ublas::symmetric_matrix<T,F1,F2,A>::const_pointer 
 
67
  matrix_storage (const ublas::symmetric_matrix<T,F1,F2,A> &m) {
 
68
    return &m.data().begin()[0];
 
69
  }
 
70
#endif
 
71
  // We need data_const() mostly due to MSVC 6.0.
 
72
  // But how shall we write portable code otherwise?
 
73
  template<typename T, typename F1, typename F2, typename A>
 
74
  BOOST_UBLAS_INLINE
 
75
  typename ublas::symmetric_matrix<T,F1,F2,A>::const_pointer 
 
76
  matrix_storage_const (const ublas::symmetric_matrix<T,F1,F2,A> &m) {
 
77
    return &m.data().begin()[0];
 
78
  }
 
79
  template<typename T, typename F1, typename F2, typename A>
 
80
  BOOST_UBLAS_INLINE
 
81
  typename ublas::symmetric_matrix<T,F1,F2,A>::pointer 
 
82
  matrix_storage (ublas::symmetric_matrix<T,F1,F2,A> &m) {
 
83
    return &m.data().begin()[0];
 
84
  }
 
85
 
 
86
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
87
  template <typename M, typename F>
 
88
  BOOST_UBLAS_INLINE
 
89
  typename M::const_pointer 
 
90
  matrix_storage (const ublas::symmetric_adaptor<M, F> &m) {
 
91
    return matrix_storage (m.data()); 
 
92
  }
 
93
#endif
 
94
  // We need data_const() mostly due to MSVC 6.0.
 
95
  // But how shall we write portable code otherwise?
 
96
  template <typename M, typename F>
 
97
  BOOST_UBLAS_INLINE
 
98
  typename M::const_pointer 
 
99
  matrix_storage_const (const ublas::symmetric_adaptor<M, F> &m) {
 
100
    return matrix_storage_const (m.data()); 
 
101
  }
 
102
  template <typename M, typename F>
 
103
  BOOST_UBLAS_INLINE
 
104
  typename M::pointer matrix_storage (ublas::symmetric_adaptor<M, F> &m) {
 
105
    return matrix_storage (m.data()); 
 
106
  }
 
107
 
 
108
 
 
109
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
110
  template<typename T, typename F1, typename F2, typename A>
 
111
  BOOST_UBLAS_INLINE
 
112
  typename ublas::hermitian_matrix<T,F1,F2,A>::const_pointer 
 
113
  matrix_storage (const ublas::hermitian_matrix<T,F1,F2,A> &m) {
 
114
    return &m.data().begin()[0];
 
115
  }
 
116
#endif
 
117
  // We need data_const() mostly due to MSVC 6.0.
 
118
  // But how shall we write portable code otherwise?
 
119
  template<typename T, typename F1, typename F2, typename A>
 
120
  BOOST_UBLAS_INLINE
 
121
  typename ublas::hermitian_matrix<T,F1,F2,A>::const_pointer 
 
122
  matrix_storage_const (const ublas::hermitian_matrix<T,F1,F2,A> &m) {
 
123
    return &m.data().begin()[0];
 
124
  }
 
125
  template<typename T, typename F1, typename F2, typename A>
 
126
  BOOST_UBLAS_INLINE
 
127
  typename ublas::hermitian_matrix<T,F1,F2,A>::pointer 
 
128
  matrix_storage (ublas::hermitian_matrix<T,F1,F2,A> &m) {
 
129
    return &m.data().begin()[0];
 
130
  }
 
131
 
 
132
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
133
  template <typename M, typename F>
 
134
  BOOST_UBLAS_INLINE
 
135
  typename M::const_pointer 
 
136
  matrix_storage (const ublas::hermitian_adaptor<M, F> &m) {
 
137
    return matrix_storage (m.data()); 
 
138
  }
 
139
#endif
 
140
  // We need data_const() mostly due to MSVC 6.0.
 
141
  // But how shall we write portable code otherwise?
 
142
  template <typename M, typename F>
 
143
  BOOST_UBLAS_INLINE
 
144
  typename M::const_pointer 
 
145
  matrix_storage_const (const ublas::hermitian_adaptor<M, F> &m) {
 
146
    return matrix_storage_const (m.data()); 
 
147
  }
 
148
  template <typename M, typename F>
 
149
  BOOST_UBLAS_INLINE
 
150
  typename M::pointer matrix_storage (ublas::hermitian_adaptor<M, F> &m) {
 
151
    return matrix_storage (m.data()); 
 
152
  }
 
153
 
 
154
  namespace detail {
 
155
 
 
156
    inline char m_uplo_tag (ublas::upper_tag const&) { return 'U'; } 
 
157
    inline char m_uplo_tag (ublas::lower_tag const&) { return 'L'; } 
 
158
 
 
159
  }
 
160
 
 
161
  template <typename SymmM> 
 
162
  inline 
 
163
  char matrix_uplo_tag (SymmM&) {
 
164
      typedef typename SymmM::packed_category uplo_t; 
 
165
      return detail::m_uplo_tag (uplo_t());
 
166
  }
 
167
  
 
168
 
 
169
}}}}
 
170
 
 
171
#endif