Debian Codegraph @

include/deal.II/lac/sparse_matrix_ez.templates.h

raw
1 // ------------------------------------------------------------------------
2 //
3 // SPDX-License-Identifier: LGPL-2.1-or-later
4 // Copyright (C) 2002 - 2025 by the deal.II authors
5 //
6 // This file is part of the deal.II library.
7 //
8 // Part of the source code is dual licensed under Apache-2.0 WITH
9 // LLVM-exception OR LGPL-2.1-or-later. Detailed license information
10 // governing the source code and code contributions can be found in
11 // LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
12 //
13 // ------------------------------------------------------------------------
14
15 #ifndef dealii_sparse_matrix_ez_templates_h
16 #define dealii_sparse_matrix_ez_templates_h
17
18
19 #include <deal.II/base/config.h>
20
21 #include <deal.II/lac/sparse_matrix_ez.h>
22 #include <deal.II/lac/vector.h>
23
24 #include <algorithm>
25 #include <cmath>
26 #include <iomanip>
27 #include <iostream>
28
29 DEAL_II_NAMESPACE_OPEN
30
31 //---------------------------------------------------------------------------
32
33 template <typename number>
34 SparseMatrixEZ<number>::SparseMatrixEZ()
35 : n_columns(0)
36 , increment(1)
37 , saved_default_row_length(0)
38 {}
39
40
41 template <typename number>
42 SparseMatrixEZ<number>::SparseMatrixEZ(const SparseMatrixEZ<number> &m)
43 : EnableObserverPointer(m)
44 , n_columns(0)
45 , increment(m.increment)
46 , saved_default_row_length(m.saved_default_row_length)
47 {
48 Assert(m.m() == 0 && m.n() == 0,
49 ExcMessage(
50 "This constructor can only be called if the provided argument "
51 "is an empty matrix. This constructor can not be used to "
52 "copy-construct a non-empty matrix. Use the "
53 "SparseMatrixEZ::copy_from() function for that purpose."));
54 }
55
56
57 template <typename number>
58 SparseMatrixEZ<number>::SparseMatrixEZ(const size_type n_rows,
59 const size_type n_cols,
60 const size_type default_row_length,
61 const unsigned int default_increment)
62 {
63 reinit(n_rows, n_cols, default_row_length, default_increment);
64 }
65
66
67
68 template <typename number>
69 SparseMatrixEZ<number> &
70 SparseMatrixEZ<number>::operator=(const SparseMatrixEZ<number> &m)
71 {
72 Assert(m.empty(),
73 ExcMessage("This operator can only be called if the provided right "
74 "hand side is an empty matrix. This operator can not be "
75 "used to copy a non-empty matrix. Use the "
76 "SparseMatrixEZ::copy_from() function for that purpose."));
77 return *this;
78 }
79
80
81 template <typename number>
82 SparseMatrixEZ<number> &
83 SparseMatrixEZ<number>::operator=(const double d)
84 {
85 Assert(d == 0, ExcScalarAssignmentOnlyForZeroValue());
86
87 typename std::vector<Entry>::iterator e = data.begin();
88 const typename std::vector<Entry>::iterator end = data.end();
89
90 while (e != end)
91 {
92 (e++)->value = 0.;
93 }
94
95 return *this;
96 }
97
98
99
100 template <typename number>
101 void
102 SparseMatrixEZ<number>::reinit(const size_type n_rows,
103 const size_type n_cols,
104 const size_type default_row_length,
105 const unsigned int default_increment,
106 const size_type reserve)
107 {
108 clear();
109
110 saved_default_row_length = default_row_length;
111 increment = default_increment;
112
113 n_columns = n_cols;
114 row_info.resize(n_rows);
115 if (reserve != 0)
116 data.reserve(reserve);
117 data.resize(default_row_length * n_rows);
118
119 for (size_type i = 0; i < n_rows; ++i)
120 row_info[i].start = i * default_row_length;
121 }
122
123
124 template <typename number>
125 void
126 SparseMatrixEZ<number>::clear()
127 {
128 n_columns = 0;
129 row_info.resize(0);
130 data.resize(0);
131 }
132
133
134 template <typename number>
135 bool
136 SparseMatrixEZ<number>::empty() const
137 {
138 return ((n_columns == 0) && (row_info.empty()));
139 }
140
141
142 template <typename number>
143 template <typename somenumber>
144 void
145 SparseMatrixEZ<number>::vmult(Vector<somenumber> &dst,
146 const Vector<somenumber> &src) const
147 {
148 Assert(m() == dst.size(), ExcDimensionMismatch(m(), dst.size()));
149 Assert(n() == src.size(), ExcDimensionMismatch(n(), src.size()));
150
151 const size_type end_row = row_info.size();
152 for (size_type row = 0; row < end_row; ++row)
153 {
154 const RowInfo &ri = row_info[row];
155 typename std::vector<Entry>::const_iterator entry =
156 data.begin() + ri.start;
157 double s = 0.;
158 for (unsigned short i = 0; i < ri.length; ++i, ++entry)
159 {
160 Assert(entry->column != Entry::invalid, ExcInternalError());
161 s += entry->value * src(entry->column);
162 }
163 dst(row) = s;
164 }
165 }
166
167
168 template <typename number>
169 number
170 SparseMatrixEZ<number>::l2_norm() const
171 {
172 number sum = 0.;
173 const_iterator start = begin();
174 const_iterator final = end();
175
176 while (start != final)
177 {
178 const double value = start->value();
179 sum += value * value;
180 ++start;
181 }
182 return std::sqrt(sum);
183 }
184
185
186
187 template <typename number>
188 template <typename somenumber>
189 void
190 SparseMatrixEZ<number>::Tvmult(Vector<somenumber> &dst,
191 const Vector<somenumber> &src) const
192 {
193 dst = 0.;
194 Tvmult_add(dst, src);
195 }
196
197
198 template <typename number>
199 template <typename somenumber>
200 void
201 SparseMatrixEZ<number>::vmult_add(Vector<somenumber> &dst,
202 const Vector<somenumber> &src) const
203 {
204 Assert(m() == dst.size(), ExcDimensionMismatch(m(), dst.size()));
205 Assert(n() == src.size(), ExcDimensionMismatch(n(), src.size()));
206
207 const size_type end_row = row_info.size();
208 for (size_type row = 0; row < end_row; ++row)
209 {
210 const RowInfo &ri = row_info[row];
211 typename std::vector<Entry>::const_iterator entry =
212 data.begin() + ri.start;
213 double s = 0.;
214 for (unsigned short i = 0; i < ri.length; ++i, ++entry)
215 {
216 Assert(entry->column != Entry::invalid, ExcInternalError());
217 s += entry->value * src(entry->column);
218 }
219 dst(row) += s;
220 }
221 }
222
223 template <typename number>
224 template <typename somenumber>
225 void
226 SparseMatrixEZ<number>::Tvmult_add(Vector<somenumber> &dst,
227 const Vector<somenumber> &src) const
228 {
229 Assert(n() == dst.size(), ExcDimensionMismatch(n(), dst.size()));
230 Assert(m() == src.size(), ExcDimensionMismatch(m(), src.size()));
231
232 const size_type end_row = row_info.size();
233 for (size_type row = 0; row < end_row; ++row)
234 {
235 const RowInfo &ri = row_info[row];
236 typename std::vector<Entry>::const_iterator entry =
237 data.begin() + ri.start;
238 for (unsigned short i = 0; i < ri.length; ++i, ++entry)
239 {
240 Assert(entry->column != Entry::invalid, ExcInternalError());
241 dst(entry->column) += entry->value * src(row);
242 }
243 }
244 }
245
246
247 template <typename number>
248 template <typename somenumber>
249 void
250 SparseMatrixEZ<number>::precondition_Jacobi(Vector<somenumber> &dst,
251 const Vector<somenumber> &src,
252 const number om) const
253 {
254 Assert(m() == n(), ExcNotQuadratic());
255 Assert(dst.size() == n(), ExcDimensionMismatch(dst.size(), n()));
256 Assert(src.size() == n(), ExcDimensionMismatch(src.size(), n()));
257
258 somenumber *dst_ptr = dst.begin();
259 const somenumber *src_ptr = src.begin();
260 typename std::vector<RowInfo>::const_iterator ri = row_info.begin();
261 const typename std::vector<RowInfo>::const_iterator end = row_info.end();
262
263 for (; ri != end; ++dst_ptr, ++src_ptr, ++ri)
264 {
265 Assert(ri->diagonal != RowInfo::invalid_diagonal, ExcNoDiagonal());
266 *dst_ptr = om * *src_ptr / data[ri->start + ri->diagonal].value;
267 }
268 }
269
270
271
272 template <typename number>
273 template <typename somenumber>
274 void
275 SparseMatrixEZ<number>::precondition_SOR(Vector<somenumber> &dst,
276 const Vector<somenumber> &src,
277 const number om) const
278 {
279 Assert(m() == n(), ExcNotQuadratic());
280 Assert(dst.size() == n(), ExcDimensionMismatch(dst.size(), n()));
281 Assert(src.size() == n(), ExcDimensionMismatch(src.size(), n()));
282
283 somenumber *dst_ptr = dst.begin();
284 const somenumber *src_ptr = src.begin();
285 typename std::vector<RowInfo>::const_iterator ri = row_info.begin();
286 const typename std::vector<RowInfo>::const_iterator end = row_info.end();
287
288 for (; ri != end; ++dst_ptr, ++src_ptr, ++ri)
289 {
290 Assert(ri->diagonal != RowInfo::invalid_diagonal, ExcNoDiagonal());
291 number s = *src_ptr;
292 const size_type end_row = ri->start + ri->diagonal;
293 for (size_type i = ri->start; i < end_row; ++i)
294 s -= data[i].value * dst(data[i].column);
295
296 *dst_ptr = om * s / data[ri->start + ri->diagonal].value;
297 }
298 }
299
300
301
302 template <typename number>
303 template <typename somenumber>
304 void
305 SparseMatrixEZ<number>::precondition_TSOR(Vector<somenumber> &dst,
306 const Vector<somenumber> &src,
307 const number om) const
308 {
309 Assert(m() == n(), ExcNotQuadratic());
310 Assert(dst.size() == n(), ExcDimensionMismatch(dst.size(), n()));
311 Assert(src.size() == n(), ExcDimensionMismatch(src.size(), n()));
312
313 somenumber *dst_ptr = dst.begin() + dst.size() - 1;
314 const somenumber *src_ptr = src.begin() + src.size() - 1;
315 typename std::vector<RowInfo>::const_reverse_iterator ri = row_info.rbegin();
316 const typename std::vector<RowInfo>::const_reverse_iterator end =
317 row_info.rend();
318
319 for (; ri != end; --dst_ptr, --src_ptr, ++ri)
320 {
321 Assert(ri->diagonal != RowInfo::invalid_diagonal, ExcNoDiagonal());
322 number s = *src_ptr;
323 const size_type end_row = ri->start + ri->length;
324 for (size_type i = ri->start + ri->diagonal + 1; i < end_row; ++i)
325 s -= data[i].value * dst(data[i].column);
326
327 *dst_ptr = om * s / data[ri->start + ri->diagonal].value;
328 }
329 }
330
331
332
333 template <typename number>
334 template <typename somenumber>
335 void
336 SparseMatrixEZ<number>::precondition_SSOR(
337 Vector<somenumber> &dst,
338 const Vector<somenumber> &src,
339 const number om,
340 const std::vector<std::size_t> &) const
341 {
342 Assert(m() == n(), ExcNotQuadratic());
343 Assert(dst.size() == n(), ExcDimensionMismatch(dst.size(), n()));
344 Assert(src.size() == n(), ExcDimensionMismatch(src.size(), n()));
345
346 somenumber *dst_ptr = dst.begin();
347 const somenumber *src_ptr = src.begin();
348 typename std::vector<RowInfo>::const_iterator ri;
349 const typename std::vector<RowInfo>::const_iterator end = row_info.end();
350
351 // Forward
352 for (ri = row_info.begin(); ri != end; ++dst_ptr, ++src_ptr, ++ri)
353 {
354 Assert(ri->diagonal != RowInfo::invalid_diagonal, ExcNoDiagonal());
355 number s = 0;
356 const size_type end_row = ri->start + ri->diagonal;
357 for (size_type i = ri->start; i < end_row; ++i)
358 s += data[i].value * dst(data[i].column);
359
360 *dst_ptr = *src_ptr - s * om;
361 *dst_ptr /= data[ri->start + ri->diagonal].value;
362 }
363 // Diagonal
364 dst_ptr = dst.begin();
365 for (ri = row_info.begin(); ri != end; ++dst_ptr, ++ri)
366 *dst_ptr *= om * (2. - om) * data[ri->start + ri->diagonal].value;
367
368 // Backward
369 typename std::vector<RowInfo>::const_reverse_iterator rri;
370 const typename std::vector<RowInfo>::const_reverse_iterator rend =
371 row_info.rend();
372 dst_ptr = dst.begin() + dst.size() - 1;
373 for (rri = row_info.rbegin(); rri != rend; --dst_ptr, ++rri)
374 {
375 const size_type end_row = rri->start + rri->length;
376 number s = 0;
377 for (size_type i = rri->start + rri->diagonal + 1; i < end_row; ++i)
378 s += data[i].value * dst(data[i].column);
379
380 *dst_ptr -= s * om;
381 *dst_ptr /= data[rri->start + rri->diagonal].value;
382 }
383 }
384
385
386
387 template <typename number>
388 std::size_t
389 SparseMatrixEZ<number>::memory_consumption() const
390 {
391 return sizeof(*this) + sizeof(size_type) * row_info.capacity() +
392 sizeof(typename SparseMatrixEZ<number>::Entry) * data.capacity();
393 }
394
395
396
397 template <typename number>
398 typename SparseMatrixEZ<number>::size_type
399 SparseMatrixEZ<number>::get_row_length(const size_type row) const
400 {
401 return row_info[row].length;
402 }
403
404
405
406 template <typename number>
407 typename SparseMatrixEZ<number>::size_type
408 SparseMatrixEZ<number>::n_nonzero_elements() const
409 {
410 typename std::vector<RowInfo>::const_iterator row = row_info.begin();
411 const typename std::vector<RowInfo>::const_iterator endrow = row_info.end();
412
413 // Add up entries actually used
414 size_type used = 0;
415 for (; row != endrow; ++row)
416 used += row->length;
417 return used;
418 }
419
420
421
422 template <typename number>
423 void
424 SparseMatrixEZ<number>::compute_statistics(size_type &used,
425 size_type &allocated,
426 size_type &reserved,
427 std::vector<size_type> &used_by_line,
428 const bool full) const
429 {
430 typename std::vector<RowInfo>::const_iterator row = row_info.begin();
431 const typename std::vector<RowInfo>::const_iterator endrow = row_info.end();
432
433 // Add up entries actually used
434 used = 0;
435 size_type max_length = 0;
436 for (; row != endrow; ++row)
437 {
438 used += row->length;
439 if (max_length < row->length)
440 max_length = row->length;
441 }
442
443 // Number of entries allocated is
444 // position of last entry used
445 --row;
446 allocated = row->start + row->length;
447 reserved = data.capacity();
448
449
450 if (full)
451 {
452 used_by_line.resize(max_length + 1);
453
454 for (row = row_info.begin(); row != endrow; ++row)
455 {
456 ++used_by_line[row->length];
457 }
458 }
459 }
460
461
462 template <typename number>
463 void
464 SparseMatrixEZ<number>::print(std::ostream &out) const
465 {
466 AssertThrow(out.fail() == false, ExcIO());
467
468 const_iterator i = begin();
469 const const_iterator e = end();
470 while (i != e)
471 {
472 out << i->row() << '\t' << i->column() << '\t' << i->value() << std::endl;
473 ++i;
474 }
475 }
476
477
478 template <typename number>
479 void
480 SparseMatrixEZ<number>::print_formatted(std::ostream &out,
481 const unsigned int precision,
482 const bool scientific,
483 const unsigned int width_,
484 const char *zero_string,
485 const double denominator,
486 const char *separator) const
487 {
488 AssertThrow(out.fail() == false, ExcIO());
489 Assert(m() != 0, ExcNotInitialized());
490 Assert(n() != 0, ExcNotInitialized());
491
492 unsigned int width = width_;
493
494 std::ios::fmtflags old_flags = out.flags();
495 unsigned int old_precision = out.precision(precision);
496
497 if (scientific)
498 {
499 out.setf(std::ios::scientific, std::ios::floatfield);
500 if (width == 0u)
501 width = precision + 7;
502 }
503 else
504 {
505 out.setf(std::ios::fixed, std::ios::floatfield);
506 if (width == 0u)
507 width = precision + 2;
508 }
509
510 // TODO: Skip nonexistent entries
511 for (size_type i = 0; i < m(); ++i)
512 {
513 for (size_type j = 0; j < n(); ++j)
514 {
515 const Entry *entry = locate(i, j);
516 if (entry)
517 out << std::setw(width) << entry->value * denominator << separator;
518 else
519 out << std::setw(width) << zero_string << separator;
520 }
521 out << std::endl;
522 };
523
524 // reset output format
525 out.precision(old_precision);
526 out.flags(old_flags);
527 }
528
529
530 template <typename number>
531 void
532 SparseMatrixEZ<number>::block_write(std::ostream &out) const
533 {
534 AssertThrow(out.fail() == false, ExcIO());
535
536 // first the simple objects,
537 // bracketed in [...]
538 out << '[' << row_info.size() << "][" << n_columns << "][" << data.size()
539 << "][" << increment << "][";
540 // then write out real data
541 typename std::vector<RowInfo>::const_iterator r = row_info.begin();
542 out.write(reinterpret_cast<const char *>(&*r),
543 sizeof(RowInfo) * row_info.size());
544
545 out << "][";
546
547 typename std::vector<Entry>::const_iterator d = data.begin();
548 out.write(reinterpret_cast<const char *>(&*d), sizeof(Entry) * data.size());
549
550 out << ']';
551
552 AssertThrow(out.fail() == false, ExcIO());
553 }
554
555
556 #define DEAL_II_CHECK_INPUT(in, a, c) \
557 { \
558 in >> c; \
559 AssertThrow(c == a, ExcMessage("Unexpected character in input stream")); \
560 }
561
562 template <typename number>
563 void
564 SparseMatrixEZ<number>::block_read(std::istream &in)
565 {
566 AssertThrow(in.fail() == false, ExcIO());
567
568 char c;
569 int n;
570 // first read in simple data
571 DEAL_II_CHECK_INPUT(in, '[', c);
572 in >> n;
573 row_info.resize(n);
574
575 DEAL_II_CHECK_INPUT(in, ']', c);
576 DEAL_II_CHECK_INPUT(in, '[', c);
577 in >> n_columns;
578
579 DEAL_II_CHECK_INPUT(in, ']', c);
580 DEAL_II_CHECK_INPUT(in, '[', c);
581 in >> n;
582 data.resize(n);
583
584 DEAL_II_CHECK_INPUT(in, ']', c);
585 DEAL_II_CHECK_INPUT(in, '[', c);
586 in >> increment;
587
588 DEAL_II_CHECK_INPUT(in, ']', c);
589 DEAL_II_CHECK_INPUT(in, '[', c);
590
591 // then read data
592 in.read(reinterpret_cast<char *>(row_info.data()),
593 sizeof(RowInfo) * row_info.size());
594
595 DEAL_II_CHECK_INPUT(in, ']', c);
596 DEAL_II_CHECK_INPUT(in, '[', c);
597
598 in.read(reinterpret_cast<char *>(data.data()), sizeof(Entry) * data.size());
599
600 DEAL_II_CHECK_INPUT(in, ']', c);
601 }
602
603 #undef DEAL_II_CHECK_INPUT
604
605
606
607 DEAL_II_NAMESPACE_CLOSE
608
609 #endif // dealii_sparse_matrix_ez_templates_h