VectorOperations.cpph

Go to the documentation of this file.

#include <limits>
 
 
template <int Size, typename Scalar>
std::vector<Scalar> tarch::la::toSTLVector(const Vector<Size, Scalar>& vector) {
  std::vector<Scalar> result(Size);
  for (int i=0; i<Size; i++) result[i] = vector(i);
  return result;
}
 
 
template <int Size, typename Scalar>
int tarch::la::count(const Vector<Size, Scalar>& vector, const Scalar& value) {
  int result = 0;
  for (int d = 0; d < Size; d++) {
    if (tarch::la::equals(vector(d), value)) {
      result++;
    }
  }
  return result;
}
 
template <int Size, typename Scalar>
bool tarch::la::allEntriesAreTheSame(const Vector<Size, Scalar>& vector) {
  bool result = true;
  for (int d = 0; d < Size; d++) {
    result &= tarch::la::equals(vector(d), vector(0));
  }
  return result;
}
 
template <int Size, typename Scalar>
int tarch::la::isEntryNan(const Vector<Size, Scalar>& vector) {
  bool result = false;
  for (int i = 0; i < Size; i++) {
    result |= std::isnan(vector(i));
  }
  return result;
}
 
template <int Size, typename Scalar>
int tarch::la::isEntryFinite(const Vector<Size, Scalar>& vector) {
  bool result = true;
  for (int i = 0; i < Size; i++) {
    result &= std::isfinite(vector(i));
  }
  return result;
}
 
template <int Size, typename Scalar>
bool tarch::la::contains(const Vector<Size, Scalar>& vector, const Scalar& value) {
  bool result = false;
  for (int d = 0; d < Size; d++) {
    result |= vector(d) == value;
  }
  return result;
}
 
template <int Size, typename Scalar>
tarch::la::Vector<Size, Scalar> tarch::la::invertEntries(const Vector<Size, Scalar>& vector) {
  Vector<Size, Scalar> result;
#ifdef CompilerICC
#pragma ivdep
#endif
  for (int i = 0; i < Size; i++) {
    assertion1(vector(i) != 0.0, vector.toString());
    result(i) = 1.0 / vector(i);
  }
  return result;
}
 
template <int Size, typename Scalar>
Scalar tarch::la::norm1(const Vector<Size, Scalar>& vector) {
  Scalar result(tarch::la::abs(vector(0)));
  for (int i = 1; i < Size; i++) {
    result += tarch::la::abs(vector(i));
  }
  return result;
}
 
template <int Size>
double tarch::la::norm1(const Vector<Size, std::complex<double>>& vector) {
  double result(0.0);
  for (int i = 0; i < Size; i++) {
    result += tarch::la::abs(vector(i));
  }
  return result;
}
 
template <int Size, typename Scalar>
Scalar tarch::la::norm2Squared(const Vector<Size, Scalar>& vector) {
  Scalar result(vector(0) * vector(0));
  for (int i = 1; i < Size; i++) {
    result += vector(i) * vector(i);
  }
  return result;
}
 
template <int Size, typename Scalar>
Scalar tarch::la::norm2(const Vector<Size, Scalar>& vector) {
  return std::sqrt(norm2Squared(vector));
}
 
template <int Size>
double tarch::la::norm2Squared(const Vector<Size, std::complex<double>>& vector) {
  double result(0.0);
  for (int i = 0; i < Size; i++) {
    result += (vector(i).real() * vector(i).real());
    result += (vector(i).img() * vector(i).img());
  }
  return result;
}
 
template <int Size>
double tarch::la::norm2(const Vector<Size, std::complex<double>>& vector) {
  return std::sqrt(norm2Squared(vector));
}
 
template <int Size, typename Scalar>
Scalar tarch::la::normMax(const Vector<Size, Scalar>& vector) {
  Scalar result(0);
 
  for (int i = 0; i < Size; i++) {
    result = std::abs(vector(i)) > result ? std::abs(vector(i)) : result;
  }
 
  return result;
}
 
template <int Size>
double tarch::la::normMax(const Vector<Size, std::complex<double>>& vector) {
  double result = 0.0;
 
  for (int i = 0; i < Size; i++) {
    result = std::abs(vector(i)) > result ? std::abs(vector(i)) : result;
  }
 
  return result;
}
 
template <int Size, typename Scalar>
tarch::la::Vector<Size, Scalar> tarch::la::abs(const Vector<Size, Scalar>& vector) {
  Vector<Size, Scalar> result;
  for (int i = 0; i < Size; i++) {
    result(i) = tarch::la::abs(vector(i));
  }
  return result;
}
 
template <int Size>
tarch::la::Vector<Size, double> tarch::la::abs(const Vector<Size, std::complex<double>>& vector) {
  Vector<Size, double> result;
  for (int i = 0; i < Size; i++) {
    result(i) = tarch::la::abs(vector(i));
  }
  return result;
}
 
template <int Size, typename Scalar>
Scalar tarch::la::average(const Vector<Size, Scalar>& vector) {
  return sum(vector) / static_cast<Scalar>(Size);
}
 
template <int Size, typename Scalar>
Scalar tarch::la::sum(const Vector<Size, Scalar>& vector) {
  Scalar result = vector(0);
  for (int i = 1; i < Size; i++) {
    result += vector(i);
  }
  return result;
}
 
template <int Size, typename Scalar>
Scalar tarch::la::volume(const Vector<Size, Scalar>& vector) {
  Scalar result = vector(0);
  for (int i = 1; i < Size; i++) {
    result *= vector(i);
  }
  return result;
}
 
template <int Size, typename Scalar>
int tarch::la::indexMax(const Vector<Size, Scalar>& vector) {
  int indexMax = 0;
  for (int i = 1; i < Size; i++) {
    indexMax = vector(i) > vector(indexMax) ? i : indexMax;
  }
  return indexMax;
}
 
template <int Size, typename Scalar>
int tarch::la::indexMin(const Vector<Size, Scalar>& vector) {
  int indexMin = 0;
  for (int i = 1; i < Size; i++) {
    indexMin = vector(i) < vector(indexMin) ? i : indexMin;
  }
  return indexMin;
}
 
template <int Size, typename Scalar>
Scalar tarch::la::max(const Vector<Size, Scalar>& vector) {
  Scalar largest = vector(0);
  for (int i = 1; i < Size; i++) {
    if (largest < vector(i)) {
      largest = vector(i);
    }
  }
  return largest;
}
 
template <int Size, typename Scalar>
Scalar tarch::la::maxAbs(const Vector<Size, Scalar>& vector) {
  Scalar largest = std::abs(vector(0));
  for (int i = 1; i < Size; i++) {
    if (largest < std::abs(vector(i))) {
      largest = std::abs(vector(i));
    }
  }
  return largest;
}
 
template <int Size>
tarch::la::Vector<Size, double> tarch::la::real(const Vector<Size, std::complex<double>>& vector) {
  tarch::la::Vector<Size, double> result;
 
  for (int d = 0; d < Size; d++) {
    result(d) = vector(d).real();
  }
 
  return result;
}
 
template <int Size>
tarch::la::Vector<Size, double> tarch::la::imag(const Vector<Size, std::complex<double>>& vector) {
  tarch::la::Vector<Size, double> result;
 
  for (int d = 0; d < Size; d++) {
    result(d) = vector(d).imag();
  }
 
  return result;
}
 
template <int Size>
double tarch::la::maxReal(const Vector<Size, std::complex<double>>& vector) {
  double result = std::numeric_limits<double>::min();
  for (int i = 0; i < Size; i++) {
    result = result > vector(i).real() ? result : vector(i).real();
  }
  return result;
}
 
template <int Size>
double tarch::la::maxImag(const Vector<Size, std::complex<double>>& vector) {
  double result = std::numeric_limits<double>::min();
  for (int i = 0; i < Size; i++) {
    result = result > vector(i).imag() ? result : vector(i).imag();
  }
  return result;
}
 
template <int Size, typename Scalar>
Scalar tarch::la::min(const Vector<Size, Scalar>& vector) {
  Scalar smallest = vector(0);
  for (int i = 1; i < Size; i++) {
    if (smallest > vector(i)) {
      smallest = vector(i);
    }
  }
  return smallest;
}
 
template <int Size, typename Scalar>
std::ostream& operator<<(std::ostream& os, const tarch::la::Vector<Size, Scalar>& vector) {
  os << ::toString(vector);
  return os;
}