SymmetricElement.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_ADAPTORS_SYMMETRICMATRIX_SYMMETRICELEMENT_H_
36 #define _BLAZE_MATH_ADAPTORS_SYMMETRICMATRIX_SYMMETRICELEMENT_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
54 #include <blaze/util/Assert.h>
60 #include <blaze/util/Types.h>
61 
62 
63 namespace blaze {
64 
65 //=================================================================================================
66 //
67 // CLASS DEFINITION
68 //
69 //=================================================================================================
70 
71 //*************************************************************************************************
104 template< typename MT > // Type of the adapted matrix
106  : private SparseElement
107 {
108  private:
109  //**Type definitions****************************************************************************
112  //**********************************************************************************************
113 
114  public:
115  //**Type definitions****************************************************************************
117  using IndexType = size_t;
121  //**********************************************************************************************
122 
123  //**Constructor*********************************************************************************
126  inline SymmetricElement( IteratorType pos, MT* matrix, size_t idx );
128  //**********************************************************************************************
129 
130  //**Assignment operators************************************************************************
133  template< typename T > inline SymmetricElement& operator= ( const T& v );
134  template< typename T > inline SymmetricElement& operator+=( const T& v );
135  template< typename T > inline SymmetricElement& operator-=( const T& v );
136  template< typename T > inline SymmetricElement& operator*=( const T& v );
137  template< typename T > inline SymmetricElement& operator/=( const T& v );
139  //**********************************************************************************************
140 
141  //**Access operators****************************************************************************
144  inline Pointer operator->() noexcept;
146  //**********************************************************************************************
147 
148  //**Utility functions***************************************************************************
151  inline Reference value() const;
152  inline IndexType index() const;
154  //**********************************************************************************************
155 
156  private:
157  //**Utility functions***************************************************************************
160  inline void sync();
161  inline bool isSynced() const;
163  //**********************************************************************************************
164 
165  //**Member variables****************************************************************************
167  MT* matrix_;
168  size_t index_;
169  //**********************************************************************************************
170 
171  //**Compile time checks*************************************************************************
185  //**********************************************************************************************
186 };
187 //*************************************************************************************************
188 
189 
190 
191 
192 //=================================================================================================
193 //
194 // CONSTRUCTORS
195 //
196 //=================================================================================================
197 
198 //*************************************************************************************************
205 template< typename MT > // Type of the adapted matrix
206 inline SymmetricElement<MT>::SymmetricElement( IteratorType pos, MT* matrix, size_t idx )
207  : pos_ ( pos ) // Iterator to the current sparse symmetric matrix element
208  , matrix_( matrix ) // The sparse matrix containing the iterator
209  , index_ ( idx ) // The row/column index of the iterator
210 {
211  BLAZE_INTERNAL_ASSERT( isSynced(), "Missing matrix element detected" );
212 }
213 //*************************************************************************************************
214 
215 
216 
217 
218 //=================================================================================================
219 //
220 // OPERATORS
221 //
222 //=================================================================================================
223 
224 //*************************************************************************************************
230 template< typename MT > // Type of the adapted matrix
231 template< typename T > // Type of the right-hand side value
233 {
234  *pos_ = v;
235  sync();
236  return *this;
237 }
238 //*************************************************************************************************
239 
240 
241 //*************************************************************************************************
247 template< typename MT > // Type of the adapted matrix
248 template< typename T > // Type of the right-hand side value
250 {
251  *pos_ += v;
252  sync();
253  return *this;
254 }
255 //*************************************************************************************************
256 
257 
258 //*************************************************************************************************
264 template< typename MT > // Type of the adapted matrix
265 template< typename T > // Type of the right-hand side value
267 {
268  *pos_ -= v;
269  sync();
270  return *this;
271 }
272 //*************************************************************************************************
273 
274 
275 //*************************************************************************************************
281 template< typename MT > // Type of the adapted matrix
282 template< typename T > // Type of the right-hand side value
284 {
285  *pos_ *= v;
286  sync();
287  return *this;
288 }
289 //*************************************************************************************************
290 
291 
292 //*************************************************************************************************
298 template< typename MT > // Type of the adapted matrix
299 template< typename T > // Type of the right-hand side value
301 {
302  *pos_ /= v;
303  sync();
304  return *this;
305 }
306 //*************************************************************************************************
307 
308 
309 
310 
311 //=================================================================================================
312 //
313 // ACCESS OPERATORS
314 //
315 //=================================================================================================
316 
317 //*************************************************************************************************
322 template< typename MT > // Type of the adapted matrix
324 {
325  return this;
326 }
327 //*************************************************************************************************
328 
329 
330 
331 
332 //=================================================================================================
333 //
334 // UTILITY FUNCTIONS
335 //
336 //=================================================================================================
337 
338 //*************************************************************************************************
343 template< typename MT > // Type of the adapted matrix
345 {
346  return Reference( pos_, matrix_, index_ );
347 }
348 //*************************************************************************************************
349 
350 
351 //*************************************************************************************************
356 template< typename MT > // Type of the adapted matrix
358 {
359  return pos_->index();
360 }
361 //*************************************************************************************************
362 
363 
364 //*************************************************************************************************
369 template< typename MT > // Type of the adapted matrix
371 {
372  if( pos_->index() == index_ || isDefault( pos_->value() ) )
373  return;
374 
375  const size_t row ( ( IsRowMajorMatrix_v<MT> )?( pos_->index() ):( index_ ) );
376  const size_t column( ( IsRowMajorMatrix_v<MT> )?( index_ ):( pos_->index() ) );
377 
378  matrix_->set( row, column, pos_->value() );
379 }
380 //*************************************************************************************************
381 
382 
383 //*************************************************************************************************
388 template< typename MT > // Type of the adapted matrix
390 {
391  const size_t row ( ( IsRowMajorMatrix_v<MT> )?( pos_->index() ):( index_ ) );
392  const size_t column( ( IsRowMajorMatrix_v<MT> )?( index_ ):( pos_->index() ) );
393 
394  const IteratorType pos2( matrix_->find( row, column ) );
395  const IteratorType end( matrix_->end( pos_->index() ) );
396 
397  return ( isDefault( pos_->value() ) && ( pos2 == end || isDefault( pos2->value() ) ) ) ||
398  ( pos2 != end && pos_->value() == pos2->value() );
399 }
400 //*************************************************************************************************
401 
402 } // namespace blaze
403 
404 #endif
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONST(T)
Constraint on the data type.In case the given data type is a const-qualified type, a compilation error is created.
Definition: Const.h:79
Header file for auxiliary alias declarations.
decltype(auto) column(Matrix< MT, SO > &matrix, RCAs... args)
Creating a view on a specific column of the given matrix.
Definition: Column.h:133
Constraint on the data type.
Header file for basic type definitions.
Constraint on the data type.
IteratorType pos_
Iterator to the current sparse Hermitian matrix element.
Definition: SymmetricElement.h:166
bool isSynced() const
Checking if the current sparse element is in sync.
Definition: SymmetricElement.h:389
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOLATILE(T)
Constraint on the data type.In case the given data type is a volatile-qualified type, a compilation error is created.
Definition: Volatile.h:79
Constraint on the data type.
typename T::ElementType ElementType_t
Alias declaration for nested ElementType type definitions.The ElementType_t alias declaration provide...
Definition: Aliases.h:170
Constraint on the data type.
Constraint on the data type.
MT * matrix_
The sparse matrix containing the iterator.
Definition: SymmetricElement.h:167
ElementType_t< MT > ElementType
Type of the represented matrix element.
Definition: SymmetricElement.h:110
SymmetricElement(IteratorType pos, MT *matrix, size_t idx)
Constructor for the SymmetricElement class.
Definition: SymmetricElement.h:206
Constraint on the data type.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
#define BLAZE_CONSTRAINT_MUST_NOT_BE_POINTER_TYPE(T)
Constraint on the data type.In case the given data type T is not a pointer type, a compilation error ...
Definition: Pointer.h:79
size_t index_
The row/column index of the iterator.
Definition: SymmetricElement.h:168
Constraint on the data type.
Header file for the SparseElement base class.
Iterator_t< MT > IteratorType
Type of the underlying sparse matrix iterators.
Definition: SymmetricElement.h:111
Pointer operator->() noexcept
Direct access to the Hermitian element.
Definition: SymmetricElement.h:323
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UPPER_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a upper triangular matrix type...
Definition: Upper.h:81
void sync()
Synchronization of the current sparse element to the according paired element.
Definition: SymmetricElement.h:370
SymmetricValue< MT > Reference
Reference return type.
Definition: SymmetricElement.h:118
MT::Iterator end(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:438
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a symmetric matrix type, a compilation error is created.
Definition: Symmetric.h:79
typename T::Iterator Iterator_t
Alias declaration for nested Iterator type definitions.The Iterator_t alias declaration provides a co...
Definition: Aliases.h:190
Header file for run time assertion macros.
Constraint on the data type.
Constraint on the data type.
decltype(auto) row(Matrix< MT, SO > &, RRAs...)
Creating a view on a specific row of the given matrix.
Definition: Row.h:133
#define BLAZE_CONSTRAINT_MUST_BE_NUMERIC_TYPE(T)
Constraint on the data type.In case the given data type T is not a numeric (integral or floating poin...
Definition: Numeric.h:61
Representation of two synchronized values within a sparse symmetric matrix.The SymmetricValue class r...
Definition: SymmetricValue.h:113
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LOWER_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a lower triangular matrix type...
Definition: Lower.h:81
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:79
Header file for the isDefault shim.
Header file for the SymmetricValue class.
Constraint on the data type.
Representation of two synchronized elements within the sparse symmetric matrix.The SymmetricElement c...
Definition: SymmetricElement.h:105
Constraint on the data type.
Base class for all sparse element types.The SparseElement class is the base class for all sparse elem...
Definition: SparseElement.h:57
Header file for the IsRowMajorMatrix type trait.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EXPRESSION_TYPE(T)
Constraint on the data type.In case the given data type T is an expression (i.e. a type derived from ...
Definition: Expression.h:81
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:631
#define BLAZE_CONSTRAINT_MUST_NOT_BE_HERMITIAN_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is an Hermitian matrix type, a compilation error is created.
Definition: Hermitian.h:79
IndexType index() const
Access to the current index of the Hermitian element.
Definition: SymmetricElement.h:357
Reference value() const
Access to the current value of the Hermitian element.
Definition: SymmetricElement.h:344
Size type of the Blaze library.
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a sparse, N-dimensional matrix type...
Definition: SparseMatrix.h:61