BELFEM 0.9.0
Berkeley Lab Finite Element Framework
Loading...
Searching...
No Matches
fn_BZ_dot.hpp
Go to the documentation of this file.
1//
2// Created by Christian Messe on 04.09.19.
3//
4
5#ifndef BELFEM_FN_BZ_DOT_HPP
6#define BELFEM_FN_BZ_DOT_HPP
7
8#include "cl_BZ_Vector.hpp"
9#include "cl_BZ_Matrix.hpp"
10
11namespace belfem
12{
13//------------------------------------------------------------------------------
14// BELFEM wrapper types: Vector<T> and Matrix<T>
15//------------------------------------------------------------------------------
16
17 template< typename T >
18 auto
19 dot( const Vector< T > & aA , const Vector< T > & aB )
20 -> decltype( blaze::dot( aA.vector_data() , aB.vector_data() ) )
21 {
22 return blaze::dot( aA.vector_data() , aB.vector_data() );
23 }
24
25// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
26
27 template< typename T >
28 auto
29 dot( const Matrix< T > & aA , const Vector< T > & aB )
30 -> decltype( blaze::dot( aA.matrix_data() , aB.vector_data() ) )
31 {
32 return blaze::dot( aA.matrix_data() , aB.vector_data() );
33 }
34
35// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
36
37 template< typename T >
38 auto
39 dot( const Vector< T > & aA , const Matrix< T > & aB )
40 -> decltype( blaze::dot( aA.vector_data() , aB.matrix_data() ) )
41 {
42 return blaze::dot( aA.vector_data() , aB.matrix_data() );
43 }
44
45//------------------------------------------------------------------------------
46// two Blaze expression types (Row, Column, DynamicVector, etc.)
47//------------------------------------------------------------------------------
48
49 template< typename ET1, typename ET2 >
50 auto
51 dot( const ET1 & aA, const ET2 & aB )
52 -> decltype( blaze::dot( aA , aB ) )
53 {
54 return blaze::dot( aA , aB );
55 }
56
57//------------------------------------------------------------------------------
58// single-row Rows matrix view: extract row vector via blaze::row()
59//------------------------------------------------------------------------------
60
61 template< typename MT, bool SO, bool SF, bool DF, typename ET >
62 auto
63 dot( const blaze::Rows< MT, SO, SF, DF > & aA, const ET & aB )
64 -> decltype( blaze::dot( blaze::row( aA, 0UL ), aB ) )
65 {
66 return blaze::dot( blaze::row( aA, 0UL ), aB );
67 }
68
69// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
70
71 template< typename ET, typename MT, bool SO, bool SF, bool DF >
72 auto
73 dot( const ET & aA, const blaze::Rows< MT, SO, SF, DF > & aB )
74 -> decltype( blaze::dot( aA, blaze::row( aB, 0UL ) ) )
75 {
76 return blaze::dot( aA, blaze::row( aB, 0UL ) );
77 }
78
79// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
80
81 template< typename MT1, bool SO1, bool SF1, bool DF1,
82 typename MT2, bool SO2, bool SF2, bool DF2 >
83 auto
84 dot( const blaze::Rows< MT1, SO1, SF1, DF1 > & aA,
85 const blaze::Rows< MT2, SO2, SF2, DF2 > & aB )
86 -> decltype( blaze::dot( blaze::row( aA, 0UL ), blaze::row( aB, 0UL ) ) )
87 {
88 return blaze::dot( blaze::row( aA, 0UL ), blaze::row( aB, 0UL ) );
89 }
90
91// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
92
93 template< typename MT, bool SO, bool SF, bool DF, typename T >
94 T
95 dot( const blaze::Rows< MT, SO, SF, DF > & aA, const Vector< T > & aB )
96 {
97 return blaze::dot( blaze::row( aA, 0UL ), aB.vector_data() );
98 }
99
100// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
101
102 template< typename T, typename MT, bool SO, bool SF, bool DF >
103 T
104 dot( const Vector< T > & aA, const blaze::Rows< MT, SO, SF, DF > & aB )
105 {
106 return blaze::dot( aA.vector_data(), blaze::row( aB, 0UL ) );
107 }
108
109//------------------------------------------------------------------------------
110// single-column Columns matrix view: extract column vector via blaze::column()
111//------------------------------------------------------------------------------
112
113 template< typename MT, bool SO, bool SF, bool DF, typename ET >
114 auto
115 dot( const blaze::Columns< MT, SO, SF, DF > & aA, const ET & aB )
116 -> decltype( blaze::dot( blaze::column( aA, 0UL ), aB ) )
117 {
118 return blaze::dot( blaze::column( aA, 0UL ), aB );
119 }
120
121// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
122
123 template< typename ET, typename MT, bool SO, bool SF, bool DF >
124 auto
125 dot( const ET & aA, const blaze::Columns< MT, SO, SF, DF > & aB )
126 -> decltype( blaze::dot( aA, blaze::column( aB, 0UL ) ) )
127 {
128 return blaze::dot( aA, blaze::column( aB, 0UL ) );
129 }
130
131// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
132
133 template< typename MT1, bool SO1, bool SF1, bool DF1,
134 typename MT2, bool SO2, bool SF2, bool DF2 >
135 auto
136 dot( const blaze::Columns< MT1, SO1, SF1, DF1 > & aA,
137 const blaze::Columns< MT2, SO2, SF2, DF2 > & aB )
138 -> decltype( blaze::dot( blaze::column( aA, 0UL ), blaze::column( aB, 0UL ) ) )
139 {
140 return blaze::dot( blaze::column( aA, 0UL ), blaze::column( aB, 0UL ) );
141 }
142
143// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
144
145 template< typename MT, bool SO, bool SF, bool DF, typename T >
146 T
147 dot( const blaze::Columns< MT, SO, SF, DF > & aA, const Vector< T > & aB )
148 {
149 return blaze::dot( blaze::column( aA, 0UL ), aB.vector_data() );
150 }
151
152// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
153
154 template< typename T, typename MT, bool SO, bool SF, bool DF >
155 T
156 dot( const Vector< T > & aA, const blaze::Columns< MT, SO, SF, DF > & aB )
157 {
158 return blaze::dot( aA.vector_data(), blaze::column( aB, 0UL ) );
159 }
160
161//------------------------------------------------------------------------------
162// cross-combinations: Rows × Columns (resolve ambiguity)
163//------------------------------------------------------------------------------
164
165 template< typename MT1, bool SO1, bool SF1, bool DF1,
166 typename MT2, bool SO2, bool SF2, bool DF2 >
167 auto
168 dot( const blaze::Rows< MT1, SO1, SF1, DF1 > & aA,
169 const blaze::Columns< MT2, SO2, SF2, DF2 > & aB )
170 -> decltype( blaze::dot( blaze::row( aA, 0UL ), blaze::column( aB, 0UL ) ) )
171 {
172 return blaze::dot( blaze::row( aA, 0UL ), blaze::column( aB, 0UL ) );
173 }
174
175// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
176
177 template< typename MT1, bool SO1, bool SF1, bool DF1,
178 typename MT2, bool SO2, bool SF2, bool DF2 >
179 auto
180 dot( const blaze::Columns< MT1, SO1, SF1, DF1 > & aA,
181 const blaze::Rows< MT2, SO2, SF2, DF2 > & aB )
182 -> decltype( blaze::dot( blaze::column( aA, 0UL ), blaze::row( aB, 0UL ) ) )
183 {
184 return blaze::dot( blaze::column( aA, 0UL ), blaze::row( aB, 0UL ) );
185 }
186
187//------------------------------------------------------------------------------
188// BELFEM Vector<T> with Blaze expression type
189//------------------------------------------------------------------------------
190
191 template< typename T, typename ET >
192 auto
193 dot( const Vector< T > & aA, const ET & aB )
194 -> decltype( blaze::dot( aA.vector_data(), aB ) )
195 {
196 return blaze::dot( aA.vector_data(), aB );
197 }
198
199// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
200
201 template< typename ET, typename T >
202 auto
203 dot( const ET & aA, const Vector< T > & aB )
204 -> decltype( blaze::dot( aA, aB.vector_data() ) )
205 {
206 return blaze::dot( aA, aB.vector_data() );
207 }
208
209//------------------------------------------------------------------------------
210}
211
212#endif //BELFEM_FN_BZ_DOT_HPP
cl_BZ_Matrix.hpp
cl_BZ_Vector.hpp
belfem::Matrix
Dense column-major matrix.
Definition cl_BZ_Matrix.hpp:28
belfem::Vector
Column vector.
Definition cl_BZ_Vector.hpp:41
belfem::Vector::vector_data
VectorType & vector_data()
expose the underlying matrix implementation ( writable version )
Definition cl_AR_Vector.hpp:204
belfem::dot
auto dot(const Vector< T > &aA, const Vector< T > &aB) -> decltype(arma::dot(aA.vector_data(), aB.vector_data()))
Scalar product of two vectors.
Definition fn_AR_dot.hpp:24
belfem
USER GUIDES:
Definition cl_Capacitor.cpp:16