38 memcpy(vdata, op1.
vdata, vdim *
sizeof(T));
51 for (
size_t i = 0;
i < vdim; ++
i)
60 resizeNoCopy(op1.size());
61 memcpy(&vdata[0],&(op1[0]),vdim*
sizeof(T));
85 for (
size_t j = 0;
j < vdim;
j++)
100 for (
size_t j = 0;
j < vdim;
j++)
107 for (
size_t j = 0;
j < vdim;
j++)
119 size_t iBlockMax = vdim / 4;
120 for (
size_t i = 0;
i < iBlockMax;
i++)
122 (*ptr1++) = (*ptr2++) * op1;
123 (*ptr1++) = (*ptr2++) * op1;
124 (*ptr1++) = (*ptr2++) * op1;
125 (*ptr1++) = (*ptr2++) * op1;
127 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
128 (*ptr1++) = (*ptr2++) * op1;
139 size_t iBlockMax = vdim / 4;
140 for (
size_t i = 0;
i < iBlockMax;
i++)
142 (*ptr1++) = (*ptr2++) * iop1;
143 (*ptr1++) = (*ptr2++) * iop1;
144 (*ptr1++) = (*ptr2++) * iop1;
145 (*ptr1++) = (*ptr2++) * iop1;
147 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
148 (*ptr1++) = (*ptr2++) * iop1;
158 size_t iBlockMax = vdim / 4;
159 for (
size_t i = 0;
i < iBlockMax;
i++)
161 (*ptr1++) = (*ptr2++) + op1;
162 (*ptr1++) = (*ptr2++) + op1;
163 (*ptr1++) = (*ptr2++) + op1;
164 (*ptr1++) = (*ptr2++) + op1;
166 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
167 (*ptr1++) = (*ptr2++) + op1;
177 size_t iBlockMax = vdim / 4;
178 for (
size_t i = 0;
i < iBlockMax;
i++)
180 (*ptr1++) = (*ptr2++) - op1;
181 (*ptr1++) = (*ptr2++) - op1;
182 (*ptr1++) = (*ptr2++) - op1;
183 (*ptr1++) = (*ptr2++) - op1;
185 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
186 (*ptr1++) = (*ptr2++) - op1;
193 if (vdim != op1.
vdim)
198 size_t iBlockMax = vdim / 4;
199 for (
size_t i = 0;
i < iBlockMax;
i++)
201 (*ptr1++) += (*ptr2++);
202 (*ptr1++) += (*ptr2++);
203 (*ptr1++) += (*ptr2++);
204 (*ptr1++) += (*ptr2++);
206 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
207 (*ptr1++) += (*ptr2++);
213 if (vdim != op1.
vdim)
218 size_t iBlockMax = vdim / 4;
219 for (
size_t i = 0;
i < iBlockMax;
i++)
221 (*ptr1++) -= (*ptr2++);
222 (*ptr1++) -= (*ptr2++);
223 (*ptr1++) -= (*ptr2++);
224 (*ptr1++) -= (*ptr2++);
226 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
227 (*ptr1++) -= (*ptr2++);
234 size_t iBlockMax = vdim / 4;
235 for (
size_t i = 0;
i < iBlockMax;
i++)
242 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
251 size_t iBlockMax = vdim / 4;
252 for (
size_t i = 0;
i < iBlockMax;
i++)
259 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
267 size_t iBlockMax = vdim / 4;
268 for (
size_t i = 0;
i < iBlockMax;
i++)
275 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
283 size_t iBlockMax = vdim / 4;
284 for (
size_t i = 0;
i < iBlockMax;
i++)
291 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
302 size_t iBlockMax = vdim / 4;
303 for (
size_t i = 0;
i < iBlockMax;
i++)
305 (*ptr1++) = (*ptr2++) * (*ptr3++);
306 (*ptr1++) = (*ptr2++) * (*ptr3++);
307 (*ptr1++) = (*ptr2++) * (*ptr3++);
308 (*ptr1++) = (*ptr2++) * (*ptr3++);
310 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
311 (*ptr1++) = (*ptr2++) * (*ptr3++);
322 size_t iBlockMax = vdim / 4;
323 for (
size_t i = 0;
i < iBlockMax;
i++)
325 (*ptr1++) = (*ptr2++) / (*ptr3++);
326 (*ptr1++) = (*ptr2++) / (*ptr3++);
327 (*ptr1++) = (*ptr2++) / (*ptr3++);
328 (*ptr1++) = (*ptr2++) / (*ptr3++);
330 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
331 (*ptr1++) = (*ptr2++) / (*ptr3++);
342 size_t iBlockMax = vdim / 4;
343 for (
size_t i = 0;
i < iBlockMax;
i++)
345 (*ptr1++) = (*ptr2++) + (*ptr3++);
346 (*ptr1++) = (*ptr2++) + (*ptr3++);
347 (*ptr1++) = (*ptr2++) + (*ptr3++);
348 (*ptr1++) = (*ptr2++) + (*ptr3++);
350 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
351 (*ptr1++) = (*ptr2++) + (*ptr3++);
362 size_t iBlockMax = vdim / 4;
363 for (
size_t i = 0;
i < iBlockMax;
i++)
365 (*ptr1++) = (*ptr2++) - (*ptr3++);
366 (*ptr1++) = (*ptr2++) - (*ptr3++);
367 (*ptr1++) = (*ptr2++) - (*ptr3++);
368 (*ptr1++) = (*ptr2++) - (*ptr3++);
370 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
371 (*ptr1++) = (*ptr2++) - (*ptr3++);
380 size_t iBlockMax = vdim / 4;
381 for (
size_t i = 0;
i < iBlockMax;
i++)
383 (*ptr1++) *= (*ptr2++);
384 (*ptr1++) *= (*ptr2++);
385 (*ptr1++) *= (*ptr2++);
386 (*ptr1++) *= (*ptr2++);
388 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
389 (*ptr1++) *= (*ptr2++);
397 size_t iBlockMax = vdim / 4;
398 for (
size_t i = 0;
i < iBlockMax;
i++)
400 (*ptr1++) /= (*ptr2++);
401 (*ptr1++) /= (*ptr2++);
402 (*ptr1++) /= (*ptr2++);
403 (*ptr1++) /= (*ptr2++);
405 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
406 (*ptr1++) /= (*ptr2++);
414 size_t iBlockMax = vdim / 4;
415 for (
size_t i = 0;
i < iBlockMax;
i++)
417 (*ptr1++) += (*ptr2++);
418 (*ptr1++) += (*ptr2++);
419 (*ptr1++) += (*ptr2++);
420 (*ptr1++) += (*ptr2++);
422 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
423 (*ptr1++) += (*ptr2++);
431 size_t iBlockMax = vdim / 4;
432 for (
size_t i = 0;
i < iBlockMax;
i++)
434 (*ptr1++) -= (*ptr2++);
435 (*ptr1++) -= (*ptr2++);
436 (*ptr1++) -= (*ptr2++);
437 (*ptr1++) -= (*ptr2++);
439 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
440 (*ptr1++) -= (*ptr2++);
449 size_t iBlockMax = vdim / 4;
450 for (
size_t i = 0;
i < iBlockMax;
i++)
452 if constexpr (std::is_signed_v<T> || std::is_floating_point_v<T>) {
453 (*ptr1++) = -(*ptr2++);
454 (*ptr1++) = -(*ptr2++);
455 (*ptr1++) = -(*ptr2++);
456 (*ptr1++) = -(*ptr2++);
460 static_cast<std::string>(
"Can not use unitary minus on unsigned datatypes"));
464 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
465 if constexpr (std::is_signed_v<T> || std::is_floating_point_v<T>) {
466 (*ptr1++) = -(*ptr2++);
470 static_cast<std::string>(
"Can not use unitary minus on unsigned datatypes"));
479 size_t iBlockMax = vdim / 4;
480 for (
size_t i = 0;
i < iBlockMax;
i++)
491 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
502 size_t iBlockMax = vdim / 4;
503 for (
size_t i = 0;
i < iBlockMax;
i++)
505 *ptr1 =
floor(*ptr1);
507 *ptr1 =
floor(*ptr1);
509 *ptr1 =
floor(*ptr1);
511 *ptr1 =
floor(*ptr1);
514 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
516 *ptr1 =
floor(*ptr1);
525 size_t iBlockMax = vdim / 4;
526 for (
size_t i = 0;
i < iBlockMax;
i++)
528 *ptr1 =
round(*ptr1);
530 *ptr1 =
round(*ptr1);
532 *ptr1 =
round(*ptr1);
534 *ptr1 =
round(*ptr1);
537 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
539 *ptr1 =
round(*ptr1);
552 for (
size_t j = 0;
j < vdim; ++
j)
564 for (
size_t j = 0;
j < vdim; ++
j)
576 maxval = minval =
VEC_ELEM(*
this,0);
577 for (
size_t j = 0;
j < vdim; ++
j)
594 double sum = 0, sum2 = 0;
595 for (
size_t j = 0;
j < vdim; ++
j)
602 stddev=sum2/vdim-mean*mean;
617 for (
size_t j = 0;
j < vdim; ++
j)
634 for (
size_t j = 0;
j < vdim; ++
j)
656 size_t iBlockMax = vdim / 4;
657 for (
size_t i = 0;
i < iBlockMax;
i++)
664 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
667 return sum / (double) vdim;
678 size_t iBlockMax = vdim / 4;
679 for (
size_t i = 0;
i < iBlockMax;
i++)
694 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
709 size_t iBlockMax = vdim / 4;
710 for (
size_t i = 0;
i < iBlockMax;
i++)
712 sum += (*ptr1++) * (*ptr2++);
713 sum += (*ptr1++) * (*ptr2++);
714 sum += (*ptr1++) * (*ptr2++);
715 sum += (*ptr1++) * (*ptr2++);
717 for (
size_t i = iBlockMax * 4;
i < vdim; ++
i)
718 sum += (*ptr1++) * (*ptr2++);
728 T im = (T) (1.0 / m);
738 for (
int j = 0;
j <= (int) (vdim - 1) / 2;
j++)
741 SWAP(vdata[
j], vdata[vdim-1-j], aux);
748 const double i12 = 1.0 / 12.0;
750 for (
int i = 2;
i <= vdim - 2;
i++)
751 if constexpr (std::is_signed_v<T> || std::is_floating_point_v<T>) {
753 * (-(*this)(
i + 2) + 8 * (*
this)(
i + 1) - 8 * (*
this)(
i - 1)
758 static_cast<std::string>(
"Can not use unitary minus on unsigned datatypes"));
769 std::ofstream fh_gplot;
771 (static_cast<std::string>(
"PPP") + fn_tmp +
".gpl").c_str());
775 static_cast<std::string>(
"vector::showWithGnuPlot: Cannot open PPP") + fn_tmp +
".gpl for output");
776 fh_gplot <<
"set xlabel \"" + xlabel +
"\"\n";
778 <<
"plot \"PPP" + fn_tmp +
".txt\" title \"" + title
780 fh_gplot <<
"pause 300 \"\"\n";
783 (static_cast<std::string>(
"(gnuplot PPP") + fn_tmp
784 +
".gpl; rm PPP" + fn_tmp +
".txt PPP" + fn_tmp
785 +
".gpl) &").c_str());
789 "Something went wrong when working with GNUPlot. Please report this error to developers.");
797 out.open(fn.c_str(), std::ios::out);
801 static_cast< std::string >(
"Matrix1D::write: File " + fn +
" cannot be opened for output"));
816 static_cast< std::string >(
"MultidimArray::read: File " + fn +
" not found"));
828 nam =
static_cast<std::string
>(
"PPP" + nam +
".txt");
833 (static_cast<std::string>(
"xmipp_edit -i " + nam +
" -remove &").c_str()));
837 "Something went wrong when working with xmipp_edit. Please report this error to developers.");
Just to locate unclassified errors.
__host__ __device__ float2 floor(const float2 v)
void write(std::ostream &os, const datablock &db)
#define REPORT_ERROR(nerr, ErrormMsg)
void computeMinMax(T &minval, T &maxval) const
Problem with matrix size.
Matrix1D< T > operator-() const
void indexSort(Matrix1D< int > &indx) const
void sqrt(Image< double > &op)
Matrix1D< T > operator*(T op1) const
Matrix1D< double > vectorR3(double x, double y, double z)
void showWithGnuPlot(const std::string &xlabel, const std::string &title)
void operator+=(const Matrix1D< T > &op1) const
void write(const FileName &fn) const
Matrix1D< T > transpose() const
#define XMIPP_EQUAL_REAL(x, y)
void read(const FileName &fn)
void operator-=(const Matrix1D< T > &op1) const
double computeMean() const
double dotProduct(const Matrix1D< T > &op1) const
#define XMIPP_EQUAL_ACCURACY
void indexx(int n, double arrin[], int indx[])
bool row
<0=column vector (default), 1=row vector
double sum(bool average=false) const
Matrix1D< double > vectorR2(double x, double y)
Matrix1D< T > operator/(T op1) const
void sort(struct DCEL_T *dcel)
Matrix1D< T > operator+(T op1) const
void initConstant(std::vector< T > &V, T &value)
#define MATRIX1D_ARRAY(v)
void typeCast(const Matrix1D< T1 > &v1, Matrix1D< T2 > &v2)
void numericalDerivative(Matrix1D< double > &result) const
void resizeNoCopy(int Xdim)
void computeMeanAndStddev(double &mean, double &stddev) const
Matrix1D< T > sort() const
T * vdata
The array itself.
bool operator==(const Matrix1D< T > &op1) const
Matrix1D< T > & operator=(const Matrix1D< T > &op1)
size_t vdim
Number of elements.
void initRandom(int length)