1 //=================================================================================================
2 /*!
3 // \file blazetest/mathtest/adaptors/lowermatrix/SparseTest.h
4 // \brief Header file for the LowerMatrix sparse test
5 //
6 // Copyright (C) 2012-2020 Klaus Iglberger - All Rights Reserved
7 //
8 // This file is part of the Blaze library. You can redistribute it and/or modify it under
9 // the terms of the New (Revised) BSD License. Redistribution and use in source and binary
10 // forms, with or without modification, are permitted provided that the following conditions
11 // are met:
12 //
13 // 1. Redistributions of source code must retain the above copyright notice, this list of
14 // conditions and the following disclaimer.
15 // 2. Redistributions in binary form must reproduce the above copyright notice, this list
16 // of conditions and the following disclaimer in the documentation and/or other materials
17 // provided with the distribution.
18 // 3. Neither the names of the Blaze development group nor the names of its contributors
19 // may be used to endorse or promote products derived from this software without specific
20 // prior written permission.
21 //
22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
23 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
25 // SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
27 // TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
28 // BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
30 // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
31 // DAMAGE.
32 */
33 //=================================================================================================
34
35 #ifndef _BLAZETEST_MATHTEST_ADAPTORS_LOWERMATRIX_SPARSETEST_H_
36 #define _BLAZETEST_MATHTEST_ADAPTORS_LOWERMATRIX_SPARSETEST_H_
37
38
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42
43 #include <sstream>
44 #include <stdexcept>
45 #include <string>
46 #include <blaze/math/CompressedMatrix.h>
47 #include <blaze/math/constraints/ColumnMajorMatrix.h>
48 #include <blaze/math/constraints/Lower.h>
49 #include <blaze/math/constraints/RequiresEvaluation.h>
50 #include <blaze/math/constraints/RowMajorMatrix.h>
51 #include <blaze/math/constraints/SparseMatrix.h>
52 #include <blaze/math/constraints/Upper.h>
53 #include <blaze/math/LowerMatrix.h>
54 #include <blaze/math/typetraits/IsRowMajorMatrix.h>
55 #include <blaze/util/constraints/SameType.h>
56 #include <blazetest/system/Types.h>
57
58
59 namespace blazetest {
60
61 namespace mathtest {
62
63 namespace adaptors {
64
65 namespace lowermatrix {
66
67 //=================================================================================================
68 //
69 // CLASS DEFINITION
70 //
71 //=================================================================================================
72
73 //*************************************************************************************************
74 /*!\brief Auxiliary class for all tests of the sparse LowerMatrix specialization.
75 //
76 // This class represents a test suite for the blaze::LowerMatrix class template specialization
77 // for sparse matrices. It performs a series of both compile time as well as runtime tests.
78 */
79 class SparseTest
80 {
81 public:
82 //**Constructors********************************************************************************
83 /*!\name Constructors */
84 //@{
85 explicit SparseTest();
86 // No explicitly declared copy constructor.
87 //@}
88 //**********************************************************************************************
89
90 //**Destructor**********************************************************************************
91 // No explicitly declared destructor.
92 //**********************************************************************************************
93
94 private:
95 //**Test functions******************************************************************************
96 /*!\name Test functions */
97 //@{
98 void testConstructors();
99 void testAssignment ();
100 void testAddAssign ();
101 void testSubAssign ();
102 void testSchurAssign ();
103 void testMultAssign ();
104 void testScaling ();
105 void testFunctionCall();
106 void testIterator ();
107 void testNonZeros ();
108 void testReset ();
109 void testClear ();
110 void testResize ();
111 void testReserve ();
112 void testTrim ();
113 void testShrinkToFit ();
114 void testSwap ();
115 void testSet ();
116 void testInsert ();
117 void testAppend ();
118 void testErase ();
119 void testFind ();
120 void testLowerBound ();
121 void testUpperBound ();
122 void testIsDefault ();
123 void testSubmatrix ();
124 void testRow ();
125 void testColumn ();
126
127 template< typename Type >
128 void checkRows( const Type& matrix, size_t expectedRows ) const;
129
130 template< typename Type >
131 void checkColumns( const Type& matrix, size_t expectedColumns ) const;
132
133 template< typename Type >
134 void checkCapacity( const Type& matrix, size_t minCapacity ) const;
135
136 template< typename Type >
137 void checkCapacity( const Type& matrix, size_t index, size_t minCapacity ) const;
138
139 template< typename Type >
140 void checkNonZeros( const Type& matrix, size_t expectedNonZeros ) const;
141
142 template< typename Type >
143 void checkNonZeros( const Type& matrix, size_t index, size_t expectedNonZeros ) const;
144 //@}
145 //**********************************************************************************************
146
147 //**Member variables****************************************************************************
148 /*!\name Member variables */
149 //@{
150 std::string test_; //!< Label of the currently performed test.
151 //@}
152 //**********************************************************************************************
153
154 //**Type definitions****************************************************************************
155 //! Type of the row-major lower matrix.
156 using LT = blaze::LowerMatrix< blaze::CompressedMatrix<int,blaze::rowMajor> >;
157
158 //! Type of the column-major lower matrix.
159 using OLT = blaze::LowerMatrix< blaze::CompressedMatrix<int,blaze::columnMajor> >;
160
161 using RLT = LT::Rebind<double>::Other; //!< Rebound row-major lower matrix type.
162 using ORLT = OLT::Rebind<double>::Other; //!< Rebound column-major lower matrix type.
163 //**********************************************************************************************
164
165 //**Compile time checks*************************************************************************
166 /*! \cond BLAZE_INTERNAL */
167 BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE( LT );
168 BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE( LT::ResultType );
169 BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE( LT::OppositeType );
170 BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE( LT::TransposeType );
171 BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE( OLT );
172 BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE( OLT::ResultType );
173 BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE( OLT::OppositeType );
174 BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE( OLT::TransposeType );
175 BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE( RLT );
176 BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE( RLT::ResultType );
177 BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE( RLT::OppositeType );
178 BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE( RLT::TransposeType );
179 BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE( ORLT );
180 BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE( ORLT::ResultType );
181 BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE( ORLT::OppositeType );
182 BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE( ORLT::TransposeType );
183
184 BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE ( LT );
185 BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE ( LT::ResultType );
186 BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE( LT::OppositeType );
187 BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE( LT::TransposeType );
188 BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE( OLT );
189 BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE( OLT::ResultType );
190 BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE ( OLT::OppositeType );
191 BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE ( OLT::TransposeType );
192 BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE ( RLT );
193 BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE ( RLT::ResultType );
194 BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE( RLT::OppositeType );
195 BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE( RLT::TransposeType );
196 BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE( ORLT );
197 BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE( ORLT::ResultType );
198 BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE ( ORLT::OppositeType );
199 BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE ( ORLT::TransposeType );
200
201 BLAZE_CONSTRAINT_MUST_BE_LOWER_MATRIX_TYPE( LT );
202 BLAZE_CONSTRAINT_MUST_BE_LOWER_MATRIX_TYPE( LT::ResultType );
203 BLAZE_CONSTRAINT_MUST_BE_LOWER_MATRIX_TYPE( LT::OppositeType );
204 BLAZE_CONSTRAINT_MUST_BE_UPPER_MATRIX_TYPE( LT::TransposeType );
205 BLAZE_CONSTRAINT_MUST_BE_LOWER_MATRIX_TYPE( OLT );
206 BLAZE_CONSTRAINT_MUST_BE_LOWER_MATRIX_TYPE( OLT::ResultType );
207 BLAZE_CONSTRAINT_MUST_BE_LOWER_MATRIX_TYPE( OLT::OppositeType );
208 BLAZE_CONSTRAINT_MUST_BE_UPPER_MATRIX_TYPE( OLT::TransposeType );
209 BLAZE_CONSTRAINT_MUST_BE_LOWER_MATRIX_TYPE( RLT );
210 BLAZE_CONSTRAINT_MUST_BE_LOWER_MATRIX_TYPE( RLT::ResultType );
211 BLAZE_CONSTRAINT_MUST_BE_LOWER_MATRIX_TYPE( RLT::OppositeType );
212 BLAZE_CONSTRAINT_MUST_BE_UPPER_MATRIX_TYPE( RLT::TransposeType );
213 BLAZE_CONSTRAINT_MUST_BE_LOWER_MATRIX_TYPE( ORLT );
214 BLAZE_CONSTRAINT_MUST_BE_LOWER_MATRIX_TYPE( ORLT::ResultType );
215 BLAZE_CONSTRAINT_MUST_BE_LOWER_MATRIX_TYPE( ORLT::OppositeType );
216 BLAZE_CONSTRAINT_MUST_BE_UPPER_MATRIX_TYPE( ORLT::TransposeType );
217
218 BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION( LT::ResultType );
219 BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION( LT::OppositeType );
220 BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION( LT::TransposeType );
221 BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION( OLT::ResultType );
222 BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION( OLT::OppositeType );
223 BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION( OLT::TransposeType );
224 BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION( RLT::ResultType );
225 BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION( RLT::OppositeType );
226 BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION( RLT::TransposeType );
227 BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION( ORLT::ResultType );
228 BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION( ORLT::OppositeType );
229 BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION( ORLT::TransposeType );
230
231 BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE( LT::ElementType, LT::ResultType::ElementType );
232 BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE( LT::ElementType, LT::OppositeType::ElementType );
233 BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE( LT::ElementType, LT::TransposeType::ElementType );
234 BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE( OLT::ElementType, OLT::ResultType::ElementType );
235 BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE( OLT::ElementType, OLT::OppositeType::ElementType );
236 BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE( OLT::ElementType, OLT::TransposeType::ElementType );
237 BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE( RLT::ElementType, RLT::ResultType::ElementType );
238 BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE( RLT::ElementType, RLT::OppositeType::ElementType );
239 BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE( RLT::ElementType, RLT::TransposeType::ElementType );
240 BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE( ORLT::ElementType, ORLT::ResultType::ElementType );
241 BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE( ORLT::ElementType, ORLT::OppositeType::ElementType );
242 BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE( ORLT::ElementType, ORLT::TransposeType::ElementType );
243 /*! \endcond */
244 //**********************************************************************************************
245 };
246 //*************************************************************************************************
247
248
249
250
251 //=================================================================================================
252 //
253 // TEST FUNCTIONS
254 //
255 //=================================================================================================
256
257 //*************************************************************************************************
258 /*!\brief Checking the number of rows of the given matrix.
259 //
260 // \param matrix The matrix to be checked.
261 // \param expectedRows The expected number of rows of the matrix.
262 // \return void
263 // \exception std::runtime_error Error detected.
264 //
265 // This function checks the number of rows of the given matrix. In case the actual number of
266 // rows does not correspond to the given expected number of rows, a \a std::runtime_error
267 // exception is thrown.
268 */
269 template< typename Type > // Type of the matrix
checkRows(const Type & matrix,size_t expectedRows)270 void SparseTest::checkRows( const Type& matrix, size_t expectedRows ) const
271 {
272 if( matrix.rows() != expectedRows ) {
273 std::ostringstream oss;
274 oss << " Test: " << test_ << "\n"
275 << " Error: Invalid number of rows detected\n"
276 << " Details:\n"
277 << " Number of rows : " << matrix.rows() << "\n"
278 << " Expected number of rows: " << expectedRows << "\n";
279 throw std::runtime_error( oss.str() );
280 }
281 }
282 //*************************************************************************************************
283
284
285 //*************************************************************************************************
286 /*!\brief Checking the number of columns of the given matrix.
287 //
288 // \param matrix The matrix to be checked.
289 // \param expectedRows The expected number of columns of the matrix.
290 // \return void
291 // \exception std::runtime_error Error detected.
292 //
293 // This function checks the number of columns of the given matrix. In case the actual number of
294 // columns does not correspond to the given expected number of columns, a \a std::runtime_error
295 // exception is thrown.
296 */
297 template< typename Type > // Type of the matrix
checkColumns(const Type & matrix,size_t expectedColumns)298 void SparseTest::checkColumns( const Type& matrix, size_t expectedColumns ) const
299 {
300 if( matrix.columns() != expectedColumns ) {
301 std::ostringstream oss;
302 oss << " Test: " << test_ << "\n"
303 << " Error: Invalid number of columns detected\n"
304 << " Details:\n"
305 << " Number of columns : " << matrix.columns() << "\n"
306 << " Expected number of columns: " << expectedColumns << "\n";
307 throw std::runtime_error( oss.str() );
308 }
309 }
310 //*************************************************************************************************
311
312
313 //*************************************************************************************************
314 /*!\brief Checking the capacity of the given matrix.
315 //
316 // \param matrix The matrix to be checked.
317 // \param minCapacity The expected minimum capacity of the matrix.
318 // \return void
319 // \exception std::runtime_error Error detected.
320 //
321 // This function checks the capacity of the given matrix. In case the actual capacity is smaller
322 // than the given expected minimum capacity, a \a std::runtime_error exception is thrown.
323 */
324 template< typename Type > // Type of the matrix
checkCapacity(const Type & matrix,size_t minCapacity)325 void SparseTest::checkCapacity( const Type& matrix, size_t minCapacity ) const
326 {
327 if( capacity( matrix ) < minCapacity ) {
328 std::ostringstream oss;
329 oss << " Test: " << test_ << "\n"
330 << " Error: Invalid capacity detected\n"
331 << " Details:\n"
332 << " Capacity : " << capacity( matrix ) << "\n"
333 << " Expected minimum capacity: " << minCapacity << "\n";
334 throw std::runtime_error( oss.str() );
335 }
336 }
337 //*************************************************************************************************
338
339
340 //*************************************************************************************************
341 /*!\brief Checking the capacity of a specific row/column of the given matrix.
342 //
343 // \param matrix The matrix to be checked.
344 // \param index The row/column to be checked.
345 // \param minCapacity The expected minimum capacity of the specified row/column.
346 // \return void
347 // \exception std::runtime_error Error detected.
348 //
349 // This function checks the capacity of a specific row/column of the given matrix. In case the
350 // actual capacity is smaller than the given expected minimum capacity, a \a std::runtime_error
351 // exception is thrown.
352 */
353 template< typename Type > // Type of the matrix
checkCapacity(const Type & matrix,size_t index,size_t minCapacity)354 void SparseTest::checkCapacity( const Type& matrix, size_t index, size_t minCapacity ) const
355 {
356 if( capacity( matrix, index ) < minCapacity ) {
357 std::ostringstream oss;
358 oss << " Test: " << test_ << "\n"
359 << " Error: Invalid capacity detected in "
360 << ( blaze::IsRowMajorMatrix<Type>::value ? "row " : "column " ) << index << "\n"
361 << " Details:\n"
362 << " Capacity : " << capacity( matrix, index ) << "\n"
363 << " Expected minimum capacity: " << minCapacity << "\n";
364 throw std::runtime_error( oss.str() );
365 }
366 }
367 //*************************************************************************************************
368
369
370 //*************************************************************************************************
371 /*!\brief Checking the number of non-zero elements of the given matrix.
372 //
373 // \param matrix The matrix to be checked.
374 // \param expectedNonZeros The expected number of non-zero elements of the matrix.
375 // \return void
376 // \exception std::runtime_error Error detected.
377 //
378 // This function checks the number of non-zero elements of the given matrix. In case the
379 // actual number of non-zero elements does not correspond to the given expected number,
380 // a \a std::runtime_error exception is thrown.
381 */
382 template< typename Type > // Type of the matrix
checkNonZeros(const Type & matrix,size_t expectedNonZeros)383 void SparseTest::checkNonZeros( const Type& matrix, size_t expectedNonZeros ) const
384 {
385 if( nonZeros( matrix ) != expectedNonZeros ) {
386 std::ostringstream oss;
387 oss << " Test: " << test_ << "\n"
388 << " Error: Invalid number of non-zero elements\n"
389 << " Details:\n"
390 << " Number of non-zeros : " << nonZeros( matrix ) << "\n"
391 << " Expected number of non-zeros: " << expectedNonZeros << "\n";
392 throw std::runtime_error( oss.str() );
393 }
394
395 if( capacity( matrix ) < nonZeros( matrix ) ) {
396 std::ostringstream oss;
397 oss << " Test: " << test_ << "\n"
398 << " Error: Invalid capacity detected\n"
399 << " Details:\n"
400 << " Number of non-zeros: " << nonZeros( matrix ) << "\n"
401 << " Capacity : " << capacity( matrix ) << "\n";
402 throw std::runtime_error( oss.str() );
403 }
404 }
405 //*************************************************************************************************
406
407
408 //*************************************************************************************************
409 /*!\brief Checking the number of non-zero elements in a specific row/column of the given matrix.
410 //
411 // \param matrix The matrix to be checked.
412 // \param index The row/column to be checked.
413 // \param expectedNonZeros The expected number of non-zero elements in the specified row/column.
414 // \return void
415 // \exception std::runtime_error Error detected.
416 //
417 // This function checks the number of non-zero elements in the specified row/column of the
418 // given matrix. In case the actual number of non-zero elements does not correspond to the
419 // given expected number, a \a std::runtime_error exception is thrown.
420 */
421 template< typename Type > // Type of the matrix
checkNonZeros(const Type & matrix,size_t index,size_t expectedNonZeros)422 void SparseTest::checkNonZeros( const Type& matrix, size_t index, size_t expectedNonZeros ) const
423 {
424 if( nonZeros( matrix, index ) != expectedNonZeros ) {
425 std::ostringstream oss;
426 oss << " Test: " << test_ << "\n"
427 << " Error: Invalid number of non-zero elements in "
428 << ( blaze::IsRowMajorMatrix<Type>::value ? "row " : "column " ) << index << "\n"
429 << " Details:\n"
430 << " Number of non-zeros : " << nonZeros( matrix, index ) << "\n"
431 << " Expected number of non-zeros: " << expectedNonZeros << "\n";
432 throw std::runtime_error( oss.str() );
433 }
434
435 if( capacity( matrix, index ) < nonZeros( matrix, index ) ) {
436 std::ostringstream oss;
437 oss << " Test: " << test_ << "\n"
438 << " Error: Invalid capacity detected in "
439 << ( blaze::IsRowMajorMatrix<Type>::value ? "row " : "column " ) << index << "\n"
440 << " Details:\n"
441 << " Number of non-zeros: " << nonZeros( matrix, index ) << "\n"
442 << " Capacity : " << capacity( matrix, index ) << "\n";
443 throw std::runtime_error( oss.str() );
444 }
445 }
446 //*************************************************************************************************
447
448
449
450
451 //=================================================================================================
452 //
453 // GLOBAL TEST FUNCTIONS
454 //
455 //=================================================================================================
456
457 //*************************************************************************************************
458 /*!\brief Testing the functionality of the sparse LowerMatrix specialization.
459 //
460 // \return void
461 */
runTest()462 void runTest()
463 {
464 SparseTest();
465 }
466 //*************************************************************************************************
467
468
469
470
471 //=================================================================================================
472 //
473 // MACRO DEFINITIONS
474 //
475 //=================================================================================================
476
477 //*************************************************************************************************
478 /*! \cond BLAZE_INTERNAL */
479 /*!\brief Macro for the execution of the LowerMatrix sparse test.
480 */
481 #define RUN_LOWERMATRIX_SPARSE_TEST \
482 blazetest::mathtest::adaptors::lowermatrix::runTest()
483 /*! \endcond */
484 //*************************************************************************************************
485
486 } // namespace lowermatrix
487
488 } // namespace adaptors
489
490 } // namespace mathtest
491
492 } // namespace blazetest
493
494 #endif
495