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,
752 const double tol=1.e-13)
754 double in00,in10,in20,in01,in11,in21,in02,in12,in22;
755 double V00,V10,V20,V01,V11,V21,V02,V12,V22;
769 &ev0,&ev1,&V00,&V10,&V01,&V11,tol);
788 &V00,&V10,&V20,&V01,&V11,&V21,&V02,&V12,&V22,tol);
815 typename VEC::size_type offset)
823 template <
class ResVEC,
class LVEC,
class RSCALAR>
826 typename ResVEC::size_type resOffset,
827 const typename ResVEC::size_type samplesToProcess,
828 const typename ResVEC::size_type sampleSize,
830 typename LVEC::size_type leftOffset,
831 const RSCALAR* right,
832 const bool rightreset,
834 bool singleleftsample)
836 size_t substep=(rightreset?0:1);
841 #pragma omp parallel for 842 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
844 typename LVEC::size_type leftbase=leftOffset+(singleleftsample?0:i*sampleSize);
845 const RSCALAR* rpos=right+(rightreset?0:i*substep);
847 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
849 res[i*sampleSize+resOffset+j]=left[leftbase+j]+*rpos;
856 #pragma omp parallel for 857 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
859 typename LVEC::size_type leftbase=leftOffset+(singleleftsample?0:i*sampleSize);
860 const RSCALAR* rpos=right+(rightreset?0:i*substep);
862 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
864 res[i*sampleSize+resOffset+j]=pow(left[leftbase+j],*rpos);
871 #pragma omp parallel for 872 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
874 typename LVEC::size_type leftbase=leftOffset+(singleleftsample?0:i*sampleSize);
875 const RSCALAR* rpos=right+(rightreset?0:i*substep);
877 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
879 res[i*sampleSize+resOffset+j]=left[leftbase+j]-*rpos;
886 #pragma omp parallel for 887 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
889 typename LVEC::size_type leftbase=leftOffset+(singleleftsample?0:i*sampleSize);
890 const RSCALAR* rpos=right+(rightreset?0:i*substep);
892 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
894 res[i*sampleSize+resOffset+j]=left[leftbase+j] * *rpos;
901 #pragma omp parallel for 902 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
904 typename LVEC::size_type leftbase=leftOffset+(singleleftsample?0:i*sampleSize);
905 const RSCALAR* rpos=right+(rightreset?0:i*substep);
907 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
909 res[i*sampleSize+resOffset+j]=left[leftbase+j]/ *rpos;
928 const bool rightreset,
930 bool singleleftsample);
935 template <
class ResVEC,
class LSCALAR,
class RVEC>
938 typename ResVEC::size_type resOffset,
939 const typename ResVEC::size_type samplesToProcess,
940 const typename ResVEC::size_type sampleSize,
942 const bool leftreset,
944 typename RVEC::size_type rightOffset,
946 bool singlerightsample)
948 size_t substep=(leftreset?0:1);
953 #pragma omp parallel for 954 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
956 typename RVEC::size_type rightbase=rightOffset+(singlerightsample?0:i*sampleSize);
957 const LSCALAR* lpos=left+(leftreset?0:i*substep);
958 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
960 res[i*sampleSize+resOffset+j]=*lpos+right[rightbase+j];
967 #pragma omp parallel for 968 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
970 typename RVEC::size_type rightbase=rightOffset+(singlerightsample?0:i*sampleSize);
971 const LSCALAR* lpos=left+(leftreset?0:i*substep);
972 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
974 res[i*sampleSize+resOffset+j]=pow(*lpos,right[rightbase+j]);
981 #pragma omp parallel for 982 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
984 typename RVEC::size_type rightbase=rightOffset+(singlerightsample?0:i*sampleSize);
985 const LSCALAR* lpos=left+(leftreset?0:i*substep);
986 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
988 res[i*sampleSize+resOffset+j]=*lpos-right[rightbase+j];
995 #pragma omp parallel for 996 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
998 typename RVEC::size_type rightbase=rightOffset+(singlerightsample?0:i*sampleSize);
999 const LSCALAR* lpos=left+(leftreset?0:i*substep);
1000 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
1002 res[i*sampleSize+resOffset+j]=*lpos*right[rightbase+j];
1009 #pragma omp parallel for 1010 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
1012 typename RVEC::size_type rightbase=rightOffset+(singlerightsample?0:i*sampleSize);
1013 const LSCALAR* lpos=left+(leftreset?0:i*substep);
1014 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
1016 res[i*sampleSize+resOffset+j]=*lpos/right[rightbase+j];
1033 const bool leftreset,
1037 bool singlerightsample);
1042 template <
class ResVEC,
class LVEC,
class RVEC>
1045 typename ResVEC::size_type resOffset,
1046 const typename ResVEC::size_type samplesToProcess,
1047 const typename ResVEC::size_type sampleSize,
1049 typename LVEC::size_type leftOffset,
1050 const bool leftreset,
1052 typename RVEC::size_type rightOffset,
1053 const bool rightreset,
1060 #pragma omp parallel for 1061 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
1063 typename LVEC::size_type leftbase=leftOffset+(leftreset?0:i*sampleSize);
1064 typename RVEC::size_type rightbase=rightOffset+(rightreset?0:i*sampleSize);
1065 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
1067 res[i*sampleSize+resOffset+j]=left[leftbase+j]+right[rightbase+j];
1074 #pragma omp parallel for 1075 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
1077 typename LVEC::size_type leftbase=leftOffset+(leftreset?0:i*sampleSize);
1078 typename RVEC::size_type rightbase=rightOffset+(rightreset?0:i*sampleSize);
1079 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
1081 res[i*sampleSize+resOffset+j]=pow(left[leftbase+j],right[rightbase+j]);
1088 #pragma omp parallel for 1089 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
1091 typename LVEC::size_type leftbase=leftOffset+(leftreset?0:i*sampleSize);
1092 typename RVEC::size_type rightbase=rightOffset+(rightreset?0:i*sampleSize);
1093 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
1095 res[i*sampleSize+resOffset+j]=left[leftbase+j]-right[rightbase+j];
1102 #pragma omp parallel for 1103 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
1105 typename LVEC::size_type leftbase=leftOffset+(leftreset?0:i*sampleSize);
1106 typename RVEC::size_type rightbase=rightOffset+(rightreset?0:i*sampleSize);
1107 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
1109 res[i*sampleSize+resOffset+j]=left[leftbase+j]*right[rightbase+j];
1116 #pragma omp parallel for 1117 for (
typename ResVEC::size_type i=0;i<samplesToProcess;++i)
1119 typename LVEC::size_type leftbase=leftOffset+(leftreset?0:i*sampleSize);
1120 typename RVEC::size_type rightbase=rightOffset+(rightreset?0:i*sampleSize);
1121 for (
typename ResVEC::size_type j=0;j<sampleSize;++j)
1123 res[i*sampleSize+resOffset+j]=left[leftbase+j]/right[rightbase+j];
1141 const bool leftreset,
1144 const bool rightreset,
1147 #define OPVECLAZYBODY(X) \ 1148 for (size_t j=0;j<onumsteps;++j)\ 1150 for (size_t i=0;i<numsteps;++i,res+=resultStep) \ 1152 for (size_t s=0; s<chunksize; ++s)\ 1157 lroffset+=leftstep; \ 1158 rroffset+=rightstep; \ 1160 lroffset+=oleftstep;\ 1161 rroffset+=orightstep;\ 1170 template <
class ResELT,
class LELT,
class RELT>
1175 const size_t chunksize,
1176 const size_t onumsteps,
1177 const size_t numsteps,
1178 const size_t resultStep,
1179 const size_t leftstep,
1180 const size_t rightstep,
1181 const size_t oleftstep,
1182 const size_t orightstep,
1217 ESYS_ASSERT(
false,
"Invalid operation. This should never happen!");
1226 template <
class ResVEC,
class LVEC,
class RVEC>
1229 const typename ResVEC::size_type samplesToProcess,
1230 const typename ResVEC::size_type DPPSample,
1231 const typename ResVEC::size_type DPSize,
1240 typename ResVEC::size_type lstep=leftscalar?1:DPSize;
1241 typename ResVEC::size_type rstep=rightscalar?1:DPSize;
1242 typename ResVEC::size_type limit=samplesToProcess*DPPSample;
1247 #pragma omp parallel for 1248 for (
typename ResVEC::size_type i=0;i<limit;++i)
1250 typename LVEC::size_type leftbase=(lefttagged?tagsource.
getPointOffset(i/DPPSample,0):i*lstep);
1251 typename RVEC::size_type rightbase=(lefttagged?i*rstep:tagsource.
getPointOffset(i/DPPSample,0));
1253 for (
typename ResVEC::size_type j=0;j<DPSize;++j)
1255 res[i*DPSize+j]=left[leftbase+j*(!leftscalar)]+right[rightbase+j*(!rightscalar)];
1262 #pragma omp parallel for 1263 for (
typename ResVEC::size_type i=0;i<limit;++i)
1265 typename LVEC::size_type leftbase=(lefttagged?tagsource.
getPointOffset(i/DPPSample,0):i*lstep);
1266 typename RVEC::size_type rightbase=(lefttagged?i*rstep:tagsource.
getPointOffset(i/DPPSample,0));
1268 for (
typename ResVEC::size_type j=0;j<DPSize;++j)
1270 res[i*DPSize+j]=pow(left[leftbase+j*(!leftscalar)],right[rightbase+j*(!rightscalar)]);
1277 #pragma omp parallel for 1278 for (
typename ResVEC::size_type i=0;i<limit;++i)
1280 typename LVEC::size_type leftbase=(lefttagged?tagsource.
getPointOffset(i/DPPSample,0):i*lstep);
1281 typename RVEC::size_type rightbase=(lefttagged?i*rstep:tagsource.
getPointOffset(i/DPPSample,0));
1283 for (
typename ResVEC::size_type j=0;j<DPSize;++j)
1285 res[i*DPSize+j]=left[leftbase+j*(!leftscalar)]-right[rightbase+j*(!rightscalar)];
1292 #pragma omp parallel for 1293 for (
typename ResVEC::size_type i=0;i<limit;++i)
1295 typename LVEC::size_type leftbase=(lefttagged?tagsource.
getPointOffset(i/DPPSample,0):i*lstep);
1296 typename RVEC::size_type rightbase=(lefttagged?i*rstep:tagsource.
getPointOffset(i/DPPSample,0));
1298 for (
typename ResVEC::size_type j=0;j<DPSize;++j)
1300 res[i*DPSize+j]=left[leftbase+j*(!leftscalar)]*right[rightbase+j*(!rightscalar)];
1307 #pragma omp parallel for 1308 for (
typename ResVEC::size_type i=0;i<limit;++i)
1310 typename LVEC::size_type leftbase=(lefttagged?tagsource.
getPointOffset(i/DPPSample,0):i*lstep);
1311 typename RVEC::size_type rightbase=(lefttagged?i*rstep:tagsource.
getPointOffset(i/DPPSample,0));
1313 for (
typename ResVEC::size_type j=0;j<DPSize;++j)
1315 res[i*DPSize+j]=left[leftbase+j*(!leftscalar)]/right[rightbase+j*(!rightscalar)];
1332 const bool leftscalar,
1334 const bool rightscalar,
1335 const bool lefttagged,
1358 template <
class BinaryFunction>
1364 BinaryFunction operation,
1368 "Couldn't perform reductionOp due to insufficient storage.");
1371 current_value=operation(current_value,left[offset+i]);
1373 return current_value;
1376 template <
class BinaryFunction>
1382 BinaryFunction operation,
1386 "Couldn't perform reductionOp due to insufficient storage.");
1389 current_value=operation(current_value,left[offset+i]);
1391 return current_value;
1439 for (
size_t z=inOffset;z<inOffset+count;++z)
1451 #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 binaryOpVectorLazyHelper(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:1172
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
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:148
virtual DataTypes::RealVectorType::size_type getPointOffset(int sampleNo, int dataPointNo) const
getPointOffset
Definition: DataTagged.cpp:840
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:438
bool vectorHasNaN(const DataTypes::RealVectorType &in, DataTypes::RealVectorType::size_type inOffset, size_t count)
returns true if the vector contains NaN
Definition: DataVectorOps.h:1437
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
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:198
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:170
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:1147
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:329
bool checkOffset(const VEC &data, const DataTypes::ShapeType &shape, typename VEC::size_type offset)
Definition: DataVectorOps.h:813
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:237
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:38
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:1361
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:746
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:194