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