EigenComplexVector.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidCurveFitting/EigenComplexVector.h"
 
#include <cmath>
#include <iomanip>
#include <sstream>
#include <stdexcept>
 
namespace Mantid::CurveFitting {
 
ComplexVector::ComplexVector() : m_vector(Eigen::VectorXcd(1)) { zero(); }
 
ComplexVector::ComplexVector(const size_t n) : m_vector(Eigen::VectorXcd(n)) {}
 
ComplexVector::ComplexVector(const ComplexVector &v) : m_vector(v.m_vector) {}
 
ComplexVector::ComplexVector(ComplexVector &&v) : m_vector(std::move(v.m_vector)) {}
 
ComplexVector::ComplexVector(const Eigen::VectorXcd v) : m_vector(v) {}
 
ComplexVector::ComplexVector(Eigen::VectorXcd &&v) : m_vector(std::move(v)) {}
 
ComplexVector &ComplexVector::operator=(const ComplexVector &v) {
  m_vector = v.m_vector;
  return *this;
}
 
ComplexVector &ComplexVector::operator=(const Eigen::VectorXcd &v) {
  m_vector = v;
  return *this;
}
 
ComplexVector &ComplexVector::operator=(ComplexVector &&v) noexcept {
  m_vector = std::move(v.m_vector);
  return *this;
}
 
Eigen::VectorXcd &ComplexVector::eigen() { return m_vector; }
 
const Eigen::VectorXcd ComplexVector::eigen() const { return m_vector; }
 
void ComplexVector::resize(const size_t n) {
  auto newVector = Eigen::VectorXcd(n);
  size_t m = size() < n ? size() : n;
  for (size_t i = 0; i < m; ++i) {
    newVector(i) = m_vector(i);
  }
  for (size_t i = m; i < n; ++i) {
    newVector(i) = ComplexType(0, 0);
  }
  m_vector = newVector;
}
 
size_t ComplexVector::size() const { return m_vector.size(); }
 
void ComplexVector::set(const size_t i, const ComplexType &value) {
  if (i < size()) {
    m_vector(i) = value;
  } else {
    std::stringstream errmsg;
    errmsg << "ComplexVector index = " << i << " is out of range = " << m_vector.size() << " in ComplexVector.set()";
    throw std::out_of_range(errmsg.str());
  }
}
ComplexType ComplexVector::get(const size_t i) const {
  if (i < size()) {
    return m_vector(i);
  }
  std::stringstream errmsg;
  errmsg << "ComplexVector index = " << i << " is out of range = " << m_vector.size() << " in ComplexVector.get()";
  throw std::out_of_range(errmsg.str());
}
 
// Set all elements to zero
void ComplexVector::zero() { m_vector.setZero(); }
 
ComplexVector &ComplexVector::operator+=(const ComplexVector &v) {
  if (size() != v.size()) {
    throw std::runtime_error("ComplexVectors have different sizes.");
  }
  m_vector += v.eigen();
  return *this;
}
 
ComplexVector &ComplexVector::operator-=(const ComplexVector &v) {
  if (size() != v.size()) {
    throw std::runtime_error("ComplexVectors have different sizes.");
  }
  m_vector -= v.eigen();
  return *this;
}
 
ComplexVector &ComplexVector::operator*=(const ComplexType d) {
  m_vector *= d;
  return *this;
}
 
ComplexVector &ComplexVector::operator+=(const ComplexType &d) {
  m_vector.array() += d;
  return *this;
}
 
ComplexVector ComplexVector::move() { return ComplexVector(m_vector); }
 
std::ostream &operator<<(std::ostream &ostr, const ComplexVector &v) {
  std::ios::fmtflags fflags(ostr.flags());
  ostr << std::scientific << std::setprecision(6);
  for (size_t j = 0; j < v.size(); ++j) {
    auto value = v.get(j);
    ostr << std::setw(28) << value.real() << "+" << value.imag() << "j";
  }
  ostr.flags(fflags);
  return ostr;
}
 
void ComplexVector::sort(const std::vector<size_t> &indices) {
  std::vector<ComplexType> temp_data(size());
  std::transform(indices.cbegin(), indices.cend(), temp_data.begin(),
                 [&m_vector = m_vector](size_t i) { return m_vector(i); });
  resize(indices.size());
  m_vector = complex_vec_map_type(temp_data.data(), temp_data.size(), dynamic_stride(0, 1));
}
 
} // namespace Mantid::CurveFitting