STK++ 0.9.13
Public Types | Static Public Member Functions | List of all members
STK::hidden::MultCoefImpl< Lhs, Rhs, Result > Struct Template Reference
Hidden implementation details

This structure regroup the methods to used after block multiplication in order to perform the product of the remaining rows and columns. More...

#include <STK_ProductRaw.h>

Public Types

typedef Result::Type Type
 

Static Public Member Functions

static void dot (Lhs const &lhs, Rhs const &rhs, Result &res, int i, int j)
 dot product.
 
static void dot (Lhs const &lhs, ITContainer< Rhs, Arrays::vector_ > const &rhs, Result &res, int i)
 dot product.
 
static void dot (ITContainer< Lhs, Arrays::point_ > const &lhs, Rhs const &rhs, Result &res, int j)
 dot product.
 
static bool multDispatcher (Lhs const &lhs, Rhs const &rhs, Result &res)
 
static void mul1XX (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Lhs having 1 row
 
static void mul2XX (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Lhs having 2 rows
 
static void mul3XX (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Lhs having 3 rows
 
static void mul4XX (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Lhs having 4 rows
 
static void mul5XX (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Lhs having 5 rows
 
static void mul6XX (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Lhs having 6 rows
 
static void mul7XX (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Lhs having 7 rows
 
static void mulX1X (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Lhs having 1 column and Rhs having 1 row
 
static void mulX2X (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Lhs having 2 columns and Rhs having 2 rows
 
static void mulX3X (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Lhs having 3 columns and Rhs having 3 rows
 
static void mulX4X (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Lhs having 4 columns and Rhs having 4 rows
 
static void mulX5X (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Lhs having 5 columns and Rhs having 5 rows
 
static void mulX6X (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Lhs having 6 columns and Rhs having 6 rows
 
static void mulX7X (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Lhs having 7 columns and Rhs having 7 rows
 
static void mulXX1 (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Rhs having 1 column
 
static void mulXX2 (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Rhs having 2 columns
 
static void mulXX3 (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Rhs having 3 columns
 
static void mulXX4 (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Rhs having 4 columns
 
static void mulXX5 (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Rhs having 5 columns
 
static void mulXX6 (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Rhs having 6 columns
 
static void mulXX7 (Lhs const &lhs, Rhs const &rhs, Result &res)
 multiplication with Rhs having 7 columns
 
static void mult1Outer (Lhs const &lhs, Rhs const &rhs, Result &res, int k)
 multiplication with one outer rows/columns
 
static void mult2Outer (Lhs const &lhs, Rhs const &rhs, Result &res, int k)
 multiplication with two outer rows/columns
 
static void mult3Outer (Lhs const &lhs, Rhs const &rhs, Result &res, int k)
 multiplication with three outer rows/columns
 

Detailed Description

template<typename Lhs, typename Rhs, typename Result>
struct STK::hidden::MultCoefImpl< Lhs, Rhs, Result >

This structure regroup the methods to used after block multiplication in order to perform the product of the remaining rows and columns.

Definition at line 90 of file STK_ProductRaw.h.

Member Typedef Documentation

◆ Type

template<typename Lhs , typename Rhs , typename Result >
typedef Result::Type STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::Type

Definition at line 92 of file STK_ProductRaw.h.

Member Function Documentation

◆ dot() [1/3]

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::dot ( ITContainer< Lhs, Arrays::point_ > const &  lhs,
Rhs const &  rhs,
Result &  res,
int  j 
)
inlinestatic

dot product.

point by general

Definition at line 109 of file STK_ProductRaw.h.

110 {
111 Range const dotRange = inf(rhs.rangeRowsInCol(j), lhs.range());
112 for (int k=dotRange.begin(); k< dotRange.end(); ++k)
113 res.elt(j) += lhs.elt(k) * rhs.elt(k, j);
114 }
STK::inf
Range inf(TRange< SizeI_ > const &I, TRange< SizeJ_ > const &J)
compute inf(I,J).
Definition STK_Range.h:477
STK::Range
TRange< UnknownSize > Range
Definition STK_Range.h:59

References STK::inf().

◆ dot() [2/3]

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::dot ( Lhs const &  lhs,
ITContainer< Rhs, Arrays::vector_ > const &  rhs,
Result &  res,
int  i 
)
inlinestatic

dot product.

general by vector

Definition at line 102 of file STK_ProductRaw.h.

103 {
104 Range const dotRange = inf(lhs.rangeColsInRow(i), rhs.range());
105 for (int k=dotRange.begin(); k< dotRange.end(); ++k)
106 res.elt(i) += lhs.elt(i, k) * rhs.elt(k);
107 }

References STK::inf().

◆ dot() [3/3]

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::dot ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res,
int  i,
int  j 
)
inlinestatic

dot product.

general by general

Definition at line 95 of file STK_ProductRaw.h.

96 {
97 Range const dotRange = inf(lhs.rangeColsInRow(i), rhs.rangeRowsInCol(j));
98 for (int k=dotRange.begin(); k< dotRange.end(); ++k)
99 res.elt(i, j) += lhs.elt(i, k) * rhs.elt(k, j);
100 }

References STK::inf().

◆ mul1XX()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mul1XX ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Lhs having 1 row

Definition at line 158 of file STK_ProductRaw.h.

159 {
160 int const lhsRow = lhs.beginRows();
161 for (int j=rhs.beginCols(); j< rhs.endCols(); ++j)
162 for (int k=rhs.beginRows(); k< rhs.endRows(); ++k)
163 res.elt(lhsRow, j) += lhs.elt(lhsRow, k) * rhs.elt(k, j);
164 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

◆ mul2XX()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mul2XX ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Lhs having 2 rows

Definition at line 166 of file STK_ProductRaw.h.

167 {
168 int const i = lhs.beginRows();
169 for (int j=rhs.beginCols(); j< rhs.endCols(); ++j)
170 for (int k=rhs.beginRows(); k< rhs.endRows(); ++k)
171 {
172 res.elt(i , j) += lhs.elt(i , k) * rhs.elt(k, j);
173 res.elt(i+1, j) += lhs.elt(i+1, k) * rhs.elt(k, j);
174 }
175 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

◆ mul3XX()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mul3XX ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Lhs having 3 rows

Definition at line 177 of file STK_ProductRaw.h.

178 {
179 int const i = lhs.beginRows();
180 for (int j=rhs.beginCols(); j< rhs.endCols(); ++j)
181 for (int k=rhs.beginRows(); k< rhs.endRows(); ++k)
182 {
183 res.elt(i , j) += lhs.elt(i , k) * rhs.elt(k, j);
184 res.elt(i+1, j) += lhs.elt(i+1, k) * rhs.elt(k, j);
185 res.elt(i+2, j) += lhs.elt(i+2, k) * rhs.elt(k, j);
186 }
187 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

◆ mul4XX()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mul4XX ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Lhs having 4 rows

Definition at line 189 of file STK_ProductRaw.h.

190 {
191 int const i = lhs.beginRows();
192 for (int j=rhs.beginCols(); j< rhs.endCols(); ++j)
193 for (int k=rhs.beginRows(); k< rhs.endRows(); ++k)
194 {
195 res.elt(i , j) += lhs.elt(i , k) * rhs.elt(k, j);
196 res.elt(i+1, j) += lhs.elt(i+1, k) * rhs.elt(k, j);
197 res.elt(i+2, j) += lhs.elt(i+2, k) * rhs.elt(k, j);
198 res.elt(i+3, j) += lhs.elt(i+3, k) * rhs.elt(k, j);
199 }
200 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

◆ mul5XX()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mul5XX ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Lhs having 5 rows

Definition at line 202 of file STK_ProductRaw.h.

203 {
204 int const i = lhs.beginRows();
205 for (int j=rhs.beginCols(); j< rhs.endCols(); ++j)
206 for (int k=rhs.beginRows(); k< rhs.endRows(); ++k)
207 {
208 res.elt(i , j) += lhs.elt(i , k) * rhs.elt(k, j);
209 res.elt(i+1, j) += lhs.elt(i+1, k) * rhs.elt(k, j);
210 res.elt(i+2, j) += lhs.elt(i+2, k) * rhs.elt(k, j);
211 res.elt(i+3, j) += lhs.elt(i+3, k) * rhs.elt(k, j);
212 res.elt(i+4, j) += lhs.elt(i+4, k) * rhs.elt(k, j);
213 }
214 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

◆ mul6XX()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mul6XX ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Lhs having 6 rows

Definition at line 216 of file STK_ProductRaw.h.

217 {
218 int const i = lhs.beginRows();
219 for (int j=rhs.beginCols(); j< rhs.endCols(); ++j)
220 for (int k=rhs.beginRows(); k< rhs.endRows(); ++k)
221 {
222 res.elt(i , j) += lhs.elt(i , k) * rhs.elt(k, j);
223 res.elt(i+1, j) += lhs.elt(i+1, k) * rhs.elt(k, j);
224 res.elt(i+2, j) += lhs.elt(i+2, k) * rhs.elt(k, j);
225 res.elt(i+3, j) += lhs.elt(i+3, k) * rhs.elt(k, j);
226 res.elt(i+4, j) += lhs.elt(i+4, k) * rhs.elt(k, j);
227 res.elt(i+5, j) += lhs.elt(i+5, k) * rhs.elt(k, j);
228 }
229 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

◆ mul7XX()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mul7XX ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Lhs having 7 rows

Definition at line 231 of file STK_ProductRaw.h.

232 {
233 int const i = lhs.beginRows();
234 for (int j=rhs.beginCols(); j< rhs.endCols(); ++j)
235 for (int k=rhs.beginRows(); k< rhs.endRows(); ++k)
236 {
237 res.elt(i , j) += lhs.elt(i , k) * rhs.elt(k, j);
238 res.elt(i+1, j) += lhs.elt(i+1, k) * rhs.elt(k, j);
239 res.elt(i+2, j) += lhs.elt(i+2, k) * rhs.elt(k, j);
240 res.elt(i+3, j) += lhs.elt(i+3, k) * rhs.elt(k, j);
241 res.elt(i+4, j) += lhs.elt(i+4, k) * rhs.elt(k, j);
242 res.elt(i+5, j) += lhs.elt(i+5, k) * rhs.elt(k, j);
243 res.elt(i+6, j) += lhs.elt(i+6, k) * rhs.elt(k, j);
244 }
245 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

◆ mult1Outer()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mult1Outer ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res,
int  k 
)
inlinestatic

multiplication with one outer rows/columns

Definition at line 425 of file STK_ProductRaw.h.

426 {
427 for (int i=lhs.beginRows(); i< lhs.endRows(); ++i)
428 for (int j=rhs.beginCols(); j< rhs.endCols(); ++j)
429 res.elt(i,j) += lhs.elt(i, k) * rhs.elt(k, j);
430 }

Referenced by STK::hidden::BlockByPanel< Lhs, Rhs, Result >::run(), STK::hidden::PanelByBlock< Lhs, Rhs, Result >::run(), STK::hidden::BlockPanelProduct< Lhs, Rhs, Result >::run(), and STK::hidden::PanelBlockProduct< Lhs, Rhs, Result >::run().

◆ mult2Outer()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mult2Outer ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res,
int  k 
)
inlinestatic

multiplication with two outer rows/columns

Definition at line 432 of file STK_ProductRaw.h.

433 {
434 for (int i=lhs.beginRows(); i< lhs.endRows(); ++i)
435 for (int j=rhs.beginCols(); j< rhs.endCols(); ++j)
436 res.elt(i,j) += lhs.elt(i, k ) * rhs.elt(k, j)
437 + lhs.elt(i, k+1) * rhs.elt(k+1, j);
438 }

Referenced by STK::hidden::BlockByPanel< Lhs, Rhs, Result >::run(), STK::hidden::PanelByBlock< Lhs, Rhs, Result >::run(), STK::hidden::BlockPanelProduct< Lhs, Rhs, Result >::run(), and STK::hidden::PanelBlockProduct< Lhs, Rhs, Result >::run().

◆ mult3Outer()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mult3Outer ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res,
int  k 
)
inlinestatic

multiplication with three outer rows/columns

Definition at line 440 of file STK_ProductRaw.h.

441 {
442 for (int i=lhs.beginRows(); i< lhs.endRows(); ++i)
443 for (int j=rhs.beginCols(); j< rhs.endCols(); ++j)
444 res.elt(i,j) += lhs.elt(i, k ) * rhs.elt(k, j)
445 + lhs.elt(i, k+1) * rhs.elt(k+1, j)
446 + lhs.elt(i, k+2) * rhs.elt(k+2, j);
447 }

Referenced by STK::hidden::BlockByPanel< Lhs, Rhs, Result >::run(), STK::hidden::PanelByBlock< Lhs, Rhs, Result >::run(), STK::hidden::BlockPanelProduct< Lhs, Rhs, Result >::run(), and STK::hidden::PanelBlockProduct< Lhs, Rhs, Result >::run().

◆ multDispatcher()

template<typename Lhs , typename Rhs , typename Result >
static bool STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

Definition at line 116 of file STK_ProductRaw.h.

117 {
118 // small sizes
119 switch (lhs.sizeRows())
120 {
121 case 0: return true;
122 case 1: mul1XX(lhs, rhs, res); return true;
123 case 2: mul2XX(lhs, rhs, res); return true;
124 case 3: mul3XX(lhs, rhs, res); return true;
125 case 4: mul4XX(lhs, rhs, res); return true;
126 case 5: mul5XX(lhs, rhs, res); return true;
127 case 6: mul6XX(lhs, rhs, res); return true;
128 case 7: mul7XX(lhs, rhs, res); return true;
129 default: break;
130 }
131 switch (lhs.sizeCols())
132 {
133 case 0: return true; break;
134 case 1: mulX1X(lhs, rhs, res); return true;
135 case 2: mulX2X(lhs, rhs, res); return true;
136 case 3: mulX3X(lhs, rhs, res); return true;
137 case 4: mulX4X(lhs, rhs, res); return true;
138 case 5: mulX5X(lhs, rhs, res); return true;
139 case 6: mulX6X(lhs, rhs, res); return true;
140 case 7: mulX7X(lhs, rhs, res); return true;
141 default: break;
142 }
143 switch (rhs.sizeCols())
144 {
145 case 0: return true;
146 case 1: mulXX1(lhs, rhs, res); return true;
147 case 2: mulXX2(lhs, rhs, res); return true;
148 case 3: mulXX3(lhs, rhs, res); return true;
149 case 4: mulXX4(lhs, rhs, res); return true;
150 case 5: mulXX5(lhs, rhs, res); return true;
151 case 6: mulXX6(lhs, rhs, res); return true;
152 case 7: mulXX7(lhs, rhs, res); return true;
153 default: break;
154 }
155 return false;
156 }
STK::hidden::MultCoefImpl::mulXX5
static void mulXX5(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Rhs having 5 columns
Definition STK_ProductRaw.h:380
STK::hidden::MultCoefImpl::mulX4X
static void mulX4X(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Lhs having 4 columns and Rhs having 4 rows
Definition STK_ProductRaw.h:278
STK::hidden::MultCoefImpl::mulXX7
static void mulXX7(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Rhs having 7 columns
Definition STK_ProductRaw.h:409
STK::hidden::MultCoefImpl::mulXX3
static void mulXX3(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Rhs having 3 columns
Definition STK_ProductRaw.h:355
STK::hidden::MultCoefImpl::mulXX2
static void mulXX2(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Rhs having 2 columns
Definition STK_ProductRaw.h:344
STK::hidden::MultCoefImpl::mulX6X
static void mulX6X(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Lhs having 6 columns and Rhs having 6 rows
Definition STK_ProductRaw.h:305
STK::hidden::MultCoefImpl::mul2XX
static void mul2XX(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Lhs having 2 rows
Definition STK_ProductRaw.h:166
STK::hidden::MultCoefImpl::mul1XX
static void mul1XX(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Lhs having 1 row
Definition STK_ProductRaw.h:158
STK::hidden::MultCoefImpl::mulXX4
static void mulXX4(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Rhs having 4 columns
Definition STK_ProductRaw.h:367
STK::hidden::MultCoefImpl::mulX7X
static void mulX7X(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Lhs having 7 columns and Rhs having 7 rows
Definition STK_ProductRaw.h:320
STK::hidden::MultCoefImpl::mul5XX
static void mul5XX(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Lhs having 5 rows
Definition STK_ProductRaw.h:202
STK::hidden::MultCoefImpl::mul4XX
static void mul4XX(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Lhs having 4 rows
Definition STK_ProductRaw.h:189
STK::hidden::MultCoefImpl::mul6XX
static void mul6XX(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Lhs having 6 rows
Definition STK_ProductRaw.h:216
STK::hidden::MultCoefImpl::mul7XX
static void mul7XX(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Lhs having 7 rows
Definition STK_ProductRaw.h:231
STK::hidden::MultCoefImpl::mulXX6
static void mulXX6(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Rhs having 6 columns
Definition STK_ProductRaw.h:394
STK::hidden::MultCoefImpl::mulX2X
static void mulX2X(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Lhs having 2 columns and Rhs having 2 rows
Definition STK_ProductRaw.h:255
STK::hidden::MultCoefImpl::mulX1X
static void mulX1X(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Lhs having 1 column and Rhs having 1 row
Definition STK_ProductRaw.h:247
STK::hidden::MultCoefImpl::mul3XX
static void mul3XX(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Lhs having 3 rows
Definition STK_ProductRaw.h:177
STK::hidden::MultCoefImpl::mulXX1
static void mulXX1(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Rhs having 1 column
Definition STK_ProductRaw.h:336
STK::hidden::MultCoefImpl::mulX5X
static void mulX5X(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Lhs having 5 columns and Rhs having 5 rows
Definition STK_ProductRaw.h:291
STK::hidden::MultCoefImpl::mulX3X
static void mulX3X(Lhs const &lhs, Rhs const &rhs, Result &res)
multiplication with Lhs having 3 columns and Rhs having 3 rows
Definition STK_ProductRaw.h:266

References STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mul1XX(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mul2XX(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mul3XX(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mul4XX(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mul5XX(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mul6XX(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mul7XX(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulX1X(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulX2X(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulX3X(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulX4X(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulX5X(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulX6X(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulX7X(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulXX1(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulXX2(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulXX3(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulXX4(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulXX5(), STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulXX6(), and STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulXX7().

◆ mulX1X()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulX1X ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Lhs having 1 column and Rhs having 1 row

Definition at line 247 of file STK_ProductRaw.h.

248 {
249 int const k = lhs.beginCols();
250 for (int i=lhs.beginRows(); i< lhs.endRows(); ++i)
251 for (int j=rhs.beginCols(); j< rhs.endCols(); ++j)
252 res.elt(i, j) += lhs.elt(i, k) * rhs.elt(k, j);
253 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

◆ mulX2X()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulX2X ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Lhs having 2 columns and Rhs having 2 rows

Definition at line 255 of file STK_ProductRaw.h.

256 {
257 int const k = lhs.beginCols();
258 for (int i=lhs.beginRows(); i< lhs.endRows(); ++i)
259 for (int j=rhs.beginCols(); j< rhs.endCols(); ++j)
260 {
261 res.elt(i, j) += lhs.elt(i, k) * rhs.elt(k, j);
262 res.elt(i, j) += lhs.elt(i, k+1) * rhs.elt(k+1, j);
263 }
264 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

◆ mulX3X()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulX3X ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Lhs having 3 columns and Rhs having 3 rows

Definition at line 266 of file STK_ProductRaw.h.

267 {
268 int const k = lhs.beginCols();
269 for (int i=lhs.beginRows(); i< lhs.endRows(); ++i)
270 for (int j=rhs.beginCols(); j< rhs.endCols(); ++j)
271 {
272 res.elt(i, j) += lhs.elt(i, k) * rhs.elt(k, j);
273 res.elt(i, j) += lhs.elt(i, k+1) * rhs.elt(k+1, j);
274 res.elt(i, j) += lhs.elt(i, k+2) * rhs.elt(k+2, j);
275 }
276 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

◆ mulX4X()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulX4X ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Lhs having 4 columns and Rhs having 4 rows

Definition at line 278 of file STK_ProductRaw.h.

279 {
280 int const k = lhs.beginCols();
281 for (int i=lhs.beginRows(); i< lhs.endRows(); ++i)
282 for (int j=rhs.beginCols(); j< rhs.endCols(); ++j)
283 {
284 res.elt(i, j) += lhs.elt(i, k) * rhs.elt(k, j);
285 res.elt(i, j) += lhs.elt(i, k+1) * rhs.elt(k+1, j);
286 res.elt(i, j) += lhs.elt(i, k+2) * rhs.elt(k+2, j);
287 res.elt(i, j) += lhs.elt(i, k+3) * rhs.elt(k+3, j);
288 }
289 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

◆ mulX5X()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulX5X ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Lhs having 5 columns and Rhs having 5 rows

Definition at line 291 of file STK_ProductRaw.h.

292 {
293 int const k = lhs.beginCols();
294 for (int i=lhs.beginRows(); i< lhs.endRows(); ++i)
295 for (int j=rhs.beginCols(); j< rhs.endCols(); ++j)
296 {
297 res.elt(i, j) += lhs.elt(i, k) * rhs.elt(k, j);
298 res.elt(i, j) += lhs.elt(i, k+1) * rhs.elt(k+1, j);
299 res.elt(i, j) += lhs.elt(i, k+2) * rhs.elt(k+2, j);
300 res.elt(i, j) += lhs.elt(i, k+3) * rhs.elt(k+3, j);
301 res.elt(i, j) += lhs.elt(i, k+4) * rhs.elt(k+4, j);
302 }
303 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

◆ mulX6X()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulX6X ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Lhs having 6 columns and Rhs having 6 rows

Definition at line 305 of file STK_ProductRaw.h.

306 {
307 int const k = lhs.beginCols();
308 for (int i=lhs.beginRows(); i< lhs.endRows(); ++i)
309 for (int j=rhs.beginCols(); j< rhs.endCols(); ++j)
310 {
311 res.elt(i, j) += lhs.elt(i, k) * rhs.elt(k, j);
312 res.elt(i, j) += lhs.elt(i, k+1) * rhs.elt(k+1, j);
313 res.elt(i, j) += lhs.elt(i, k+2) * rhs.elt(k+2, j);
314 res.elt(i, j) += lhs.elt(i, k+3) * rhs.elt(k+3, j);
315 res.elt(i, j) += lhs.elt(i, k+4) * rhs.elt(k+4, j);
316 res.elt(i, j) += lhs.elt(i, k+5) * rhs.elt(k+5, j);
317 }
318 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

◆ mulX7X()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulX7X ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Lhs having 7 columns and Rhs having 7 rows

Definition at line 320 of file STK_ProductRaw.h.

321 {
322 int const k = lhs.beginCols();
323 for (int i=lhs.beginRows(); i< lhs.endRows(); ++i)
324 for (int j=rhs.beginCols(); j< rhs.endCols(); ++j)
325 {
326 res.elt(i, j) += lhs.elt(i, k) * rhs.elt(k, j);
327 res.elt(i, j) += lhs.elt(i, k+1) * rhs.elt(k+1, j);
328 res.elt(i, j) += lhs.elt(i, k+2) * rhs.elt(k+2, j);
329 res.elt(i, j) += lhs.elt(i, k+3) * rhs.elt(k+3, j);
330 res.elt(i, j) += lhs.elt(i, k+4) * rhs.elt(k+4, j);
331 res.elt(i, j) += lhs.elt(i, k+5) * rhs.elt(k+5, j);
332 res.elt(i, j) += lhs.elt(i, k+6) * rhs.elt(k+6, j);
333 }
334 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

◆ mulXX1()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulXX1 ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Rhs having 1 column

Definition at line 336 of file STK_ProductRaw.h.

337 {
338 int const j = rhs.beginCols();
339 for (int i=lhs.beginRows(); i< lhs.endRows(); ++i)
340 for (int k=lhs.beginCols(); k< lhs.endCols(); ++k)
341 res.elt(i, j) += lhs.elt(i, k) * rhs.elt(k, j);
342 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

◆ mulXX2()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulXX2 ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Rhs having 2 columns

Definition at line 344 of file STK_ProductRaw.h.

345 {
346 int const j = rhs.beginCols();
347 for (int i=lhs.beginRows(); i< lhs.endRows(); ++i)
348 for (int k=lhs.beginCols(); k< lhs.endCols(); ++k)
349 {
350 res.elt(i, j ) += lhs.elt(i, k) * rhs.elt(k, j );
351 res.elt(i, j+1) += lhs.elt(i, k) * rhs.elt(k, j+1);
352 }
353 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

◆ mulXX3()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulXX3 ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Rhs having 3 columns

Definition at line 355 of file STK_ProductRaw.h.

356 {
357 int const j = rhs.beginCols();
358 for (int i=lhs.beginRows(); i< lhs.endRows(); ++i)
359 for (int k=lhs.beginCols(); k< lhs.endCols(); ++k)
360 {
361 res.elt(i, j ) += lhs.elt(i, k) * rhs.elt(k, j );
362 res.elt(i, j+1) += lhs.elt(i, k) * rhs.elt(k, j+1);
363 res.elt(i, j+2) += lhs.elt(i, k) * rhs.elt(k, j+2);
364 }
365 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

◆ mulXX4()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulXX4 ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Rhs having 4 columns

Definition at line 367 of file STK_ProductRaw.h.

368 {
369 int const j = rhs.beginCols();
370 for (int i=lhs.beginRows(); i< lhs.endRows(); ++i)
371 for (int k=lhs.beginCols(); k< lhs.endCols(); ++k)
372 {
373 res.elt(i, j ) += lhs.elt(i, k) * rhs.elt(k, j );
374 res.elt(i, j+1) += lhs.elt(i, k) * rhs.elt(k, j+1);
375 res.elt(i, j+2) += lhs.elt(i, k) * rhs.elt(k, j+2);
376 res.elt(i, j+3) += lhs.elt(i, k) * rhs.elt(k, j+3);
377 }
378 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

◆ mulXX5()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulXX5 ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Rhs having 5 columns

Definition at line 380 of file STK_ProductRaw.h.

381 {
382 int const j = rhs.beginCols();
383 for (int i=lhs.beginRows(); i< lhs.endRows(); ++i)
384 for (int k=lhs.beginCols(); k< lhs.endCols(); ++k)
385 {
386 res.elt(i, j ) += lhs.elt(i, k) * rhs.elt(k, j );
387 res.elt(i, j+1) += lhs.elt(i, k) * rhs.elt(k, j+1);
388 res.elt(i, j+2) += lhs.elt(i, k) * rhs.elt(k, j+2);
389 res.elt(i, j+3) += lhs.elt(i, k) * rhs.elt(k, j+3);
390 res.elt(i, j+4) += lhs.elt(i, k) * rhs.elt(k, j+4);
391 }
392 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

◆ mulXX6()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulXX6 ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Rhs having 6 columns

Definition at line 394 of file STK_ProductRaw.h.

395 {
396 int const j = rhs.beginCols();
397 for (int i=lhs.beginRows(); i< lhs.endRows(); ++i)
398 for (int k=lhs.beginCols(); k< lhs.endCols(); ++k)
399 {
400 res.elt(i, j ) += lhs.elt(i, k) * rhs.elt(k, j );
401 res.elt(i, j+1) += lhs.elt(i, k) * rhs.elt(k, j+1);
402 res.elt(i, j+2) += lhs.elt(i, k) * rhs.elt(k, j+2);
403 res.elt(i, j+3) += lhs.elt(i, k) * rhs.elt(k, j+3);
404 res.elt(i, j+4) += lhs.elt(i, k) * rhs.elt(k, j+4);
405 res.elt(i, j+5) += lhs.elt(i, k) * rhs.elt(k, j+5);
406 }
407 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

◆ mulXX7()

template<typename Lhs , typename Rhs , typename Result >
static void STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::mulXX7 ( Lhs const &  lhs,
Rhs const &  rhs,
Result &  res 
)
inlinestatic

multiplication with Rhs having 7 columns

Definition at line 409 of file STK_ProductRaw.h.

410 {
411 int const j = rhs.beginCols();
412 for (int i=lhs.beginRows(); i< lhs.endRows(); ++i)
413 for (int k=lhs.beginCols(); k< lhs.endCols(); ++k)
414 {
415 res.elt(i, j ) += lhs.elt(i, k) * rhs.elt(k, j );
416 res.elt(i, j+1) += lhs.elt(i, k) * rhs.elt(k, j+1);
417 res.elt(i, j+2) += lhs.elt(i, k) * rhs.elt(k, j+2);
418 res.elt(i, j+3) += lhs.elt(i, k) * rhs.elt(k, j+3);
419 res.elt(i, j+4) += lhs.elt(i, k) * rhs.elt(k, j+4);
420 res.elt(i, j+5) += lhs.elt(i, k) * rhs.elt(k, j+5);
421 res.elt(i, j+6) += lhs.elt(i, k) * rhs.elt(k, j+6);
422 }
423 }

Referenced by STK::hidden::MultCoefImpl< Lhs, Rhs, Result >::multDispatcher().

The documentation for this struct was generated from the following file: