Loading...
Searching...
No Matches
Operators_array.tpp
Go to the documentation of this file.
1/*---------------------------------------------------------------------------*\
2 *
3 * bitpit
4 *
5 * Copyright (C) 2015-2021 OPTIMAD engineering Srl
6 *
7 * -------------------------------------------------------------------------
8 * License
9 * This file is part of bitpit.
10 *
11 * bitpit is free software: you can redistribute it and/or modify it
12 * under the terms of the GNU Lesser General Public License v3 (LGPL)
13 * as published by the Free Software Foundation.
14 *
15 * bitpit is distributed in the hope that it will be useful, but WITHOUT
16 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
18 * License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with bitpit. If not, see <http://www.gnu.org/licenses/>.
22 *
23\*---------------------------------------------------------------------------*/
24
25// ===================================================================================//
26// OPERATORS //
27// //
28// Operators for standard template library arrays. //
29// ================================================================================== //
30// INFO //
31// ================================================================================== //
37// Author : Alessandro Alaia //
38// Version : v3.0 //
39// //
40// All rights reserved. //
41// ================================================================================== //
42
43// ================================================================================== //
44// TEMPLATES IMPLEMENTATION //
45// ================================================================================== //
46
52// Operator "+" ===================================================================== //
53
54// ---------------------------------------------------------------------------------- //
73template <class T, size_t d>
74std::array<T, d> operator+ (
75 const std::array<T, d> &x,
76 const std::array<T, d> &y
77) {
78
79// ================================================================================== //
80// VARIABLES DECLARATION //
81// ================================================================================== //
82std::array<T, d> z;
83
84// ================================================================================== //
85// PERFORM SUM //
86// ================================================================================== //
87for (size_t i = 0; i < d; i++){
88 z[i] = x[i] + y[i];
89};
90
91return (z); };
92
93// ---------------------------------------------------------------------------------- //
112template <class T, size_t d>
113std::array<T, d> operator+ (
114 const std::array<T, d> &x,
115 const T &y
116) {
117
118// ================================================================================== //
119// VARIABLES DECLARATION //
120// ================================================================================== //
121std::array<T, d> z;
122
123// ================================================================================== //
124// PERFORM SUM //
125// ================================================================================== //
126for (size_t i = 0; i < d; i++){
127 z[i] = x[i] + y;
128};
129
130return (z); };
131
132// ---------------------------------------------------------------------------------- //
151template <class T, size_t d>
152std::array<T, d> operator+ (
153 const T &x,
154 const std::array<T, d> &y
155) {
156
157// ================================================================================== //
158// VARIABLES DECLARATION //
159// ================================================================================== //
160std::array<T, d> z;
161
162// ================================================================================== //
163// PERFORM SUM //
164// ================================================================================== //
165z = y + x;
166
167return (z); };
168
169// ---------------------------------------------------------------------------------- //
189template <class T, size_t d, size_t e>
190std::array<std::array<T, e>, d> operator+ (
191 const T &x,
192 const std::array<std::array<T, e>, d> &y
193) {
194
195// ================================================================================== //
196// VARIABLES DECLARATION //
197// ================================================================================== //
198std::array<std::array<T, e>, d> z;
199
200// ================================================================================== //
201// PERFORM SUM //
202// ================================================================================== //
203for (size_t i = 0; i < d; i++){
204 z[i] = x + y[i];
205};
206
207return (z); };
208
209// ---------------------------------------------------------------------------------- //
229template <class T, size_t d, size_t e>
230std::array<std::array<T, e>, d> operator+ (
231 const std::array<std::array<T, e>, d> &x,
232 const T &y
233) {
234
235// ================================================================================== //
236// VARIABLES DECLARATION //
237// ================================================================================== //
238std::array<std::array<T, e>, d> z;
239
240// ================================================================================== //
241// PERFORM SUM //
242// ================================================================================== //
243z = y + x;
244
245return (z); };
246
247// Operator "+=" ==================================================================== //
248
249// ---------------------------------------------------------------------------------- //
267template <class T, size_t d>
268std::array< T, d >& operator+= (
269 std::array< T, d > &x,
270 const std::array< T, d > &y
271) {
272
273// ================================================================================== //
274// VARIABLES DECLARATION //
275// ================================================================================== //
276// none
277
278// ================================================================================== //
279// PERFORM SUM //
280// ================================================================================== //
281for (size_t i = 0; i < d; i++){
282 x[i] += y[i];
283};
284
285return (x); };
286
287// ---------------------------------------------------------------------------------- //
305template <class T, size_t d>
306std::array< T, d >& operator+= (
307 std::array< T, d > &x,
308 const T &y
309) {
310
311// ================================================================================== //
312// VARIABLES DECLARATION //
313// ================================================================================== //
314// none
315
316// ================================================================================== //
317// PERFORM SUM //
318// ================================================================================== //
319for (size_t i = 0; i < d; i++){
320 x[i] += y;
321};
322
323return (x); };
324
325// ---------------------------------------------------------------------------------- //
343template <class T, size_t d, size_t e>
344std::array< std::array< T, e >, d >& operator+= (
345 std::array< std::array< T, e >, d > &x,
346 const T &y
347) {
348
349// ================================================================================== //
350// VARIABLES DECLARATION //
351// ================================================================================== //
352// none
353
354// ================================================================================== //
355// PERFORM SUM //
356// ================================================================================== //
357for (size_t i = 0; i < d; i++) {
358 x[i] += y;
359} //next i
360
361return (x); };
362
363// Operator "-" ===================================================================== //
364
365// ---------------------------------------------------------------------------------- //
384template <class T, size_t d>
385std::array<T, d> operator- (
386 const std::array<T, d> &x,
387 const std::array<T, d> &y
388) {
389
390// ================================================================================== //
391// VARIABLES DECLARATION //
392// ================================================================================== //
393std::array<T, d> z;
394
395// ================================================================================== //
396// PERFORM DIFFERENCE //
397// ================================================================================== //
398for (size_t i = 0; i < d; i++){
399 z[i] = x[i] - y[i];
400};
401
402return(z); };
403
404// ---------------------------------------------------------------------------------- //
423template <class T, size_t d>
424std::array<T, d> operator- (
425 const std::array<T, d> &x,
426 const T &y
427) {
428
429// ================================================================================== //
430// VARIABLES DECLARATION //
431// ================================================================================== //
432std::array<T, d> z;
433
434// ================================================================================== //
435// PERFORM DIFFERENCE //
436// ================================================================================== //
437for (size_t i = 0; i < d; i++){
438 z[i] = x[i] - y;
439};
440
441return(z); };
442
443// ---------------------------------------------------------------------------------- //
462template <class T, size_t d>
463std::array<T, d> operator- (
464 const T &x,
465 const std::array<T, d> &y
466) {
467
468// ================================================================================== //
469// VARIABLES DECLARATION //
470// ================================================================================== //
471std::array<T, d> z;
472
473// ================================================================================== //
474// PERFORM DIFFERENCE //
475// ================================================================================== //
476z = y - x;
477
478return(z); };
479
480// ---------------------------------------------------------------------------------- //
500template <class T, size_t d, size_t e>
501std::array<std::array<T, e>, d> operator- (
502 const T &x,
503 const std::array<std::array<T, e>, d> &y
504) {
505
506// ================================================================================== //
507// VARIABLES DECLARATION //
508// ================================================================================== //
509std::array<std::array<T, e>, d> z;
510
511// ================================================================================== //
512// PERFORM DIFFERENCE //
513// ================================================================================== //
514for (size_t i = 0; i < d; i++) {
515 z[i] = y[i] - x;
516} //next i
517
518return(z); };
519
520// ---------------------------------------------------------------------------------- //
540template <class T, size_t d, size_t e>
541std::array<std::array<T, e>, d> operator- (
542 const std::array<std::array<T, e>, d> &x,
543 const T &y
544) {
545
546// ================================================================================== //
547// VARIABLES DECLARATION //
548// ================================================================================== //
549std::array<std::array<T, e>, d> z;
550
551// ================================================================================== //
552// PERFORM DIFFERENCE //
553// ================================================================================== //
554z = y - x;
555
556return(z); };
557
558// Operator "-=" ==================================================================== //
559
560// ---------------------------------------------------------------------------------- //
578template <class T, size_t d>
579std::array< T, d >& operator-= (
580 std::array< T, d > &x,
581 const std::array< T, d > &y
582) {
583
584// ================================================================================== //
585// VARIABLES DECLARATION //
586// ================================================================================== //
587// none
588
589// ================================================================================== //
590// PERFORM SUM //
591// ================================================================================== //
592for (size_t i = 0; i < d; i++){
593 x[i] -= y[i];
594};
595
596return (x); };
597
598// ---------------------------------------------------------------------------------- //
616template <class T, size_t d>
617std::array< T, d >& operator-= (
618 std::array< T, d > &x,
619 const T &y
620) {
621
622// ================================================================================== //
623// template <class T, size_t d> //
624// array< T, d >& operator-= ( //
625// array< T, d > &x, //
626// const T &y) //
627// //
628// Element-wise decrement. Returns: //
629// x -= y, s.t x[i] -= y //
630// ================================================================================== //
631// INPUT //
632// ================================================================================== //
633// - x : array< T, d >, 1st argument of '-=' operator //
634// - y : T , 2nd argument of '-=' operator //
635// ================================================================================== //
636// OUTPUT //
637// ================================================================================== //
638// - x : array< T, d >&, reference to first argument //
639// ================================================================================== //
640
641// ================================================================================== //
642// VARIABLES DECLARATION //
643// ================================================================================== //
644// none
645
646// ================================================================================== //
647// PERFORM SUM //
648// ================================================================================== //
649for (size_t i = 0; i < d; i++){
650 x[i] -= y;
651};
652
653return (x); };
654
655// ---------------------------------------------------------------------------------- //
673template <class T, size_t d, size_t e>
674std::array< std::array< T, e >, d >& operator-= (
675 std::array< std::array< T, e >, d > &x,
676 const T &y
677) {
678
679// ================================================================================== //
680// VARIABLES DECLARATION //
681// ================================================================================== //
682// none
683
684// ================================================================================== //
685// PERFORM SUM //
686// ================================================================================== //
687for (size_t i = 0; i < d; i++) {
688 x[i] -= y;
689} //next i
690
691return (x); };
692
693// Operator "*" ===================================================================== //
694
695// ---------------------------------------------------------------------------------- //
714template <class T, size_t d>
715std::array<T, d> operator* (
716 const std::array<T, d> &x,
717 const std::array<T, d> &y
718) {
719
720// ================================================================================== //
721// VARIABLES DECLARATION //
722// ================================================================================== //
723std::array<T, d> z;
724
725// ================================================================================== //
726// PERFORM PRODUCT //
727// ================================================================================== //
728for (size_t i = 0; i < d; i++){
729 z[i] = x[i] * y[i];
730};
731
732return(z); };
733
734// ---------------------------------------------------------------------------------- //
753template <class T, size_t d>
754std::array<T, d> operator* (
755 const std::array<T, d> &x,
756 const T &y
757) {
758
759// ================================================================================== //
760// VARIABLES DECLARATION //
761// ================================================================================== //
762std::array<T, d> z;
763
764// ================================================================================== //
765// PERFORM PRODUCT //
766// ================================================================================== //
767for (size_t i = 0; i < d; i++){
768 z[i] = x[i] * y;
769};
770
771return(z); };
772
773// ---------------------------------------------------------------------------------- //
792template <class T, size_t d>
793std::array<T, d> operator* (
794 const T &x,
795 const std::array<T, d> &y
796) {
797
798// ================================================================================== //
799// VARIABLES DECLARATION //
800// ================================================================================== //
801std::array<T, d> z;
802
803// ================================================================================== //
804// PERFORM PRODUCT //
805// ================================================================================== //
806z = y * x;
807
808return(z); };
809
810// ---------------------------------------------------------------------------------- //
830template <class T, size_t d, size_t e>
831std::array<std::array<T, e>, d> operator* (
832 const T &x,
833 const std::array<std::array<T, e>, d> &y
834) {
835
836// ================================================================================== //
837// VARIABLES DECLARATION //
838// ================================================================================== //
839std::array<std::array<T, e>, d> z;
840
841// ================================================================================== //
842// PERFORM PRODUCT //
843// ================================================================================== //
844for (size_t i = 0; i < d; i++) {
845 z[i] = y[i] * x;
846} //next i
847
848return(z); };
849
850// ---------------------------------------------------------------------------------- //
870template <class T, size_t d, size_t e>
871std::array<std::array<T, e>, d> operator* (
872 const std::array<std::array<T, e>, d> &x,
873 const T &y
874) {
875
876// ================================================================================== //
877// VARIABLES DECLARATION //
878// ================================================================================== //
879std::array<std::array<T, e>, d> z;
880
881// ================================================================================== //
882// PERFORM PRODUCT //
883// ================================================================================== //
884for (size_t i = 0; i < d; i++) {
885 z[i] = x[i] * y;
886} //next i
887
888return(z); };
889
890// Operator "*=" ===================================================================== //
891
892// ---------------------------------------------------------------------------------- //
910template <class T, size_t d>
911std::array< T, d >& operator*= (
912 std::array< T, d > &x,
913 const std::array< T, d > &y
914) {
915
916// ================================================================================== //
917// VARIABLES DECLARATION //
918// ================================================================================== //
919// none
920
921// ================================================================================== //
922// PERFORM SUM //
923// ================================================================================== //
924for (size_t i = 0; i < d; i++){
925 x[i] *= y[i];
926};
927
928return (x); };
929
930// ---------------------------------------------------------------------------------- //
948template <class T, size_t d>
949std::array< T, d >& operator*= (
950 std::array< T, d > &x,
951 const T &y
952) {
953
954// ================================================================================== //
955// VARIABLES DECLARATION //
956// ================================================================================== //
957// none
958
959// ================================================================================== //
960// PERFORM SUM //
961// ================================================================================== //
962for (size_t i = 0; i < d; i++){
963 x[i] *= y;
964};
965
966return (x); };
967
968// ---------------------------------------------------------------------------------- //
986template <class T, size_t d, size_t e>
987std::array< std::array< T, e >, d >& operator*= (
988 std::array< std::array< T, e >, d > &x,
989 const T &y
990) {
991
992// ================================================================================== //
993// VARIABLES DECLARATION //
994// ================================================================================== //
995// none
996
997// ================================================================================== //
998// PERFORM SUM //
999// ================================================================================== //
1000for (size_t i = 0; i < d; i++) {
1001 x[i] *= y;
1002} //next i
1003
1004return (x); };
1005
1006// Operator "/" ===================================================================== //
1007
1008// ---------------------------------------------------------------------------------- //
1027template <class T, size_t d>
1028std::array<T, d> operator/ (
1029 const std::array<T, d> &x,
1030 const std::array<T, d> &y
1031) {
1032
1033// ================================================================================== //
1034// VARIABLES DECLARATION //
1035// ================================================================================== //
1036std::array<T, d> z;
1037
1038// ================================================================================== //
1039// PERFORM DIVISION //
1040// ================================================================================== //
1041for (size_t i = 0; i < d; i++){
1042 z[i] = x[i] / y[i];
1043};
1044
1045return(z); };
1046
1047// ---------------------------------------------------------------------------------- //
1066template <class T, size_t d>
1067std::array<T, d> operator/ (
1068 const std::array<T, d> &x,
1069 const T &y
1070) {
1071
1072// ================================================================================== //
1073// VARIABLES DECLARATION //
1074// ================================================================================== //
1075
1076// Local variables
1077std::array<T, d> z;
1078
1079// Counters
1080size_t i;
1081
1082// ================================================================================== //
1083// DIVIDE X BY Y //
1084// ================================================================================== //
1085for (i = 0; i < d; i++) {
1086 z[i] = x[i]/y;
1087}
1088
1089return(z); };
1090
1091// ---------------------------------------------------------------------------------- //
1110template <class T, size_t d>
1111std::array<T, d> operator/ (
1112 const T &x,
1113 const std::array<T, d> &y
1114) {
1115
1116// ================================================================================== //
1117// VARIABLES DECLARATION //
1118// ================================================================================== //
1119std::array<T, d> z;
1120
1121// ================================================================================== //
1122// DIVIDE X BY Y //
1123// ================================================================================== //
1124for (size_t i = 0; i < d; i++) {
1125 z[i] = x/y[i];
1126}
1127
1128return(z); };
1129
1130// ---------------------------------------------------------------------------------- //
1150template <class T, size_t d, size_t e>
1151std::array<std::array<T, e>, d> operator/ (
1152 const T &x,
1153 const std::array<std::array<T, e>, d> &y
1154) {
1155
1156// ================================================================================== //
1157// VARIABLES DECLARATION //
1158// ================================================================================== //
1159std::array<std::array<T, e>, d> z;
1160
1161// ================================================================================== //
1162// DIVIDE X BY Y //
1163// ================================================================================== //
1164for (size_t i = 0; i < d; i++) {
1165 z[i] = x/y[i];
1166}
1167
1168return(z); };
1169
1170// ---------------------------------------------------------------------------------- //
1190template <class T, size_t d, size_t e>
1191std::array<std::array<T, e>, d> operator/ (
1192 const std::array<std::array<T, e>, d> &x,
1193 const T &y
1194) {
1195
1196// ================================================================================== //
1197// VARIABLES DECLARATION //
1198// ================================================================================== //
1199std::array<std::array<T, e>, d> z;
1200
1201// ================================================================================== //
1202// DIVIDE X BY Y //
1203// ================================================================================== //
1204for (size_t i = 0; i < d; i++) {
1205 z[i] = x[i]/y;
1206}
1207
1208return(z); };
1209
1210// Operator "/=" ===================================================================== //
1211
1212// ---------------------------------------------------------------------------------- //
1230template <class T, size_t d>
1231std::array< T, d >& operator/= (
1232 std::array< T, d > &x,
1233 const std::array< T, d > &y
1234) {
1235
1236for (size_t i = 0; i < d; i++){
1237 x[i] /= y[i];
1238};
1239
1240return (x); };
1241
1242// ---------------------------------------------------------------------------------- //
1260template <class T, size_t d>
1261std::array< T, d >& operator/= (
1262 std::array< T, d > &x,
1263 const T &y
1264) {
1265
1266for (size_t i = 0; i < d; i++){
1267 x[i] /= y;
1268};
1269
1270return (x); };
1271
1272// ---------------------------------------------------------------------------------- //
1290template <class T, size_t d, size_t e>
1291std::array< std::array< T, e >, d >& operator/= (
1292 std::array< std::array< T, e >, d > &x,
1293 const T &y
1294) {
1295
1296for (size_t i = 0; i < d; i++) {
1297 x[i] /= y;
1298} //next i
1299
1300return (x); };
1301
1310// Output operator ================================================================== //
1311
1312// ---------------------------------------------------------------------------------- //
1327template <class T, size_t d>
1328std::ostream& operator<< (
1329 std::ostream &out,
1330 const std::array<T, d> &x
1331) {
1332
1333// ================================================================================== //
1334// VARIABLES DECLARATION //
1335// ================================================================================== //
1336// none
1337
1338// ================================================================================== //
1339// OUTPUT ARRAY CONTENT //
1340// ================================================================================== //
1341if (d == 0) {
1342 return(out);
1343}
1344for (size_t i = 0; i < d-1; i++) {
1345 out << x[i] << " ";
1346} //next i
1347out << x[d-1] ;
1348
1349return(out); };
1350
1351// ---------------------------------------------------------------------------------- //
1366template <class T, size_t d>
1367std::ofstream& operator<< (
1368 std::ofstream &out,
1369 const std::array<T, d> &x
1370) {
1371
1372// ================================================================================== //
1373// VARIABLES DECLARATION //
1374// ================================================================================== //
1375// none
1376
1377// ================================================================================== //
1378// OUTPUT ARRAY CONTENT //
1379// ================================================================================== //
1380if (d == 0) {
1381 return(out);
1382}
1383for (size_t i = 0; i < d-1; i++) {
1384 out << x[i] << " ";
1385} //next i
1386out << x[d-1];
1387
1388return(out); };
1389
1390namespace bitpit {
1391
1392// ---------------------------------------------------------------------------------- //
1407template <class T, size_t d>
1408Logger& operator<< (
1409 Logger &out,
1410 const std::array<T, d> &x
1411) {
1412
1413// ================================================================================== //
1414// VARIABLES DECLARATION //
1415// ================================================================================== //
1416// none
1417
1418// ================================================================================== //
1419// OUTPUT ARRAY CONTENT //
1420// ================================================================================== //
1421if (d == 0) {
1422 return(out);
1423}
1424for (size_t i = 0; i < d-1; i++) {
1425 out << x[i] << " ";
1426} //next i
1427out << x[d-1];
1428
1429return(out); };
1430
1431}
1432
1433// Input operator =================================================================== //
1434
1435// ---------------------------------------------------------------------------------- //
1448template <class T, size_t d>
1449std::istream& operator>> (
1450 std::istream &in,
1451 std::array<T, d> &x
1452) {
1453
1454// ================================================================================== //
1455// VARIABLES DECLARATION //
1456// ================================================================================== //
1457
1458// Local variables
1459T dummy;
1460
1461// Counters
1462size_t i;
1463
1464// ================================================================================== //
1465// EXTRACT STREAM CONTENT INTO ARRAY //
1466// ================================================================================== //
1467i = 0;
1468while ((in.good()) && (i < d)) {
1469 if (in >> dummy) { x[i] = dummy; }
1470 i++;
1471} //next i
1472
1473return(in); };
1474
1475// ---------------------------------------------------------------------------------- //
1488template <class T, size_t d>
1489std::ifstream& operator>> (
1490 std::ifstream &in,
1491 std::array<T, d> &x
1492) {
1493
1494// ================================================================================== //
1495// VARIABLES DECLARATION //
1496// ================================================================================== //
1497
1498// Local variables
1499T dummy;
1500
1501// Counters
1502int i;
1503
1504// ================================================================================== //
1505// EXTRACT FILE CONTENT INTO ARRAY //
1506// ================================================================================== //
1507i = 0;
1508while ((in.good()) && (i < d)) {
1509 if (in >> dummy) { x[i] = dummy; }
1510 i++;
1511} //next i
1512
1513return(in); };
1514
1515// Miscellanea ====================================================================== //
1516
1517// ---------------------------------------------------------------------------------- //
1527template<class T, size_t d>
1528std::ostream& display(
1529 std::ostream &out,
1530 const std::array<T, d> &x,
1531 unsigned int padding
1532) {
1533
1534// ================================================================================== //
1535// VARIABLES DECLARATION //
1536// ================================================================================== //
1537
1538// Counters
1539typename std::array<T, d>::const_iterator i, e = x.cend();
1540
1541// ================================================================================== //
1542// DISPLAY VECTOR //
1543// ================================================================================== //
1544if (x.size() == 0) {
1545 out << "[ ]";
1546 return(out);
1547}
1548out << std::string(padding, ' ') << "[ ";
1549--e;
1550for (i = x.begin(); i != e; ++i) {
1551 display(out, *i) << ", ";
1552} //next i
1553display(out, *e) << " ]";
1554
1555return(out); }
1556
1557// ---------------------------------------------------------------------------------- //
1567template<class T, size_t d>
1568std::ofstream& display(
1569 std::ofstream &out,
1570 const std::array<T, d> &x,
1571 unsigned int padding
1572) {
1573
1574// ================================================================================== //
1575// VARIABLES DECLARATION //
1576// ================================================================================== //
1577
1578// Counters
1579typename std::array<T, d>::const_iterator i, e = x.cend();
1580
1581// ================================================================================== //
1582// DISPLAY VECTOR //
1583// ================================================================================== //
1584if (x.size() == 0) {
1585 out << "[ ]";
1586 return(out);
1587}
1588out << std::string(padding, ' ') << "[ ";
1589--e;
1590for (i = x.begin(); i != e; ++i) {
1591 display(out, *i) << ", ";
1592} //next i
1593display(out, *e) << " ]";
1594
1595return(out); }
1596
operator*=
std::array< T, d > & operator*=(std::array< T, d > &x, const std::array< T, d > &y)
Definition Operators_array.tpp:911
operator-=
std::array< T, d > & operator-=(std::array< T, d > &x, const std::array< T, d > &y)
Definition Operators_array.tpp:579
operator/
std::array< T, d > operator/(const std::array< T, d > &x, const std::array< T, d > &y)
Definition Operators_array.tpp:1028
operator+=
std::array< T, d > & operator+=(std::array< T, d > &x, const std::array< T, d > &y)
Definition Operators_array.tpp:268
operator/=
std::array< T, d > & operator/=(std::array< T, d > &x, const std::array< T, d > &y)
Definition Operators_array.tpp:1231
operator*
std::array< T, d > operator*(const std::array< T, d > &x, const std::array< T, d > &y)
Definition Operators_array.tpp:715
operator-
std::array< T, d > operator-(const std::array< T, d > &x, const std::array< T, d > &y)
Definition Operators_array.tpp:385
operator+
std::array< T, d > operator+(const std::array< T, d > &x, const std::array< T, d > &y)
Definition Operators_array.tpp:74
operator>>
std::istream & operator>>(std::istream &in, std::array< T, d > &x)
Definition Operators_array.tpp:1449
display
std::ostream & display(std::ostream &out, const std::array< T, d > &x, unsigned int padding)
Definition Operators_array.tpp:1528
operator<<
std::ostream & operator<<(std::ostream &out, const std::array< T, d > &x)
Definition Operators_array.tpp:1328
--- layout: doxygen_footer ---
Generated on Wed Jun 19 2024 10:21:05 for bitpit by   doxygen 1.10.0