PSCF v1.3.2
cuda/VecOp.h
1#ifndef PRDC_VEC_OP_H
2#define PRDC_VEC_OP_H
3
4/*
5* PSCF - Polymer Self-Consistent Field
6*
7* Copyright 2015 - 2025, The Regents of the University of Minnesota
8* Distributed under the terms of the GNU General Public License.
9*/
10
11#include "types.h"
12#include <pscf/cuda/DeviceArray.h>
13
14namespace Pscf {
15namespace Prdc {
16namespace Cuda {
17
75namespace VecOp {
76
77// Assignment operations:
78// ~~~~~~~~~~~~~~~~~~~~~~
79
89void eqV(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
90 const int beginIdA, const int beginIdB, const int n);
91
98inline void eqV(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b)
99{ eqV(a, b, 0, 0, a.capacity()); }
100
110void eqV(DeviceArray<cudaComplex>& a, DeviceArray<cudaComplex> const & b,
111 const int beginIdA, const int beginIdB, const int n);
112
119inline void eqV(DeviceArray<cudaComplex>& a,
120 DeviceArray<cudaComplex> const & b)
121{ eqV(a, b, 0, 0, a.capacity()); }
122
131void eqS(DeviceArray<cudaReal>& a, const cudaReal b,
132 const int beginIdA, const int n);
133
140inline void eqS(DeviceArray<cudaReal>& a, const cudaReal b)
141{ eqS(a, b, 0, a.capacity()); }
142
151void eqS(DeviceArray<cudaComplex>& a, const cudaComplex b,
152 const int beginIdA, const int n);
153
160inline void eqS(DeviceArray<cudaComplex>& a, const cudaComplex b)
161{ eqS(a, b, 0, a.capacity()); }
162
163
164// Addition operations
165// ~~~~~~~~~~~~~~~~~~~
166
178void addVV(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
179 DeviceArray<cudaReal> const & c, const int beginIdA,
180 const int beginIdB, const int beginIdC, const int n);
181
189inline void addVV(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
190 DeviceArray<cudaReal> const & c)
191{ addVV(a, b, c, 0, 0, 0, a.capacity()); }
192
204void addVV(DeviceArray<cudaComplex>& a, DeviceArray<cudaComplex> const & b,
205 DeviceArray<cudaComplex> const & c, const int beginIdA,
206 const int beginIdB, const int beginIdC, const int n);
207
215inline void addVV(DeviceArray<cudaComplex>& a,
216 DeviceArray<cudaComplex> const & b,
217 DeviceArray<cudaComplex> const & c)
218{ addVV(a, b, c, 0, 0, 0, a.capacity()); }
219
231void addVV(DeviceArray<cudaComplex>& a, DeviceArray<cudaReal> const & b,
232 DeviceArray<cudaComplex> const & c, const int beginIdA,
233 const int beginIdB, const int beginIdC, const int n);
234
242inline void addVV(DeviceArray<cudaComplex>& a,
243 DeviceArray<cudaReal> const & b,
244 DeviceArray<cudaComplex> const & c)
245{ addVV(a, b, c, 0, 0, 0, a.capacity()); }
246
258void addVV(DeviceArray<cudaComplex>& a, DeviceArray<cudaComplex> const & b,
259 DeviceArray<cudaReal> const & c, const int beginIdA,
260 const int beginIdB, const int beginIdC, const int n);
261
269inline void addVV(DeviceArray<cudaComplex>& a,
270 DeviceArray<cudaComplex> const & b,
271 DeviceArray<cudaReal> const & c)
272{ addVV(a, b, c, 0, 0, 0, a.capacity()); }
273
284void addVS(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
285 const cudaReal c, const int beginIdA,
286 const int beginIdB, const int n);
287
295inline void addVS(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
296 const cudaReal c)
297{ addVS(a, b, c, 0, 0, a.capacity()); }
298
309void addVS(DeviceArray<cudaComplex>& a, DeviceArray<cudaComplex> const & b,
310 const cudaComplex c, const int beginIdA,
311 const int beginIdB, const int n);
312
320inline void addVS(DeviceArray<cudaComplex>& a,
321 DeviceArray<cudaComplex> const & b, const cudaComplex c)
322{ addVS(a, b, c, 0, 0, a.capacity()); }
323
334void addVS(DeviceArray<cudaComplex>& a, DeviceArray<cudaReal> const & b,
335 const cudaComplex c, const int beginIdA,
336 const int beginIdB, const int n);
337
345inline void addVS(DeviceArray<cudaComplex>& a, DeviceArray<cudaReal> const & b,
346 const cudaComplex c)
347{ addVS(a, b, c, 0, 0, a.capacity()); }
348
359void addVS(DeviceArray<cudaComplex>& a, DeviceArray<cudaComplex> const & b,
360 const cudaReal c, const int beginIdA,
361 const int beginIdB, const int n);
362
370inline void addVS(DeviceArray<cudaComplex>& a,
371 DeviceArray<cudaComplex> const & b, const cudaReal c)
372{ addVS(a, b, c, 0, 0, a.capacity()); }
373
374
375// Subtraction operations
376// ~~~~~~~~~~~~~~~~~~~~~~
377
389void subVV(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
390 DeviceArray<cudaReal> const & c, const int beginIdA,
391 const int beginIdB, const int beginIdC, const int n);
392
400inline void subVV(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
401 DeviceArray<cudaReal> const & c)
402{ subVV(a, b, c, 0, 0, 0, a.capacity()); }
403
415void subVV(DeviceArray<cudaComplex>& a, DeviceArray<cudaComplex> const & b,
416 DeviceArray<cudaComplex> const & c, const int beginIdA,
417 const int beginIdB, const int beginIdC, const int n);
418
426inline void subVV(DeviceArray<cudaComplex>& a,
427 DeviceArray<cudaComplex> const & b,
428 DeviceArray<cudaComplex> const & c)
429{ subVV(a, b, c, 0, 0, 0, a.capacity()); }
430
442void subVV(DeviceArray<cudaComplex>& a, DeviceArray<cudaReal> const & b,
443 DeviceArray<cudaComplex> const & c, const int beginIdA,
444 const int beginIdB, const int beginIdC, const int n);
445
453inline void subVV(DeviceArray<cudaComplex>& a, DeviceArray<cudaReal> const & b,
454 DeviceArray<cudaComplex> const & c)
455{ subVV(a, b, c, 0, 0, 0, a.capacity()); }
456
468void subVV(DeviceArray<cudaComplex>& a, DeviceArray<cudaComplex> const & b,
469 DeviceArray<cudaReal> const & c, const int beginIdA,
470 const int beginIdB, const int beginIdC, const int n);
471
479inline void subVV(DeviceArray<cudaComplex>& a,
480 DeviceArray<cudaComplex> const & b,
481 DeviceArray<cudaReal> const & c)
482{ subVV(a, b, c, 0, 0, 0, a.capacity()); }
483
494void subVS(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
495 const cudaReal c, const int beginIdA,
496 const int beginIdB, const int n);
497
505inline void subVS(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
506 const cudaReal c)
507{ subVS(a, b, c, 0, 0, a.capacity()); }
508
519void subVS(DeviceArray<cudaComplex>& a, DeviceArray<cudaComplex> const & b,
520 const cudaComplex c, const int beginIdA,
521 const int beginIdB, const int n);
522
530inline void subVS(DeviceArray<cudaComplex>& a,
531 DeviceArray<cudaComplex> const & b, const cudaComplex c)
532{ subVS(a, b, c, 0, 0, a.capacity()); }
533
544void subVS(DeviceArray<cudaComplex>& a, DeviceArray<cudaReal> const & b,
545 const cudaComplex c, const int beginIdA,
546 const int beginIdB, const int n);
547
555inline void subVS(DeviceArray<cudaComplex>& a,
556 DeviceArray<cudaReal> const & b,
557 const cudaComplex c)
558{ subVS(a, b, c, 0, 0, a.capacity()); }
559
570void subVS(DeviceArray<cudaComplex>& a, DeviceArray<cudaComplex> const & b,
571 const cudaReal c, const int beginIdA,
572 const int beginIdB, const int n);
573
581inline void subVS(DeviceArray<cudaComplex>& a,
582 DeviceArray<cudaComplex> const & b, const cudaReal c)
583{ subVS(a, b, c, 0, 0, a.capacity()); }
584
585
586// Multiplication operations
587// ~~~~~~~~~~~~~~~~~~~~~~~~~
588
600void mulVV(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
601 DeviceArray<cudaReal> const & c, const int beginIdA,
602 const int beginIdB, const int beginIdC, const int n);
603
611inline void mulVV(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
612 DeviceArray<cudaReal> const & c)
613{ mulVV(a, b, c, 0, 0, 0, a.capacity()); }
614
626void mulVV(DeviceArray<cudaComplex>& a, DeviceArray<cudaComplex> const & b,
627 DeviceArray<cudaComplex> const & c, const int beginIdA,
628 const int beginIdB, const int beginIdC, const int n);
629
637inline void mulVV(DeviceArray<cudaComplex>& a,
638 DeviceArray<cudaComplex> const & b,
639 DeviceArray<cudaComplex> const & c)
640{ mulVV(a, b, c, 0, 0, 0, a.capacity()); }
641
653void mulVV(DeviceArray<cudaComplex>& a, DeviceArray<cudaReal> const & b,
654 DeviceArray<cudaComplex> const & c, const int beginIdA,
655 const int beginIdB, const int beginIdC, const int n);
656
664inline void mulVV(DeviceArray<cudaComplex>& a,
665 DeviceArray<cudaReal> const & b,
666 DeviceArray<cudaComplex> const & c)
667{ mulVV(a, b, c, 0, 0, 0, a.capacity()); }
668
680void mulVV(DeviceArray<cudaComplex>& a, DeviceArray<cudaComplex> const & b,
681 DeviceArray<cudaReal> const & c, const int beginIdA,
682 const int beginIdB, const int beginIdC, const int n);
683
691inline void mulVV(DeviceArray<cudaComplex>& a,
692 DeviceArray<cudaComplex> const & b,
693 DeviceArray<cudaReal> const & c)
694{ mulVV(a, b, c, 0, 0, 0, a.capacity()); }
695
706void mulVS(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
707 const cudaReal c, const int beginIdA,
708 const int beginIdB, const int n);
709
717inline void mulVS(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
718 const cudaReal c)
719{ mulVS(a, b, c, 0, 0, a.capacity()); }
720
731void mulVS(DeviceArray<cudaComplex>& a, DeviceArray<cudaComplex> const & b,
732 const cudaComplex c, const int beginIdA,
733 const int beginIdB, const int n);
734
742inline void mulVS(DeviceArray<cudaComplex>& a,
743 DeviceArray<cudaComplex> const & b, const cudaComplex c)
744{ mulVS(a, b, c, 0, 0, a.capacity()); }
745
756void mulVS(DeviceArray<cudaComplex>& a,
757 DeviceArray<cudaReal> const & b,
758 const cudaComplex c,
759 const int beginIdA, const int beginIdB, const int n);
760
768inline void mulVS(DeviceArray<cudaComplex>& a,
769 DeviceArray<cudaReal> const & b, const cudaComplex c)
770{ mulVS(a, b, c, 0, 0, a.capacity()); }
771
782void mulVS(DeviceArray<cudaComplex>& a,
783 DeviceArray<cudaComplex> const & b,
784 const cudaReal c,
785 const int beginIdA, const int beginIdB, const int n);
786
794inline void mulVS(DeviceArray<cudaComplex>& a,
795 DeviceArray<cudaComplex> const & b,
796 const cudaReal c)
797{ mulVS(a, b, c, 0, 0, a.capacity()); }
798
799
800// Division operations
801// ~~~~~~~~~~~~~~~~~~~
802
814void divVV(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
815 DeviceArray<cudaReal> const & c, const int beginIdA,
816 const int beginIdB, const int beginIdC, const int n);
817
825inline void divVV(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
826 DeviceArray<cudaReal> const & c)
827{ divVV(a, b, c, 0, 0, 0, a.capacity()); }
828
840void divVV(DeviceArray<cudaComplex>& a, DeviceArray<cudaComplex> const & b,
841 DeviceArray<cudaReal> const & c, const int beginIdA,
842 const int beginIdB, const int beginIdC, const int n);
843
851inline void divVV(DeviceArray<cudaComplex>& a,
852 DeviceArray<cudaComplex> const & b,
853 DeviceArray<cudaReal> const & c)
854{ divVV(a, b, c, 0, 0, 0, a.capacity()); }
855
866void divVS(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
867 const cudaReal c, const int beginIdA,
868 const int beginIdB, const int n);
869
877inline void divVS(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
878 const cudaReal c)
879{ divVS(a, b, c, 0, 0, a.capacity()); }
880
891void divVS(DeviceArray<cudaComplex>& a, DeviceArray<cudaComplex> const & b,
892 const cudaReal c, const int beginIdA,
893 const int beginIdB, const int n);
894
902inline void divVS(DeviceArray<cudaComplex>& a,
903 DeviceArray<cudaComplex> const & b, const cudaReal c)
904{ divVS(a, b, c, 0, 0, a.capacity()); }
905
916void divSV(DeviceArray<cudaReal>& a, const cudaReal b,
917 DeviceArray<cudaReal> const & c,
918 const int beginIdA, const int beginIdC, const int n);
919
927inline void divSV(DeviceArray<cudaReal>& a, const cudaReal b,
928 DeviceArray<cudaReal> const & c)
929{ divSV(a, b, c, 0, 0, a.capacity()); }
930
931// Exponentiation operations:
932// ~~~~~~~~~~~~~~~~~~~~~~
933
943void expV(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
944 const int beginIdA, const int beginIdB, const int n);
945
952inline void expV(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b)
953{ expV(a, b, 0, 0, a.capacity()); }
954
964void expV(DeviceArray<cudaComplex>& a, DeviceArray<cudaComplex> const & b,
965 const int beginIdA, const int beginIdB, const int n);
966
973inline void expV(DeviceArray<cudaComplex>& a,
974 DeviceArray<cudaComplex> const & b)
975{ expV(a, b, 0, 0, a.capacity()); }
976
977
978// Compound operations: addition
979// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
980
990void addEqV(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
991 const int beginIdA, const int beginIdB, const int n);
992
999inline void addEqV(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b)
1000{ addEqV(a, b, 0, 0, a.capacity()); }
1001
1011void addEqV(DeviceArray<cudaComplex>& a, DeviceArray<cudaComplex> const & b,
1012 const int beginIdA, const int beginIdB, const int n);
1013
1020inline void addEqV(DeviceArray<cudaComplex>& a,
1021 DeviceArray<cudaComplex> const & b)
1022{ addEqV(a, b, 0, 0, a.capacity()); }
1023
1033void addEqV(DeviceArray<cudaComplex>& a, DeviceArray<cudaReal> const & b,
1034 const int beginIdA, const int beginIdB, const int n);
1035
1042inline void addEqV(DeviceArray<cudaComplex>& a,
1043 DeviceArray<cudaReal> const & b)
1044{ addEqV(a, b, 0, 0, a.capacity()); }
1045
1054void addEqS(DeviceArray<cudaReal>& a, const cudaReal b,
1055 const int beginIdA, const int n);
1056
1063inline void addEqS(DeviceArray<cudaReal>& a, const cudaReal b)
1064{ addEqS(a, b, 0, a.capacity()); }
1065
1074void addEqS(DeviceArray<cudaComplex>& a, const cudaComplex b,
1075 const int beginIdA, const int n);
1076
1083inline void addEqS(DeviceArray<cudaComplex>& a, const cudaComplex b)
1084{ addEqS(a, b, 0, a.capacity()); }
1085
1094void addEqS(DeviceArray<cudaComplex>& a, const cudaReal b,
1095 const int beginIdA, const int n);
1096
1103inline void addEqS(DeviceArray<cudaComplex>& a, const cudaReal b)
1104{ addEqS(a, b, 0, a.capacity()); }
1105
1106
1107// Compound operations: subtraction
1108// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1109
1119void subEqV(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
1120 const int beginIdA, const int beginIdB, const int n);
1121
1128inline void subEqV(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b)
1129{ subEqV(a, b, 0, 0, a.capacity()); }
1130
1140void subEqV(DeviceArray<cudaComplex>& a, DeviceArray<cudaComplex> const & b,
1141 const int beginIdA, const int beginIdB, const int n);
1142
1149inline void subEqV(DeviceArray<cudaComplex>& a,
1150 DeviceArray<cudaComplex> const & b)
1151{ subEqV(a, b, 0, 0, a.capacity()); }
1152
1162void subEqV(DeviceArray<cudaComplex>& a, DeviceArray<cudaReal> const & b,
1163 const int beginIdA, const int beginIdB, const int n);
1164
1171inline void subEqV(DeviceArray<cudaComplex>& a,
1172 DeviceArray<cudaReal> const & b)
1173{ subEqV(a, b, 0, 0, a.capacity()); }
1174
1183void subEqS(DeviceArray<cudaReal>& a, const cudaReal b,
1184 const int beginIdA, const int n);
1185
1192inline void subEqS(DeviceArray<cudaReal>& a, const cudaReal b)
1193{ subEqS(a, b, 0, a.capacity()); }
1194
1203void subEqS(DeviceArray<cudaComplex>& a, const cudaComplex b,
1204 const int beginIdA, const int n);
1205
1212inline void subEqS(DeviceArray<cudaComplex>& a, const cudaComplex b)
1213{ subEqS(a, b, 0, a.capacity()); }
1214
1223void subEqS(DeviceArray<cudaComplex>& a, const cudaReal b,
1224 const int beginIdA, const int n);
1225
1232inline void subEqS(DeviceArray<cudaComplex>& a, const cudaReal b)
1233{ subEqS(a, b, 0, a.capacity()); }
1234
1235
1236// Compound operations: multiplication
1237// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1238
1248void mulEqV(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
1249 const int beginIdA, const int beginIdB, const int n);
1250
1257inline void mulEqV(DeviceArray<cudaReal>& a,
1258 DeviceArray<cudaReal> const & b)
1259{ mulEqV(a, b, 0, 0, a.capacity()); }
1260
1270void mulEqV(DeviceArray<cudaComplex>& a, DeviceArray<cudaComplex> const & b,
1271 const int beginIdA, const int beginIdB, const int n);
1272
1279inline void mulEqV(DeviceArray<cudaComplex>& a,
1280 DeviceArray<cudaComplex> const & b)
1281{ mulEqV(a, b, 0, 0, a.capacity()); }
1282
1292void mulEqV(DeviceArray<cudaComplex>& a, DeviceArray<cudaReal> const & b,
1293 const int beginIdA, const int beginIdB, const int n);
1294
1301inline void mulEqV(DeviceArray<cudaComplex>& a,
1302 DeviceArray<cudaReal> const & b)
1303{ mulEqV(a, b, 0, 0, a.capacity()); }
1304
1313void mulEqS(DeviceArray<cudaReal>& a, const cudaReal b,
1314 const int beginIdA, const int n);
1315
1322inline void mulEqS(DeviceArray<cudaReal>& a, const cudaReal b)
1323{ mulEqS(a, b, 0, a.capacity()); }
1324
1333void mulEqS(DeviceArray<cudaComplex>& a, const cudaComplex b,
1334 const int beginIdA, const int n);
1335
1342inline void mulEqS(DeviceArray<cudaComplex>& a, const cudaComplex b)
1343{ mulEqS(a, b, 0, a.capacity()); }
1344
1353void mulEqS(DeviceArray<cudaComplex>& a, const cudaReal b,
1354 const int beginIdA, const int n);
1355
1362inline void mulEqS(DeviceArray<cudaComplex>& a, const cudaReal b)
1363{ mulEqS(a, b, 0, a.capacity()); }
1364
1365
1366// Compound operations: division
1367// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1368
1378void divEqV(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b,
1379 const int beginIdA, const int beginIdB, const int n);
1380
1387inline void divEqV(DeviceArray<cudaReal>& a, DeviceArray<cudaReal> const & b)
1388{ divEqV(a, b, 0, 0, a.capacity()); }
1389
1399void divEqV(DeviceArray<cudaComplex>& a, DeviceArray<cudaReal> const & b,
1400 const int beginIdA, const int beginIdB, const int n);
1401
1408inline void divEqV(DeviceArray<cudaComplex>& a,
1409 DeviceArray<cudaReal> const & b)
1410{ divEqV(a, b, 0, 0, a.capacity()); }
1411
1420void divEqS(DeviceArray<cudaReal>& a, const cudaReal b,
1421 const int beginIdA, const int n);
1422
1429inline void divEqS(DeviceArray<cudaReal>& a, const cudaReal b)
1430{ divEqS(a, b, 0, a.capacity()); }
1431
1440void divEqS(DeviceArray<cudaComplex>& a, const cudaReal b,
1441 const int beginIdA, const int n);
1442
1449inline void divEqS(DeviceArray<cudaComplex>& a, const cudaReal b)
1450{ divEqS(a, b, 0, a.capacity()); }
1451
1453
1454} // namespace VecOp
1455} // namespace Cuda
1456} // namespace Prdc
1457} // namespace Pscf
1458
1459#include "VecOpMisc.h" // Ensure that if VecOp is included, so is VecOpMisc
1460
1461#endif
Pscf::DeviceArray
Dynamic array on the GPU device with aligned data.
Definition DeviceArray.h:43
Pscf::DeviceArray::capacity
int capacity() const
Return allocated capacity.
Definition DeviceArray.h:460
Pscf::Prdc::Cpu::VecOp::subVV
void subVV(Array< double > &a, Array< double > const &b, Array< double > const &c)
Vector subtraction, a[i] = b[i] - c[i].
Definition VecOp.cpp:81
Pscf::Prdc::Cpu::VecOp::divSV
void divSV(Array< double > &a, double b, Array< double > const &c)
Vector division, a[i] = b / c[i].
Definition VecOp.cpp:169
Pscf::Prdc::Cpu::VecOp::mulEqV
void mulEqV(Array< double > &a, Array< double > const &b)
Vector multiplication in-place, a[i] *= b[i].
Definition VecOp.cpp:254
Pscf::Prdc::Cpu::VecOp::addEqV
void addEqV(Array< double > &a, Array< double > const &b)
Vector addition in-place, a[i] += b[i].
Definition VecOp.cpp:199
Pscf::Prdc::Cpu::VecOp::eqV
void eqV(Array< double > &a, Array< double > const &b)
Vector assignment, a[i] = b[i].
Definition VecOp.cpp:23
Pscf::Prdc::Cpu::VecOp::mulVS
void mulVS(Array< double > &a, Array< double > const &b, double c)
Vector multiplication, a[i] = b[i] * c.
Definition VecOp.cpp:126
Pscf::Prdc::Cpu::VecOp::divEqS
void divEqS(Array< double > &a, double b)
Vector division in-place, a[i] /= b.
Definition VecOp.cpp:294
Pscf::Prdc::Cpu::VecOp::addEqS
void addEqS(Array< double > &a, double b)
Vector addition in-place, a[i] += b.
Definition VecOp.cpp:212
Pscf::Prdc::Cpu::VecOp::addVV
void addVV(Array< double > &a, Array< double > const &b, Array< double > const &c)
Vector addition, a[i] = b[i] + c[i].
Definition VecOp.cpp:50
Pscf::Prdc::Cpu::VecOp::subVS
void subVS(Array< double > &a, Array< double > const &b, double c)
Vector subtraction, a[i] = b[i] - c.
Definition VecOp.cpp:96
Pscf::Prdc::Cpu::VecOp::divEqV
void divEqV(Array< double > &a, Array< double > const &b)
Vector division in-place, a[i] /= b[i].
Definition VecOp.cpp:281
Pscf::Prdc::Cpu::VecOp::mulEqS
void mulEqS(Array< double > &a, double b)
Vector multiplication in-place, a[i] *= b.
Definition VecOp.cpp:267
Pscf::Prdc::Cpu::VecOp::divVS
void divVS(Array< double > &a, Array< double > const &b, double c)
Vector division, a[i] = b[i] / c.
Definition VecOp.cpp:156
Pscf::Prdc::Cpu::VecOp::divVV
void divVV(Array< double > &a, Array< double > const &b, Array< double > const &c)
Vector division, a[i] = b[i] / c[i].
Definition VecOp.cpp:141
Pscf::Prdc::Cpu::VecOp::eqS
void eqS(Array< double > &a, double b)
Vector assignment, a[i] = b.
Definition VecOp.cpp:36
Pscf::Prdc::Cpu::VecOp::addVS
void addVS(Array< double > &a, Array< double > const &b, double c)
Vector addition, a[i] = b[i] + c.
Definition VecOp.cpp:65
Pscf::Prdc::Cpu::VecOp::mulVV
void mulVV(Array< double > &a, Array< double > const &b, Array< double > const &c)
Vector multiplication, a[i] = b[i] * c[i].
Definition VecOp.cpp:111
Pscf::Prdc::Cpu::VecOp::subEqV
void subEqV(Array< double > &a, Array< double > const &b)
Vector subtraction in-place, a[i] -= b[i].
Definition VecOp.cpp:227
Pscf::Prdc::Cpu::VecOp::expV
void expV(Array< double > &a, Array< double > const &b)
Vector exponentiation, a[i] = exp(b[i]).
Definition VecOp.cpp:184
Pscf::Prdc::Cpu::VecOp::subEqS
void subEqS(Array< double > &a, double b)
Vector subtraction in-place, a[i] -= b.
Definition VecOp.cpp:240
Pscf::Prdc::Cuda::VecOp
Functions that perform element-wise vector operations on the GPU.
Definition VecOp.cu:16
Pscf::Prdc::Cuda
Fields, FFTs, and utilities for periodic boundary conditions (CUDA)
Definition CField.cu:12
Pscf::Prdc
Periodic fields and crystallography.
Definition CField.cpp:11
Pscf
PSCF package top-level namespace.
Definition param_domain.dox:1
Generated on for PSCF by doxygen 1.14.0