17 #ifndef __ESCRIPT_DATAMATHS_H__ 18 #define __ESCRIPT_DATAMATHS_H__ 99 template<
typename VEC>
104 typename VEC::size_type inOffset,
107 typename VEC::size_type evOffset)
113 for (i0=0; i0<s0; i0++) {
114 for (i1=0; i1<s1; i1++) {
125 for (i0=0; i0<s0; i0++) {
126 for (i1=0; i1<s1; i1++) {
127 for (i2=0; i2<s2; i2++) {
128 for (i3=0; i3<s3; i3++) {
129 ev[evOffset+
DataTypes::getRelIndex(evShape,i0,i1,i2,i3)] = (in[inOffset+
DataTypes::getRelIndex(inShape,i0,i1,i2,i3)] + in[inOffset+
DataTypes::getRelIndex(inShape,i2,i3,i0,i1)]) / 2.0;
148 template<
typename VEC>
153 typename VEC::size_type inOffset,
156 typename VEC::size_type evOffset)
162 for (i0=0; i0<s0; i0++) {
163 for (i1=0; i1<s1; i1++) {
174 for (i0=0; i0<s0; i0++) {
175 for (i1=0; i1<s1; i1++) {
176 for (i2=0; i2<s2; i2++) {
177 for (i3=0; i3<s3; i3++) {
178 ev[evOffset+
DataTypes::getRelIndex(evShape,i0,i1,i2,i3)] = (in[inOffset+
DataTypes::getRelIndex(inShape,i0,i1,i2,i3)] - in[inOffset+
DataTypes::getRelIndex(inShape,i2,i3,i0,i1)]) / 2.0;
243 typename VEC::size_type inOffset,
246 typename VEC::size_type evOffset,
256 for (i=0; i<s0; i++) {
261 if (axis_offset==0) {
265 for (i0=0; i0<s0; i0++) {
266 for (i2=0; i2<s2; i2++) {
271 else if (axis_offset==1) {
275 for (i0=0; i0<s0; i0++) {
276 for (i1=0; i1<s1; i1++) {
283 if (axis_offset==0) {
288 for (i0=0; i0<s0; i0++) {
289 for (i2=0; i2<s2; i2++) {
290 for (i3=0; i3<s3; i3++) {
296 else if (axis_offset==1) {
301 for (i0=0; i0<s0; i0++) {
302 for (i1=0; i1<s1; i1++) {
303 for (i3=0; i3<s3; i3++) {
309 else if (axis_offset==2) {
314 for (i0=0; i0<s0; i0++) {
315 for (i1=0; i1<s1; i1++) {
316 for (i2=0; i2<s2; i2++) {
344 typename VEC::size_type inOffset,
347 typename VEC::size_type evOffset,
357 if (axis_offset==1) {
358 for (i0=0; i0<s0; i0++) {
359 for (i1=0; i1<s1; i1++) {
360 for (i2=0; i2<s2; i2++) {
361 for (i3=0; i3<s3; i3++) {
368 else if (axis_offset==2) {
369 for (i0=0; i0<s0; i0++) {
370 for (i1=0; i1<s1; i1++) {
371 for (i2=0; i2<s2; i2++) {
372 for (i3=0; i3<s3; i3++) {
379 else if (axis_offset==3) {
380 for (i0=0; i0<s0; i0++) {
381 for (i1=0; i1<s1; i1++) {
382 for (i2=0; i2<s2; i2++) {
383 for (i3=0; i3<s3; i3++) {
391 for (i0=0; i0<s0; i0++) {
392 for (i1=0; i1<s1; i1++) {
393 for (i2=0; i2<s2; i2++) {
394 for (i3=0; i3<s3; i3++) {
402 else if (inRank == 3) {
407 if (axis_offset==1) {
408 for (i0=0; i0<s0; i0++) {
409 for (i1=0; i1<s1; i1++) {
410 for (i2=0; i2<s2; i2++) {
416 else if (axis_offset==2) {
417 for (i0=0; i0<s0; i0++) {
418 for (i1=0; i1<s1; i1++) {
419 for (i2=0; i2<s2; i2++) {
427 for (i0=0; i0<s0; i0++) {
428 for (i1=0; i1<s1; i1++) {
429 for (i2=0; i2<s2; i2++) {
436 else if (inRank == 2) {
440 if (axis_offset==1) {
441 for (i0=0; i0<s0; i0++) {
442 for (i1=0; i1<s1; i1++) {
448 for (i0=0; i0<s0; i0++) {
449 for (i1=0; i1<s1; i1++) {
455 else if (inRank == 1) {
458 for (i0=0; i0<s0; i0++) {
462 else if (inRank == 0) {
463 ev[evOffset] = in[inOffset];
466 throw DataException(
"Error - DataArrayView::transpose can only be calculated for rank 0, 1, 2, 3 or 4 objects.");
489 typename VEC::size_type inOffset,
492 typename VEC::size_type evOffset,
505 for (i0=0; i0<s0; i0++) {
506 for (i1=0; i1<s1; i1++) {
507 for (i2=0; i2<s2; i2++) {
508 for (i3=0; i3<s3; i3++) {
514 }
else if (axis1==2) {
515 for (i0=0; i0<s0; i0++) {
516 for (i1=0; i1<s1; i1++) {
517 for (i2=0; i2<s2; i2++) {
518 for (i3=0; i3<s3; i3++) {
525 }
else if (axis1==3) {
526 for (i0=0; i0<s0; i0++) {
527 for (i1=0; i1<s1; i1++) {
528 for (i2=0; i2<s2; i2++) {
529 for (i3=0; i3<s3; i3++) {
536 }
else if (axis0==1) {
538 for (i0=0; i0<s0; i0++) {
539 for (i1=0; i1<s1; i1++) {
540 for (i2=0; i2<s2; i2++) {
541 for (i3=0; i3<s3; i3++) {
547 }
else if (axis1==3) {
548 for (i0=0; i0<s0; i0++) {
549 for (i1=0; i1<s1; i1++) {
550 for (i2=0; i2<s2; i2++) {
551 for (i3=0; i3<s3; i3++) {
558 }
else if (axis0==2) {
560 for (i0=0; i0<s0; i0++) {
561 for (i1=0; i1<s1; i1++) {
562 for (i2=0; i2<s2; i2++) {
563 for (i3=0; i3<s3; i3++) {
572 }
else if ( inRank == 3) {
579 for (i0=0; i0<s0; i0++) {
580 for (i1=0; i1<s1; i1++) {
581 for (i2=0; i2<s2; i2++) {
586 }
else if (axis1==2) {
587 for (i0=0; i0<s0; i0++) {
588 for (i1=0; i1<s1; i1++) {
589 for (i2=0; i2<s2; i2++) {
595 }
else if (axis0==1) {
597 for (i0=0; i0<s0; i0++) {
598 for (i1=0; i1<s1; i1++) {
599 for (i2=0; i2<s2; i2++) {
606 }
else if ( inRank == 2) {
612 for (i0=0; i0<s0; i0++) {
613 for (i1=0; i1<s1; i1++) {
620 throw DataException(
"Error - DataArrayView::swapaxes can only be calculated for rank 2, 3 or 4 objects.");
672 eigenvalues3(in00,(in01+in10)/2.,(in02+in20)/2.,in11,(in21+in12)/2.,in22,
690 #pragma clang diagnostic push 691 #pragma clang diagnostic ignored "-Wunused-variable" 694 #pragma clang diagnostic pop 755 const double tol=1.e-13)
757 double in00,in10,in20,in01,in11,in21,in02,in12,in22;
758 double V00,V10,V20,V01,V11,V21,V02,V12,V22;
772 &ev0,&ev1,&V00,&V10,&V01,&V11,tol);
791 &V00,&V10,&V20,&V01,&V11,&V21,&V02,&V12,&V22,tol);
818 typename VEC::size_type offset)
826 template <
class ResVEC,
class LVEC,
class RSCALAR>
829 typename ResVEC::size_type resOffset,
830 const typename ResVEC::size_type samplesToProcess,
831 const typename ResVEC::size_type sampleSize,
833 typename LVEC::size_type leftOffset,
834 const RSCALAR* right,
835 const bool rightreset,
837 bool singleleftsample)
839 size_t substep=(rightreset?0:1);
844 #pragma omp parallel for 845 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
847 typename LVEC::size_type leftbase=leftOffset+(singleleftsample?0:i*sampleSize);
848 const RSCALAR* rpos=right+(rightreset?0:i*substep);
850 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
852 res[i*sampleSize+resOffset+j]=left[leftbase+j]+*rpos;
859 #pragma omp parallel for 860 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
862 typename LVEC::size_type leftbase=leftOffset+(singleleftsample?0:i*sampleSize);
863 const RSCALAR* rpos=right+(rightreset?0:i*substep);
865 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
867 res[i*sampleSize+resOffset+j]=pow(left[leftbase+j],*rpos);
874 #pragma omp parallel for 875 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
877 typename LVEC::size_type leftbase=leftOffset+(singleleftsample?0:i*sampleSize);
878 const RSCALAR* rpos=right+(rightreset?0:i*substep);
880 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
882 res[i*sampleSize+resOffset+j]=left[leftbase+j]-*rpos;
889 #pragma omp parallel for 890 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
892 typename LVEC::size_type leftbase=leftOffset+(singleleftsample?0:i*sampleSize);
893 const RSCALAR* rpos=right+(rightreset?0:i*substep);
895 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
897 res[i*sampleSize+resOffset+j]=left[leftbase+j] * *rpos;
904 #pragma omp parallel for 905 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
907 typename LVEC::size_type leftbase=leftOffset+(singleleftsample?0:i*sampleSize);
908 const RSCALAR* rpos=right+(rightreset?0:i*substep);
910 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
912 res[i*sampleSize+resOffset+j]=left[leftbase+j]/ *rpos;
931 const bool rightreset,
933 bool singleleftsample);
938 template <
class ResVEC,
class LSCALAR,
class RVEC>
941 typename ResVEC::size_type resOffset,
942 const typename ResVEC::size_type samplesToProcess,
943 const typename ResVEC::size_type sampleSize,
945 const bool leftreset,
947 typename RVEC::size_type rightOffset,
949 bool singlerightsample)
951 size_t substep=(leftreset?0:1);
956 #pragma omp parallel for 957 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
959 typename RVEC::size_type rightbase=rightOffset+(singlerightsample?0:i*sampleSize);
960 const LSCALAR* lpos=left+(leftreset?0:i*substep);
961 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
963 res[i*sampleSize+resOffset+j]=*lpos+right[rightbase+j];
970 #pragma omp parallel for 971 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
973 typename RVEC::size_type rightbase=rightOffset+(singlerightsample?0:i*sampleSize);
974 const LSCALAR* lpos=left+(leftreset?0:i*substep);
975 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
977 res[i*sampleSize+resOffset+j]=pow(*lpos,right[rightbase+j]);
984 #pragma omp parallel for 985 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
987 typename RVEC::size_type rightbase=rightOffset+(singlerightsample?0:i*sampleSize);
988 const LSCALAR* lpos=left+(leftreset?0:i*substep);
989 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
991 res[i*sampleSize+resOffset+j]=*lpos-right[rightbase+j];
998 #pragma omp parallel for 999 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
1001 typename RVEC::size_type rightbase=rightOffset+(singlerightsample?0:i*sampleSize);
1002 const LSCALAR* lpos=left+(leftreset?0:i*substep);
1003 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
1005 res[i*sampleSize+resOffset+j]=*lpos*right[rightbase+j];
1012 #pragma omp parallel for 1013 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
1015 typename RVEC::size_type rightbase=rightOffset+(singlerightsample?0:i*sampleSize);
1016 const LSCALAR* lpos=left+(leftreset?0:i*substep);
1017 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
1019 res[i*sampleSize+resOffset+j]=*lpos/right[rightbase+j];
1036 const bool leftreset,
1040 bool singlerightsample);
1045 template <
class ResVEC,
class LVEC,
class RVEC>
1048 typename ResVEC::size_type resOffset,
1049 const typename ResVEC::size_type samplesToProcess,
1050 const typename ResVEC::size_type sampleSize,
1052 typename LVEC::size_type leftOffset,
1053 const bool leftreset,
1055 typename RVEC::size_type rightOffset,
1056 const bool rightreset,
1063 #pragma omp parallel for 1064 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
1066 typename LVEC::size_type leftbase=leftOffset+(leftreset?0:i*sampleSize);
1067 typename RVEC::size_type rightbase=rightOffset+(rightreset?0:i*sampleSize);
1068 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
1070 res[i*sampleSize+resOffset+j]=left[leftbase+j]+right[rightbase+j];
1077 #pragma omp parallel for 1078 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
1080 typename LVEC::size_type leftbase=leftOffset+(leftreset?0:i*sampleSize);
1081 typename RVEC::size_type rightbase=rightOffset+(rightreset?0:i*sampleSize);
1082 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
1084 res[i*sampleSize+resOffset+j]=pow(left[leftbase+j],right[rightbase+j]);
1091 #pragma omp parallel for 1092 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
1094 typename LVEC::size_type leftbase=leftOffset+(leftreset?0:i*sampleSize);
1095 typename RVEC::size_type rightbase=rightOffset+(rightreset?0:i*sampleSize);
1096 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
1098 res[i*sampleSize+resOffset+j]=left[leftbase+j]-right[rightbase+j];
1105 #pragma omp parallel for 1106 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
1108 typename LVEC::size_type leftbase=leftOffset+(leftreset?0:i*sampleSize);
1109 typename RVEC::size_type rightbase=rightOffset+(rightreset?0:i*sampleSize);
1110 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
1112 res[i*sampleSize+resOffset+j]=left[leftbase+j]*right[rightbase+j];
1119 #pragma omp parallel for 1120 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
1122 typename LVEC::size_type leftbase=leftOffset+(leftreset?0:i*sampleSize);
1123 typename RVEC::size_type rightbase=rightOffset+(rightreset?0:i*sampleSize);
1124 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
1126 res[i*sampleSize+resOffset+j]=left[leftbase+j]/right[rightbase+j];
1144 const bool leftreset,
1147 const bool rightreset,
1150 #define OPVECLAZYBODY(X) \ 1151 for (size_t j=0;j<onumsteps;++j)\ 1153 for (size_t i=0;i<numsteps;++i,res+=resultStep) \ 1155 for (size_t s=0; s<chunksize; ++s)\ 1160 lroffset+=leftstep; \ 1161 rroffset+=rightstep; \ 1163 lroffset+=oleftstep;\ 1164 rroffset+=orightstep;\ 1173 template <
class ResELT,
class LELT,
class RELT>
1178 const size_t chunksize,
1179 const size_t onumsteps,
1180 const size_t numsteps,
1181 const size_t resultStep,
1182 const size_t leftstep,
1183 const size_t rightstep,
1184 const size_t oleftstep,
1185 const size_t orightstep,
1208 ESYS_ASSERT(
false,
"Invalid operation. This should never happen!");
1220 template <
class ResELT,
class LELT,
class RELT>
1225 const size_t chunksize,
1226 const size_t onumsteps,
1227 const size_t numsteps,
1228 const size_t resultStep,
1229 const size_t leftstep,
1230 const size_t rightstep,
1231 const size_t oleftstep,
1232 const size_t orightstep,
1252 ESYS_ASSERT(
false,
"Invalid operation. This should never happen!");
1261 template <
class ResVEC,
class LVEC,
class RVEC>
1264 const typename ResVEC::size_type samplesToProcess,
1265 const typename ResVEC::size_type DPPSample,
1266 const typename ResVEC::size_type DPSize,
1275 typename ResVEC::size_type lstep=leftscalar?1:DPSize;
1276 typename ResVEC::size_type rstep=rightscalar?1:DPSize;
1277 typename ResVEC::size_type limit=samplesToProcess*DPPSample;
1282 #pragma omp parallel for 1283 for (
typename ResVEC::size_type i=0;i<limit;++i)
1285 typename LVEC::size_type leftbase=(lefttagged?tagsource.
getPointOffset(i/DPPSample,0):i*lstep);
1286 typename RVEC::size_type rightbase=(lefttagged?i*rstep:tagsource.
getPointOffset(i/DPPSample,0));
1288 for (
typename ResVEC::size_type j=0;j<DPSize;++j)
1290 res[i*DPSize+j]=left[leftbase+j*(!leftscalar)]+right[rightbase+j*(!rightscalar)];
1297 #pragma omp parallel for 1298 for (
typename ResVEC::size_type i=0;i<limit;++i)
1300 typename LVEC::size_type leftbase=(lefttagged?tagsource.
getPointOffset(i/DPPSample,0):i*lstep);
1301 typename RVEC::size_type rightbase=(lefttagged?i*rstep:tagsource.
getPointOffset(i/DPPSample,0));
1303 for (
typename ResVEC::size_type j=0;j<DPSize;++j)
1305 res[i*DPSize+j]=pow(left[leftbase+j*(!leftscalar)],right[rightbase+j*(!rightscalar)]);
1312 #pragma omp parallel for 1313 for (
typename ResVEC::size_type i=0;i<limit;++i)
1315 typename LVEC::size_type leftbase=(lefttagged?tagsource.
getPointOffset(i/DPPSample,0):i*lstep);
1316 typename RVEC::size_type rightbase=(lefttagged?i*rstep:tagsource.
getPointOffset(i/DPPSample,0));
1318 for (
typename ResVEC::size_type j=0;j<DPSize;++j)
1320 res[i*DPSize+j]=left[leftbase+j*(!leftscalar)]-right[rightbase+j*(!rightscalar)];
1327 #pragma omp parallel for 1328 for (
typename ResVEC::size_type i=0;i<limit;++i)
1330 typename LVEC::size_type leftbase=(lefttagged?tagsource.
getPointOffset(i/DPPSample,0):i*lstep);
1331 typename RVEC::size_type rightbase=(lefttagged?i*rstep:tagsource.
getPointOffset(i/DPPSample,0));
1333 for (
typename ResVEC::size_type j=0;j<DPSize;++j)
1335 res[i*DPSize+j]=left[leftbase+j*(!leftscalar)]*right[rightbase+j*(!rightscalar)];
1342 #pragma omp parallel for 1343 for (
typename ResVEC::size_type i=0;i<limit;++i)
1345 typename LVEC::size_type leftbase=(lefttagged?tagsource.
getPointOffset(i/DPPSample,0):i*lstep);
1346 typename RVEC::size_type rightbase=(lefttagged?i*rstep:tagsource.
getPointOffset(i/DPPSample,0));
1348 for (
typename ResVEC::size_type j=0;j<DPSize;++j)
1350 res[i*DPSize+j]=left[leftbase+j*(!leftscalar)]/right[rightbase+j*(!rightscalar)];
1367 const bool leftscalar,
1369 const bool rightscalar,
1370 const bool lefttagged,
1393 template <
class BinaryFunction>
1399 BinaryFunction operation,
1403 "Couldn't perform reductionOp due to insufficient storage.");
1406 current_value=operation(current_value,left[offset+i]);
1408 return current_value;
1411 template <
class BinaryFunction>
1417 BinaryFunction operation,
1421 "Couldn't perform reductionOp due to insufficient storage.");
1424 current_value=operation(current_value,left[offset+i]);
1426 return current_value;
1474 for (
size_t z=inOffset;z<inOffset+count;++z)
1488 for (
size_t z=inOffset;z<inOffset+count;++z)
1501 #endif // __ESCRIPT_DATAMATHS_H__ void binaryOpVector(DataTypes::RealVectorType &res, typename DataTypes::RealVectorType::size_type resOffset, const typename DataTypes::RealVectorType::size_type samplesToProcess, const typename DataTypes::RealVectorType::size_type sampleSize, const DataTypes::RealVectorType &left, typename DataTypes::RealVectorType::size_type leftOffset, const bool leftreset, const DataTypes::RealVectorType &right, typename DataTypes::RealVectorType::size_type rightOffset, const bool rightreset, escript::ES_optype operation)
Definition: DataVectorOps.cpp:767
DataTypes::ShapeType determineResultShape(const DataTypes::ShapeType &left, const DataTypes::ShapeType &right)
Determine the shape of the result array for a matrix multiplication of the given views.
Definition: DataVectorOps.cpp:169
void eigenvalues(const DataTypes::RealVectorType &in, const DataTypes::ShapeType &inShape, typename DataTypes::RealVectorType::size_type inOffset, DataTypes::RealVectorType &ev, const DataTypes::ShapeType &evShape, typename DataTypes::RealVectorType::size_type evOffset)
solves a local eigenvalue problem
Definition: DataVectorOps.h:638
void binaryOpVectorLazyRelationalHelper(ResELT *res, const LELT *left, const RELT *right, const size_t chunksize, const size_t onumsteps, const size_t numsteps, const size_t resultStep, const size_t leftstep, const size_t rightstep, const size_t oleftstep, const size_t orightstep, size_t lroffset, size_t rroffset, escript::ES_optype operation)
Definition: DataVectorOps.h:1222
DataTypes::vec_size_type size_type
Definition: DataVectorAlt.h:49
void eigenvalues1(const DataTypes::real_t A00, DataTypes::real_t *ev0)
solves a 1x1 eigenvalue A*V=ev*V problem
Definition: ArrayOps.h:160
virtual DataTypes::RealVectorType::size_type getPointOffset(int sampleNo, int dataPointNo) const
getPointOffset
Definition: DataTagged.cpp:981
Definition: AbstractContinuousDomain.cpp:22
void transpose(const VEC &in, const DataTypes::ShapeType &inShape, typename VEC::size_type inOffset, VEC &ev, const DataTypes::ShapeType &evShape, typename VEC::size_type evOffset, int axis_offset)
Transpose each data point of this Data object around the given axis.
Definition: DataVectorOps.h:342
Definition: ES_optype.h:30
void eigenvalues_and_eigenvectors3(const DataTypes::real_t A00, const DataTypes::real_t A01, const DataTypes::real_t A02, const DataTypes::real_t A11, const DataTypes::real_t A12, const DataTypes::real_t A22, DataTypes::real_t *ev0, DataTypes::real_t *ev1, DataTypes::real_t *ev2, DataTypes::real_t *V00, DataTypes::real_t *V10, DataTypes::real_t *V20, DataTypes::real_t *V01, DataTypes::real_t *V11, DataTypes::real_t *V21, DataTypes::real_t *V02, DataTypes::real_t *V12, DataTypes::real_t *V22, const DataTypes::real_t tol)
solves a 2x2 eigenvalue A*V=ev*V problem for symmetric A. Eigenvectors are ordered by increasing valu...
Definition: ArrayOps.h:450
bool vectorHasNaN(const DataTypes::RealVectorType &in, DataTypes::RealVectorType::size_type inOffset, size_t count)
returns true if the vector contains NaN
Definition: DataVectorOps.h:1472
Definition: LapackInverseHelper.h:26
vec_size_type getRelIndex(const DataTypes::ShapeType &shape, vec_size_type i)
Compute the offset (in 1D vector) of a given subscript with a shape.
Definition: DataTypes.h:233
Definition: ES_optype.h:32
void binaryOpVectorLazyArithmeticHelper(ResELT *res, const LELT *left, const RELT *right, const size_t chunksize, const size_t onumsteps, const size_t numsteps, const size_t resultStep, const size_t leftstep, const size_t rightstep, const size_t oleftstep, const size_t orightstep, size_t lroffset, size_t rroffset, escript::ES_optype operation)
Definition: DataVectorOps.h:1175
std::vector< int > ShapeType
The shape of a single datapoint.
Definition: DataTypes.h:42
void binaryOpVectorLeftScalar(DataTypes::RealVectorType &res, typename DataTypes::RealVectorType::size_type resOffset, const typename DataTypes::RealVectorType::size_type samplesToProcess, const typename DataTypes::RealVectorType::size_type sampleSize, const DataTypes::real_t *left, const bool leftreset, const DataTypes::RealVectorType &right, typename DataTypes::RealVectorType::size_type rightOffset, escript::ES_optype operation, bool singlerightsample)
Definition: DataVectorOps.cpp:638
Definition: ES_optype.h:33
Simulates a full dataset accessible via sampleNo and dataPointNo.
Definition: DataTagged.h:44
void symmetric(const VEC &in, const DataTypes::ShapeType &inShape, typename VEC::size_type inOffset, VEC &ev, const DataTypes::ShapeType &evShape, typename VEC::size_type evOffset)
computes a symmetric matrix from your square matrix A: (A + transpose(A)) / 2
Definition: DataVectorOps.h:102
size_type size() const
Return the number of elements in this DataVectorAlt.
Definition: DataVectorAlt.h:214
void eigenvalues2(const T A00, const T A01, const T A11, T *ev0, T *ev1)
solves a 2x2 eigenvalue A*V=ev*V problem for symmetric A
Definition: ArrayOps.h:182
void matMult(const DataTypes::RealVectorType &left, const DataTypes::ShapeType &leftShape, DataTypes::RealVectorType::size_type leftOffset, const DataTypes::RealVectorType &right, const DataTypes::ShapeType &rightShape, DataTypes::RealVectorType::size_type rightOffset, DataTypes::RealVectorType &result, const DataTypes::ShapeType &resultShape)
Perform a matrix multiply of the given views.
Definition: DataVectorOps.cpp:38
#define OPVECLAZYBODY(X)
Definition: DataVectorOps.h:1150
void hermitian(const DataTypes::CplxVectorType &in, const DataTypes::ShapeType &inShape, DataTypes::CplxVectorType::size_type inOffset, DataTypes::CplxVectorType &ev, const DataTypes::ShapeType &evShape, DataTypes::CplxVectorType::size_type evOffset)
computes an hermitian matrix from your square matrix A: (A + adjoint(A)) / 2
Definition: DataVectorOps.cpp:915
void binaryOpVectorRightScalar(DataTypes::RealVectorType &res, typename DataTypes::RealVectorType::size_type resOffset, const typename DataTypes::RealVectorType::size_type samplesToProcess, const typename DataTypes::RealVectorType::size_type sampleSize, const DataTypes::RealVectorType &left, typename DataTypes::RealVectorType::size_type leftOffset, const DataTypes::real_t *right, const bool rightreset, escript::ES_optype operation, bool singleleftsample)
Definition: DataVectorOps.cpp:499
ES_optype
Definition: ES_optype.h:26
int matrix_inverse(const DataTypes::RealVectorType &in, const DataTypes::ShapeType &inShape, DataTypes::RealVectorType::size_type inOffset, DataTypes::RealVectorType &out, const DataTypes::ShapeType &outShape, DataTypes::RealVectorType::size_type outOffset, int count, LapackInverseHelper &helper)
computes the inverses of square (up to 3x3) matricies
Definition: DataVectorOps.cpp:206
void binaryOpVectorTagged(DataTypes::RealVectorType &res, const typename DataTypes::RealVectorType::size_type samplesToProcess, const typename DataTypes::RealVectorType::size_type DPPSample, const typename DataTypes::RealVectorType::size_type DPSize, const DataTypes::RealVectorType &left, const bool leftscalar, const DataTypes::RealVectorType &right, const bool rightscalar, const bool lefttagged, const DataTagged &tagsource, escript::ES_optype operation)
Definition: DataVectorOps.cpp:339
void eigenvalues_and_eigenvectors2(const DataTypes::real_t A00, const DataTypes::real_t A01, const DataTypes::real_t A11, DataTypes::real_t *ev0, DataTypes::real_t *ev1, DataTypes::real_t *V00, DataTypes::real_t *V10, DataTypes::real_t *V01, DataTypes::real_t *V11, const DataTypes::real_t tol)
solves a 2x2 eigenvalue A*V=ev*V problem for symmetric A. Eigenvectors are ordered by increasing valu...
Definition: ArrayOps.h:341
bool checkOffset(const VEC &data, const DataTypes::ShapeType &shape, typename VEC::size_type offset)
Definition: DataVectorOps.h:816
void eigenvalues_and_eigenvectors1(const DataTypes::real_t A00, DataTypes::real_t *ev0, DataTypes::real_t *V00, const DataTypes::real_t tol)
solves a 1x1 eigenvalue A*V=ev*V problem for symmetric A
Definition: ArrayOps.h:249
Definition: ES_optype.h:79
Definition: ES_optype.h:80
void swapaxes(const VEC &in, const DataTypes::ShapeType &inShape, typename VEC::size_type inOffset, VEC &ev, const DataTypes::ShapeType &evShape, typename VEC::size_type evOffset, int axis0, int axis1)
swaps the components axis0 and axis1.
Definition: DataVectorOps.h:487
void matrixInverseError(int err)
throws an appropriate exception based on failure of matrix_inverse.
Definition: DataVectorOps.cpp:185
#define V(_K_, _I_)
Definition: ShapeFunctions.cpp:120
real_t ElementType
Definition: DataVectorAlt.h:42
int noValues(const ShapeType &shape)
Calculate the number of values in a datapoint with the given shape.
Definition: DataTypes.cpp:90
Definition: DataException.h:26
#define ESCRIPT_DLL_API
Definition: escriptcore/src/system_dep.h:29
void trace(const VEC &in, const DataTypes::ShapeType &inShape, typename VEC::size_type inOffset, VEC &ev, const DataTypes::ShapeType &evShape, typename VEC::size_type evOffset, int axis_offset)
computes the trace of a matrix
Definition: DataVectorOps.h:241
escript::DataTypes::DataVectorAlt< real_t > RealVectorType
Vector to store underlying data.
Definition: DataVector.h:43
DataTypes::real_t reductionOpVector(const DataTypes::RealVectorType &left, const DataTypes::ShapeType &leftShape, DataTypes::RealVectorType::size_type offset, BinaryFunction operation, DataTypes::real_t initial_value)
Perform the given data point reduction operation on the data point specified by the given offset into...
Definition: DataVectorOps.h:1396
void antisymmetric(const VEC &in, const DataTypes::ShapeType &inShape, typename VEC::size_type inOffset, VEC &ev, const DataTypes::ShapeType &evShape, typename VEC::size_type evOffset)
computes a antisymmetric matrix from your square matrix A: (A - transpose(A)) / 2 ...
Definition: DataVectorOps.h:151
Definition: ES_optype.h:34
void eigenvalues_and_eigenvectors(const DataTypes::RealVectorType &in, const DataTypes::ShapeType &inShape, DataTypes::RealVectorType::size_type inOffset, DataTypes::RealVectorType &ev, const DataTypes::ShapeType &evShape, DataTypes::RealVectorType::size_type evOffset, DataTypes::RealVectorType &V, const DataTypes::ShapeType &VShape, DataTypes::RealVectorType::size_type VOffset, const double tol=1.e-13)
solves a local eigenvalue problem
Definition: DataVectorOps.h:749
int getRank(const DataTypes::ShapeType &shape)
Return the rank (number of dimensions) of the given shape.
Definition: DataTypes.h:218
#define ESYS_ASSERT(a, b)
EsysAssert is a MACRO that will throw an exception if the boolean condition specified is false...
Definition: Assert.h:78
Definition: ES_optype.h:78
bool nancheck(DataTypes::real_t d)
acts as a wrapper to isnan.
Definition: ArrayOps.h:116
void antihermitian(const DataTypes::CplxVectorType &in, const DataTypes::ShapeType &inShape, typename DataTypes::CplxVectorType::size_type inOffset, DataTypes::CplxVectorType &ev, const DataTypes::ShapeType &evShape, typename DataTypes::CplxVectorType::size_type evOffset)
computes a antihermitian matrix from your square matrix A: (A - adjoint(A)) / 2
Definition: DataVectorOps.cpp:962
Definition: ES_optype.h:31
double real_t
type of all real-valued scalars in escript
Definition: DataTypes.h:50
Definition: ES_optype.h:77
void eigenvalues3(const DataTypes::real_t A00, const DataTypes::real_t A01, const DataTypes::real_t A02, const DataTypes::real_t A11, const DataTypes::real_t A12, const DataTypes::real_t A22, DataTypes::real_t *ev0, DataTypes::real_t *ev1, DataTypes::real_t *ev2)
solves a 3x3 eigenvalue A*V=ev*V problem for symmetric A
Definition: ArrayOps.h:206