Debian Codegraph @

3rdparty/dissection/src/Algebra/SquareBlockMatrix.cpp

raw
1 /*! \file SquareBlockMatrix.cpp
2 \brief Block storage for symmetric/unsymmetric Square matrix
3 \author Atsushi Suzuki, Laboratoire Jacques-Louis Lions
4 \date Jun. 11th 2013
5 \date Jul. 12th 2015
6 \date Nov. 30th 2016
7 */
8
9 // This file is part of Dissection
10 //
11 // Dissection is free software: you can redistribute it and/or modify
12 // it under the terms of the GNU General Public License as published by
13 // the Free Software Foundation, either version 3 of the License, or
14 // (at your option) any later version.
15 //
16 // Linking Dissection statically or dynamically with other modules is making
17 // a combined work based on Disssection. Thus, the terms and conditions of
18 // the GNU General Public License cover the whole combination.
19 //
20 // As a special exception, the copyright holders of Dissection give you
21 // permission to combine Dissection program with free software programs or
22 // libraries that are released under the GNU LGPL and with independent modules
23 // that communicate with Dissection solely through the Dissection-fortran
24 // interface. You may copy and distribute such a system following the terms of
25 // the GNU GPL for Dissection and the licenses of the other code concerned,
26 // provided that you include the source code of that other code when and as
27 // the GNU GPL requires distribution of source code and provided that you do
28 // not modify the Dissection-fortran interface.
29 //
30 // Note that people who make modified versions of Dissection are not obligated
31 // to grant this special exception for their modified versions; it is their
32 // choice whether to do so. The GNU General Public License gives permission to
33 // release a modified version without this exception; this exception also makes
34 // it possible to release a modified version which carries forward this
35 // exception. If you modify the Dissection-fortran interface, this exception
36 // does not apply to your modified version of Dissection, and you must remove
37 // this exception when you distribute your modified version.
38 //
39 // This exception is an additional permission under section 7 of the GNU
40 // General Public License, version 3 ("GPLv3")
41 //
42 // Dissection is distributed in the hope that it will be useful,
43 // but WITHOUT ANY WARRANTY; without even the implied warranty of
44 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
45 // GNU General Public License for more details.
46 //
47 // You should have received a copy of the GNU General Public License
48 // along with Dissection. If not, see <http://www.gnu.org/licenses/>.
49 //
50
51 #include "Algebra/SquareBlockMatrix.hpp"
52 #include "Compiler/blas.hpp" // #include<complex> is inside
53
54 template<typename T>
55 void SquareBlockMatrix<T>::init(int dim, int block_size, bool isSym,
56 int first_block)
57 {
58 int itmp;
59 _pivrelaxed = false;
60 _coefs_alloc_status = false; // for safty
61 _dim = dim;
62 _block_size = block_size;
63 _isSym = isSym;
64 _block_size2 = _block_size * _block_size;
65
66 if (dim == 0) {
67 _isblocked = true;
68 _kernelDetected = false;
69 _lower_allocated = false;
70 _coefs = NULL;
71 _coefs_alloc_status = false;
72 _allocation_status = NULL;
73 return;
74 }
75 if (first_block > 0) {
76 _isdecomposed = true;
77 _dim0 = first_block;
78 _dim1 = _dim - _dim0;
79
80 _num_blocks0 = (_dim0 + _block_size - 1) / _block_size;
81 _num_blocks1 = (_dim1 + _block_size - 1) / _block_size;
82 _num_blocks = _num_blocks0 + _num_blocks1;
83
84 _block_sizes.resize(_num_blocks);
85 itmp = _dim0 % _block_size;
86 _block_size_last0 = (itmp == 0) ? _block_size : itmp;
87 itmp = _dim1 % _block_size;
88 _block_size_last1 = (itmp == 0) ? _block_size : itmp;
89 for (int i = 0; i < (_num_blocks0 - 1); i++) {
90 _block_sizes[i] = _block_size;
91 }
92 _block_sizes[_num_blocks0 - 1] = _block_size_last0;
93 if (_num_blocks1 > 0) {
94 for (int i = _num_blocks0; i < (_num_blocks - 1); i++) {
95 _block_sizes[i] = _block_size;
96 }
97 _block_sizes[_num_blocks - 1] = _block_size_last1;
98 }
99 else {
100 _block_size_last1 = 0;
101 }
102 }
103 else {
104 _isdecomposed = false;
105 _num_blocks = (_dim + _block_size - 1) / _block_size;
106 _block_sizes.resize(_num_blocks);
107 itmp = _dim % _block_size;
108 _block_size_last = (itmp == 0) ? _block_size : itmp;
109 for (int i = 0; i < (_num_blocks - 1); i++) {
110 _block_sizes[i] = _block_size;
111 }
112 _block_sizes[_num_blocks - 1] = _block_size_last;
113 }
114 _nsing_block.resize(_num_blocks);
115 if (_num_blocks > 0) {
116 for (int i = 0; i < _num_blocks; i++) {
117 _nsing_block[i] = 0;
118 }
119 }
120 _isblocked = true;
121 _kernelDetected = false;
122 _lower_allocated = false;
123
124 if (_num_blocks > 0) {
125 try {
126 _coefs = new T*[_num_blocks * _num_blocks]; // need to be managed
127 } catch (const std::bad_alloc& e) {
128 fprintf(stderr, "%s %d : allocation failed : %s", __FILE__, __LINE__,
129 e.what());
130 }
131 try {
132 _allocation_status = new bool[_num_blocks * _num_blocks];
133 } catch (const std::bad_alloc& e) {
134 fprintf(stderr, "%s %d : allocation failed : %s", __FILE__, __LINE__,
135 e.what());
136 }
137 _coefs_alloc_status = true;
138 for (int i = 0; i < (_num_blocks * _num_blocks); i++) {
139 _allocation_status[i] = false;
140 }
141 if (_isSym) {
142 _size = 0;
143 for (int i = 0; i < _num_blocks; i++) {
144 for (int j = i; j < _num_blocks; j++) {
145 _size += _block_sizes[i] * _block_sizes[j];
146 }
147 }
148 }
149 else {
150 _size = 0;
151 for (int i = 0; i < _num_blocks; i++) {
152 for (int j = 0; j < _num_blocks; j++) {
153 _size += _block_sizes[i] * _block_sizes[j];
154 }
155 }
156 }
157 }
158 else {
159 _coefs = NULL;
160 _coefs_alloc_status = false;
161 _allocation_status = NULL;
162 }
163 }
164
165 template
166 void SquareBlockMatrix<double>::init(int dim, int block_size, bool isSym,
167 int first_block);
168 template
169 void SquareBlockMatrix<quadruple>::init(int dim, int block_size, bool isSym,
170 int first_block);
171 template
172 void SquareBlockMatrix<complex<double> >::init(int dim, int block_size,
173 bool isSym, int first_block);
174 template
175 void SquareBlockMatrix<complex<quadruple> >::init(int dim, int block_size,
176 bool isSym, int first_block);
177
178 template
179 void SquareBlockMatrix<float>::init(int dim, int block_size, bool isSym,
180 int first_block);
181 template
182 void SquareBlockMatrix<complex<float> >::init(int dim, int block_size,
183 bool isSym, int first_block);
184
185 //
186
187 template<typename T>
188 void SquareBlockMatrix<T>::allocateBlock(int i, int j)
189 {
190 const int nrow = _block_sizes[i];
191 const int ncol = _block_sizes[j];
192 const int itmp = i + j * _num_blocks;
193 if (!_allocation_status[itmp]) {
194 try {
195 _coefs[itmp] = new T[nrow * ncol];
196 } catch (const std::bad_alloc& e) {
197 fprintf(stderr, "%s %d : allocation failed : %s", __FILE__, __LINE__,
198 e.what());
199 }
200 _allocation_status[itmp] = true;
201 }
202 }
203
204 template
205 void SquareBlockMatrix<double>::allocateBlock(int i, int j);
206 template
207 void SquareBlockMatrix<quadruple>::allocateBlock(int i, int j);
208 template
209 void SquareBlockMatrix<complex<double> >::allocateBlock(int i, int j);
210 template
211 void SquareBlockMatrix<complex<quadruple> >::allocateBlock(int i, int j);
212 template
213 void SquareBlockMatrix<float>::allocateBlock(int i, int j);
214 template
215 void SquareBlockMatrix<complex<float> >::allocateBlock(int i, int j);
216
217 //
218
219 template<typename T>
220 void SquareBlockMatrix<T>::allocate()
221 {
222 if (_isSym) {
223 // int ioffset = 0;
224 for (int i = 0; i < _num_blocks; i++) {
225 for (int j = i; j < _num_blocks; j++) {
226 const int nrow = _block_sizes[i];
227 const int ncol = _block_sizes[j];
228 const int itmp = i + j * _num_blocks;
229 if (!_allocation_status[itmp]) {
230 try {
231 _coefs[itmp] = new T[nrow * ncol];
232 } catch (const std::bad_alloc& e) {
233 fprintf(stderr, "%s %d : allocation failed : %s",
234 __FILE__, __LINE__,
235 e.what());
236 }
237 }
238 _allocation_status[itmp] = true;
239 }
240 }
241 }
242 else {
243 // int ioffset = 0;
244 for (int i = 0; i < _num_blocks; i++) {
245 for (int j = 0; j < _num_blocks; j++) {
246 const int nrow = _block_sizes[i];
247 const int ncol = _block_sizes[j];
248 const int itmp = i + j * _num_blocks;
249 if (!_allocation_status[itmp]) {
250 try {
251 _coefs[itmp] = new T[nrow * ncol];
252 } catch (const std::bad_alloc& e) {
253 fprintf(stderr, "%s %d : allocation failed : %s",
254 __FILE__, __LINE__,
255 e.what());
256 }
257 }
258 _allocation_status[itmp] = true;
259 }
260 }
261 }
262 }
263
264 template
265 void SquareBlockMatrix<double>::allocate();
266 template
267 void SquareBlockMatrix<quadruple>::allocate();
268 template
269 void SquareBlockMatrix<complex<double> >::allocate();
270 template
271 void SquareBlockMatrix<complex<quadruple> >::allocate();
272 template
273 void SquareBlockMatrix<float>::allocate();
274 template
275 void SquareBlockMatrix<complex<float> >::allocate();
276 //
277
278 template<typename T>
279 void SquareBlockMatrix<T>::free(int i, int j)
280 {
281 const int itmp = i + j * _num_blocks;
282 if (_allocation_status[itmp]) {
283 delete [] _coefs[itmp]; // need to be mananged
284 }
285 _allocation_status[itmp] = false;
286 }
287
288 template
289 void SquareBlockMatrix<double>::free(int i, int j);
290 template
291 void SquareBlockMatrix<quadruple>::free(int i, int j);
292 template
293 void SquareBlockMatrix<complex<double> >::free(int i, int j);
294 template
295 void SquareBlockMatrix<complex<quadruple> >::free(int i, int j);
296 template
297 void SquareBlockMatrix<float>::free(int i, int j);
298 template
299 void SquareBlockMatrix<complex<float> >::free(int i, int j);
300
301 //
302
303 template<typename T>
304 void SquareBlockMatrix<T>::free()
305 {
306 if (_isSym) {
307 for (int i = 0; i < _num_blocks; i++) {
308 for (int j = i; j < _num_blocks; j++) {
309 const int itmp = i + j * _num_blocks;
310 if (_allocation_status[itmp]) {
311 delete [] _coefs[itmp]; // need to be mananged
312 }
313 _allocation_status[itmp]= false;
314 }
315 }
316 }
317 else {
318 for (int i = 0; i < _num_blocks; i++) {
319 for (int j = 0; j < _num_blocks; j++) {
320 const int itmp = i + j * _num_blocks;
321 if (_allocation_status[itmp]) {
322 delete [] _coefs[itmp]; // need to be managed
323 }
324 _allocation_status[itmp] = false;
325 }
326 }
327 }
328 }
329 template
330 void SquareBlockMatrix<double>::free();
331 template
332 void SquareBlockMatrix<quadruple>::free();
333 template
334 void SquareBlockMatrix<complex<double> >::free();
335 template
336 void SquareBlockMatrix<complex<quadruple> >::free();
337 template
338 void SquareBlockMatrix<float>::free();
339 template
340 void SquareBlockMatrix<complex<float> >::free();
341
342 //
343
344 template<typename T>
345 T* SquareBlockMatrix<T>::addrCoefBlock(int i, int j)
346 {
347 if (_isdecomposed) { // is necessary?
348 if (_isSym && (i > j)) {
349 return _coefs[j + i * _num_blocks];
350 }
351 }
352 return _coefs[i + j * _num_blocks];
353 }
354
355 template
356 double* SquareBlockMatrix<double>::addrCoefBlock(int i, int j);
357
358 template
359 quadruple* SquareBlockMatrix<quadruple>::addrCoefBlock(int i, int j);
360
361 template
362 complex<double>* SquareBlockMatrix<complex<double> >::
363 addrCoefBlock(int i, int j);
364
365 template
366 complex<quadruple>* SquareBlockMatrix<complex<quadruple> >::
367 addrCoefBlock(int i, int j);
368
369 template
370 float* SquareBlockMatrix<float>::addrCoefBlock(int i, int j);
371
372 template
373 complex<float>* SquareBlockMatrix<complex<float> >::
374 addrCoefBlock(int i, int j);
375
376 //
377
378 template<typename T>
379 void SquareBlockMatrix<T>::ZeroClear()
380 {
381 const T zero(0.0);
382 if (_isSym) {
383 for (int i = 0; i < _num_blocks; i++) {
384 for (int j = i; j < _num_blocks; j++) {
385 const int nrow = _block_sizes[i];
386 const int ncol = _block_sizes[j];
387 const int nsize = nrow * ncol;
388 const int itmp = i + j * _num_blocks;
389 for (int k = 0; k < nsize; k++) {
390 _coefs[itmp][k] = zero; // needs to be replaced by memcpy
391 }
392 }
393 }
394 }
395 else {
396 for (int i = 0; i < _num_blocks; i++) {
397 for (int j = 0; j < _num_blocks; j++) {
398 const int nrow = _block_sizes[i];
399 const int ncol = _block_sizes[j];
400 const int nsize = nrow * ncol;
401 const int itmp = i + j * _num_blocks;
402 for (int k = 0; k < nsize; k++) {
403 _coefs[itmp][k] = zero; // needs to be replaced by memcpy
404 }
405 }
406 }
407 }
408 }
409
410 template
411 void SquareBlockMatrix<double>::ZeroClear();
412
413 template
414 void SquareBlockMatrix<quadruple>::ZeroClear();
415
416 template
417 void SquareBlockMatrix<complex<double> >::ZeroClear();
418
419 template
420 void SquareBlockMatrix<complex<quadruple> >::ZeroClear();
421
422 template
423 void SquareBlockMatrix<float>::ZeroClear();
424
425 template
426 void SquareBlockMatrix<complex<float> >::ZeroClear();
427
428 //
429
430 template<typename T>
431 T& SquareBlockMatrix<T>::diag(int i)
432 {
433 int i0, i1;
434 if(_isdecomposed) {
435 fprintf(stderr, "%s %d : operator() is not suppoesd to be used\n",
436 __FILE__, __LINE__);
437 i0 = BlockIndex(i);
438 i1 = BlockOffset(i);
439 }
440 else {
441 i0 = i / _block_size;
442 i1 = i % _block_size;
443 }
444 // const int itmp = offsetBlock(i0, i0) + i1 * (nrowBlock(i0, i0) + 1);
445 // return coefs()[itmp];
446 return _coefs[i0 * (_num_blocks + 1)][i1 * (nrowBlock(i0, i0) + 1)];
447 }
448
449 template
450 double& SquareBlockMatrix<double>::diag(int i);
451
452 template
453 quadruple& SquareBlockMatrix<quadruple>::diag(int i);
454
455 template
456 complex<double> & SquareBlockMatrix<complex<double> >::diag(int i);
457
458 template
459 complex<quadruple> & SquareBlockMatrix<complex<quadruple> >::diag(int i);
460
461 template
462 float& SquareBlockMatrix<float>::diag(int i);
463
464 template
465 complex<float> & SquareBlockMatrix<complex<float> >::diag(int i);
466 //
467
468 template<typename T>
469 const T& SquareBlockMatrix<T>::diag(int i) const
470 {
471 int i0, i1;
472 if(_isdecomposed) {
473 fprintf(stderr, "%s %d : operator() is not suppoesd to be used\n",
474 __FILE__, __LINE__);
475 i0 = BlockIndex(i);
476 i1 = BlockOffset(i);
477 }
478 else {
479 i0 = i / _block_size;
480 i1 = i % _block_size;
481 }
482 return _coefs[i0 * (_num_blocks + 1)][i1 * (nrowBlock(i0, i0) + 1)];
483 }
484
485 template
486 const double & SquareBlockMatrix<double>::diag(int i) const;
487
488 template
489 const quadruple & SquareBlockMatrix<quadruple>::diag(int i) const;
490
491 template
492 const complex<double> & SquareBlockMatrix<complex<double> >::diag(int i) const;
493
494 template
495 const complex<quadruple> & SquareBlockMatrix<complex<quadruple> >::
496 diag(int i) const;
497
498 template
499 const float & SquareBlockMatrix<float>::diag(int i) const;
500
501 template
502 const complex<float> & SquareBlockMatrix<complex<float> >::diag(int i) const;
503 //
504
505 template<typename T>
506 T& SquareBlockMatrix<T>::operator () (int i, int j)
507 {
508 int i0, i1, j0, j1;
509 if(_isdecomposed) {
510 fprintf(stderr, "%s %d : operator() is not suppoesd to be used\n",
511 __FILE__, __LINE__);
512 if (_isSym) {
513 if (i < j) {
514 i0 = BlockIndex(i);
515 j0 = BlockIndex(j);
516 i1 = BlockOffset(i);
517 j1 = BlockOffset(j);
518 }
519 else {
520 i0 = BlockIndex(j);
521 j0 = BlockIndex(i);
522 i1 = BlockOffset(j);
523 j1 = BlockOffset(i);
524 }
525 }
526 else {
527 i0 = BlockIndex(i);
528 j0 = BlockIndex(j);
529 if(i0 > j0) {
530 i1 = BlockOffset(j);
531 j1 = BlockOffset(i);
532 }
533 else {
534 i1 = BlockOffset(i);
535 j1 = BlockOffset(j);
536 }
537 }
538 } // if(_isdecomposed) {
539 else {
540 if (_isSym) {
541 if (i < j) {
542 i0 = i / _block_size;
543 i1 = i % _block_size;
544 j0 = j / _block_size;
545 j1 = j % _block_size;
546 }
547 else {
548 i0 = j / _block_size;
549 i1 = j % _block_size;
550 j0 = i / _block_size;
551 j1 = i % _block_size;
552 }
553 }
554 else {
555 i0 = i / _block_size;
556 j0 = j / _block_size;
557 if (i0 > j0) {
558 i1 = j % _block_size;
559 j1 = i % _block_size;
560 }
561 else {
562 i1 = i % _block_size;
563 j1 = j % _block_size;
564 }
565 }
566 } // if(_isdecomposed) else
567 return _coefs[i0 + j0 * _num_blocks][i1 + j1 * nrowBlock(i0, j0)];
568 }
569
570 template
571 double& SquareBlockMatrix<double>::operator () (int i, int j);
572
573 template
574 quadruple& SquareBlockMatrix<quadruple>::operator () (int i, int j);
575
576 template
577 complex<double> & SquareBlockMatrix<complex<double> >::
578 operator () (int i, int j);
579
580 template
581 complex<quadruple> & SquareBlockMatrix<complex<quadruple> >::
582 operator () (int i, int j);
583
584 template
585 float& SquareBlockMatrix<float>::operator () (int i, int j);
586
587 template
588 complex<float> & SquareBlockMatrix<complex<float> >::
589 operator () (int i, int j);
590 //
591
592 template<typename T>
593 const T& SquareBlockMatrix<T>::operator () (int i, int j) const
594 {
595 int i0, i1, j0, j1;
596 if(_isdecomposed) {
597 fprintf(stderr, "%s %d : operator() is not suppoesd to be used\n",
598 __FILE__, __LINE__);
599 if (_isSym) {
600 if (i < j) {
601 i0 = BlockIndex(i);
602 j0 = BlockIndex(j);
603 i1 = BlockOffset(i);
604 j1 = BlockOffset(j);
605 }
606 else {
607 i0 = BlockIndex(j);
608 j0 = BlockIndex(i);
609 i1 = BlockOffset(j);
610 j1 = BlockOffset(i);
611 }
612 }
613 else {
614 i0 = BlockIndex(i);
615 j0 = BlockIndex(j);
616 if(i0 > j0) {
617 i1 = BlockOffset(j);
618 j1 = BlockOffset(i);
619 }
620 else {
621 i1 = BlockOffset(i);
622 j1 = BlockOffset(j);
623 }
624 }
625 } // if(_isdecomposed) {
626 else {
627 if (_isSym) {
628 if (i < j) {
629 i0 = i / _block_size;
630 i1 = i % _block_size;
631 j0 = j / _block_size;
632 j1 = j % _block_size;
633 }
634 else {
635 i0 = j / _block_size;
636 i1 = j % _block_size;
637 j0 = i / _block_size;
638 j1 = i % _block_size;
639 }
640 }
641 else {
642 i0 = i / _block_size;
643 j0 = j / _block_size;
644 if (i0 > j0) {
645 i1 = j % _block_size;
646 j1 = i % _block_size;
647 }
648 else {
649 i1 = i % _block_size;
650 j1 = j % _block_size;
651 }
652 }
653 } // if(_isdecomposed) else
654 return _coefs[i0 + j0 * _num_blocks][i1 + j1 * nrowBlock(i0, j0)];
655 }
656
657 template
658 const double& SquareBlockMatrix<double>::operator () (int i, int j) const;
659
660 template
661 const quadruple& SquareBlockMatrix<quadruple>::operator () (int i, int j) const;
662
663 template
664 const complex<double>& SquareBlockMatrix<complex<double> >::
665 operator () (int i, int j) const;
666
667 template
668 const complex<quadruple>& SquareBlockMatrix<complex<quadruple> >::
669 operator () (int i, int j) const;
670
671 template
672 const float& SquareBlockMatrix<float>::operator () (int i, int j) const;
673
674 template
675 const complex<float>& SquareBlockMatrix<complex<float> >::
676 operator () (int i, int j) const;
677 //
678
679 template<typename T>
680 void SquareBlockMatrix<T>::copyFromArray(const T *a, int dim)
681 {
682 if (_isdecomposed) {
683 fprintf(stderr, "%s %d : copyFromArray() cannot copy decompesd data\n",
684 __FILE__, __LINE__);
685 return;
686 }
687 if (dim != _dim) {
688 fprintf(stderr, "%s %d : mismatched dim %d != %d\n",
689 __FILE__, __LINE__, dim, _dim);
690 return;
691 }
692 for (int ki = 0; ki < _num_blocks; ki++) {
693 const int n_row = ((ki == (_num_blocks - 1)) ?
694 _block_size_last : _block_size);
695 const int dst_row = n_row;
696 for (int kj = ki; kj < _num_blocks; kj++) {
697 const int n_col = ((kj == (_num_blocks - 1)) ?
698 _block_size_last : _block_size);
699 T *a_upper = addrCoefBlock(ki, kj);
700 int j, j0, j1;
701 for (j1 = (ki + kj * _dim) * _block_size, j0 = 0, j = 0;
702 j < n_col; j++, j1 += _dim, j0 += dst_row) {
703 blas_copy(n_row, (T *)a + j1, 1, a_upper + j0, 1);
704 }
705 } // loop : kj
706 } // loop : ki
707 if (!_isSym) {
708 for (int ki = 0; ki < _num_blocks; ki++) {
709 const int n_row = (ki == (_num_blocks - 1)) ?
710 _block_size_last : _block_size;
711 for (int kj = 0; kj < ki; kj++) {
712 const int n_col = _block_size;
713 T *a_lower = addrCoefBlock(ki, kj);
714 int dst_row = nrowBlock(ki, kj);
715 int j, j0, j1;
716 for (j1 = (ki + kj * _dim) * _block_size, j0 = 0, j = 0;
717 j < n_col; j++, j1 += _dim, j0++) {
718 blas_copy(n_row, (T *)a + j1, 1, a_lower + j0, dst_row);
719 }
720 } // loop : kj
721 } // loop : ki
722 } // if (!isSym)
723 }
724
725 template
726 void SquareBlockMatrix<double>::copyFromArray(const double *a, int dim);
727
728 template
729 void SquareBlockMatrix<quadruple>::copyFromArray(const quadruple *a, int dim);
730
731 template
732 void SquareBlockMatrix<complex<double> >::
733 copyFromArray(const complex<double> *a, int dim);
734
735 template
736 void SquareBlockMatrix<complex<quadruple> >::
737 copyFromArray(const complex<quadruple> *a, int dim);
738
739 template
740 void SquareBlockMatrix<float>::copyFromArray(const float *a, int dim);
741
742 template
743 void SquareBlockMatrix<complex<float> >::
744 copyFromArray(const complex<float> *a, int dim);
745 //
746
747 template<typename T>
748 void SquareBlockMatrix<T>::copyFromArrayPermute(const T *a, int dim,
749 int *permute)
750 {
751 if (_isdecomposed) {
752 fprintf(stderr, "%s %d : copyFromArray() cannot copy decompesd data\n",
753 __FILE__, __LINE__);
754 return;
755 }
756 if (dim != _dim) {
757 fprintf(stderr, "%s %d : mismatched dim %d != %d\n",
758 __FILE__, __LINE__, dim, _dim);
759 return;
760 }
761 for (int ki = 0; ki < _num_blocks; ki++) {
762 const int n_row = ((ki == (_num_blocks - 1)) ?
763 _block_size_last : _block_size);
764 const int dst_row = n_row;
765 for (int kj = ki; kj < _num_blocks; kj++) {
766 const int n_col = ((kj == (_num_blocks - 1)) ?
767 _block_size_last : _block_size);
768 T *a_upper = addrCoefBlock(ki, kj);
769 int j, j0, j1;
770 for (j1 = (ki + kj * _dim) * _block_size, j0 = 0, j = 0;
771 j < n_col; j++, j1 += _dim, j0 += dst_row) {
772 const int jj = permute[kj * _block_size + j];
773 int ii = ki * _block_size;
774 int kk = j0;
775 if (!_isSym) {
776 for (int i = 0; i < n_row; i++, kk++, ii++) {
777 a_upper[kk] = a[permute[ii] + jj * _dim];
778 }
779 }
780 else {
781 for (int i = 0; i < n_row; i++, kk++, ii++) {
782 const int itmp = permute[ii];
783 a_upper[kk] = a[itmp <= jj ? itmp + jj * _dim : jj + itmp * _dim];
784 }
785 } // if (!isSym) {
786 // blas_copy(n_row, (T *)a + j1, 1, a_upper + j0, 1);
787 }
788 } // loop : kj
789 } // loop : ki
790 if (!_isSym) {
791 for (int ki = 0; ki < _num_blocks; ki++) {
792 const int n_row = ((ki == (_num_blocks - 1)) ?
793 _block_size_last : _block_size);
794 for (int kj = 0; kj < ki; kj++) {
795 const int n_col = _block_size;
796 T *a_lower = addrCoefBlock(ki, kj);
797 const int dst_row = nrowBlock(ki, kj);
798 int j, j0, j1;
799 for (j1 = (ki + kj * _dim) * _block_size, j0 = 0, j = 0;
800 j < n_col; j++, j1 += _dim, j0++) {
801 const int jj = permute[kj * _block_size + j];
802 int ii = ki * _block_size;
803 int kk = j0;
804 for (int i = 0; i < n_row; i++, ii++, kk += dst_row) {
805 a_lower[kk] = a[permute[ii] + jj * _dim];
806 }
807 // blas_copy(n_row, (T *)a + j1, 1, a_lower + j0, dst_row);
808 }
809 } // loop : kj
810 } // loop : ki
811 } // if (!isSym)
812 }
813
814 template
815 void SquareBlockMatrix<double>::copyFromArrayPermute(const double *a, int dim,
816 int *permute);
817
818 template
819 void SquareBlockMatrix<quadruple>::copyFromArrayPermute(const quadruple *a,
820 int dim,
821 int *permute);
822
823 template
824 void SquareBlockMatrix<complex<double> >::
825 copyFromArrayPermute(const complex<double> *a, int dim,
826 int *permute);
827
828 template
829 void SquareBlockMatrix<complex<quadruple> >::
830 copyFromArrayPermute(const complex<quadruple> *a, int dim,
831 int *permute);
832 template
833 void SquareBlockMatrix<float>::copyFromArrayPermute(const float *a, int dim,
834 int *permute);
835 template
836 void SquareBlockMatrix<complex<float> >::
837 copyFromArrayPermute(const complex<float> *a, int dim,
838 int *permute);
839
840 //
841
842 template<typename T>
843 void SquareBlockMatrix<T>::copyToArrayFull(const T *a, int dim)
844 {
845 if (dim != _dim) {
846 fprintf(stderr, "%s %d : mismatched dim %d != %d\n",
847 __FILE__, __LINE__, dim, _dim);
848 return;
849 }
850 // copy upper part
851 for (int ki = 0; ki < _num_blocks; ki++) {
852 const int n_row = ((ki == (_num_blocks - 1)) ?
853 _block_size_last : _block_size);
854 const int dst_row = n_row;
855 for (int kj = ki; kj < _num_blocks; kj++) {
856 const int n_col = ((kj == (_num_blocks - 1)) ?
857 _block_size_last : _block_size);
858 T *a_upper = addrCoefBlock(ki, kj);
859 int j, j0, j1;
860 for (j1 = (ki + kj * _dim) * _block_size, j0 = 0, j = 0;
861 j < n_col; j++, j1 += _dim, j0 += dst_row) {
862 blas_copy(n_row, a_upper + j0, 1, (T *)a + j1, 1);
863 }
864 } // loop : kj
865 } // loop : ki
866 // copy lower part
867 if (_isSym) {
868 for (int ki = 0; ki < _num_blocks; ki++) {
869 const int n_row = ((ki == (_num_blocks - 1)) ?
870 _block_size_last : _block_size);
871 for (int kj = 0; kj < ki; kj++) {
872 const int n_col = _block_size;
873 const int dst_col = n_col;
874 T *a_upper = addrCoefBlock(kj, ki); // transposed access
875 int j, j0, j1;
876 for (j1 = (ki + kj * _dim) * _block_size, j0 = 0, j = 0;
877 j < n_row; j++, j1++, j0 += dst_col) {
878 blas_copy(n_col, a_upper + j0, 1, (T *)a + j1, _dim);
879 }
880 } // loop : kj
881 } // loop : ki
882 }
883 else {
884 for (int ki = 0; ki < _num_blocks; ki++) {
885 const int n_row = ((ki == (_num_blocks - 1)) ?
886 _block_size_last : _block_size);
887 for (int kj = 0; kj < ki; kj++) {
888 const int n_col = _block_size;
889 T *a_upper = addrCoefBlock(ki, kj);
890 const int src_row = nrowBlock(ki, kj);
891 int j, j0, j1;
892 for (j1 = (ki + kj * _dim) * _block_size, j0 = 0, j = 0;
893 j < n_col; j++, j1 += _dim, j0++) {
894 blas_copy(n_row, a_upper + j0, src_row, (T *)a + j1, 1);
895 }
896 } // loop : kj
897 } // loop : ki
898 }
899 }
900
901 template
902 void SquareBlockMatrix<double>::copyToArrayFull(const double *a, int dim);
903
904 template
905 void SquareBlockMatrix<quadruple>::copyToArrayFull(const quadruple *a, int dim);
906
907 template
908 void SquareBlockMatrix<complex<double> >::
909 copyToArrayFull(const complex<double> *a, int dim);
910
911 template
912 void SquareBlockMatrix<complex<quadruple> >::
913 copyToArrayFull(const complex<quadruple> *a, int dim);
914
915 template
916 void SquareBlockMatrix<float>::copyToArrayFull(const float *a, int dim);
917
918 template
919 void SquareBlockMatrix<complex<float> >::
920 copyToArrayFull(const complex<float> *a, int dim);
921 //
922
923 template<typename T>
924 void SquareBlockMatrix<T>::copyBlockToArray(int i, int j, const T *a, int dim)
925 {
926 if (dim != _dim) {
927 fprintf(stderr, "%s %d : mismatched dim %d != %d\n",
928 __FILE__, __LINE__, dim, _dim);
929 return;
930 }
931 if (_isSym && i > j) {
932 fprintf(stderr,
933 "%s %d : symmetric matrix has upper block only : %d > %d\n",
934 __FILE__, __LINE__, i, j);
935 return;
936 }
937 T *a_src = addrCoefBlock(i, j);
938 int j0, j1, j2;
939 if (i <= j) {
940 const int n_row = ((i == (_num_blocks - 1)) ?
941 _block_size_last : _block_size);
942 const int dst_row = n_row;
943 const int n_col = ((j == (_num_blocks - 1)) ?
944 _block_size_last : _block_size);
945 for (j2 = (i + j * _dim) * _block_size, j1 = 0, j0 = 0;
946 j0 < n_col; j0++, j1 += dst_row, j2 += _dim) {
947 blas_copy(n_row, a_src + j1, 1, (T *)a + j2, 1);
948 }
949 }
950 else {
951 const int n_row = ((i == (_num_blocks - 1)) ?
952 _block_size_last : _block_size);
953 const int n_col = ((j == (_num_blocks - 1)) ?
954 _block_size_last : _block_size);
955 const int dst_col = n_col;
956 for (j2 = (i + j * _dim) * _block_size, j1 = 0, j0 = 0;
957 j0 < n_col; j0++, j1++, j2 += _dim) {
958 blas_copy(n_row, a_src + j1, dst_col, (T *)a + j2, 1);
959 }
960 }
961 }
962
963 template
964 void SquareBlockMatrix<double>::copyBlockToArray(int i, int j,
965 const double *a, int dim);
966
967 template
968 void SquareBlockMatrix<quadruple>::copyBlockToArray(int i, int j,
969 const quadruple *a,
970 int dim);
971 template
972 void SquareBlockMatrix<complex<double> >::
973 copyBlockToArray(int i, int j, const complex<double> *a, int dim);
974
975 template
976 void SquareBlockMatrix<complex<quadruple> >::
977 copyBlockToArray(int i, int j, const complex<quadruple> *a, int dim);
978
979 template
980 void SquareBlockMatrix<float>::copyBlockToArray(int i, int j,
981 const float *a, int dim);
982
983 template
984 void SquareBlockMatrix<complex<float> >::
985 copyBlockToArray(int i, int j, const complex<float> *a, int dim);