complexfield2d.cpp

Go to the documentation of this file.

/**
 * @file complexfield2d.cpp
 * @brief Implements storage and numerical utilities for complex scalar wave-function fields.
 * @ingroup qpe_math
 *
 * Source: @c core/math/complexfield2d.cpp. This file is part of Quantum Phenomena Explorer (QPE),
 * maintained by Officina Turini. See LICENSE_IT.txt / LICENSE.txt for the
 * QPE freeware source-available terms and THIRD_PARTY_NOTICES.txt for
 * third-party components.
 */
 
#include "complexfield2d.h"
 
#include <algorithm>
#include <cmath>
#include <stdexcept>
 
namespace qpe {
 
ComplexField2D::ComplexField2D(std::size_t width,
                               std::size_t height,
                               float dx,
                               float dy)
{
    resize(width, height, dx, dy);
}
 
void ComplexField2D::resize(std::size_t width,
                            std::size_t height,
                            float dx,
                            float dy)
{
    if (!(dx > 0.0f) || !(dy > 0.0f)) {
        throw std::invalid_argument("ComplexField2D: dx and dy must be positive");
    }
 
    width_ = width;
    height_ = height;
    dx_ = dx;
    dy_ = dy;
    data_.assign(width_ * height_, Value(0.0f, 0.0f));
}
 
void ComplexField2D::clear() noexcept
{
    std::fill(data_.begin(), data_.end(), Value(0.0f, 0.0f));
}
 
void ComplexField2D::fill(const Value &value)
{
    std::fill(data_.begin(), data_.end(), value);
}
 
bool ComplexField2D::empty() const noexcept
{
    return data_.empty();
}
 
std::size_t ComplexField2D::width() const noexcept
{
    return width_;
}
 
std::size_t ComplexField2D::height() const noexcept
{
    return height_;
}
 
std::size_t ComplexField2D::size() const noexcept
{
    return data_.size();
}
 
float ComplexField2D::dx() const noexcept
{
    return dx_;
}
 
float ComplexField2D::dy() const noexcept
{
    return dy_;
}
 
ComplexField2D::Value &ComplexField2D::operator()(std::size_t x, std::size_t y) noexcept
{
    return data_[index(x, y)];
}
 
const ComplexField2D::Value &ComplexField2D::operator()(std::size_t x, std::size_t y) const noexcept
{
    return data_[index(x, y)];
}
 
ComplexField2D::Value &ComplexField2D::at(std::size_t x, std::size_t y)
{
    return data_[checkedIndex(x, y)];
}
 
const ComplexField2D::Value &ComplexField2D::at(std::size_t x, std::size_t y) const
{
    return data_[checkedIndex(x, y)];
}
 
ComplexField2D::Value *ComplexField2D::data() noexcept
{
    return data_.data();
}
 
const ComplexField2D::Value *ComplexField2D::data() const noexcept
{
    return data_.data();
}
 
double ComplexField2D::sumAbs2() const noexcept
{
    double sum = 0.0;
    for (const Value &v : data_) {
        const double re = static_cast<double>(v.real());
        const double im = static_cast<double>(v.imag());
        sum += re * re + im * im;
    }
    return sum;
}
 
double ComplexField2D::norm2() const noexcept
{
    return sumAbs2() * static_cast<double>(dx_) * static_cast<double>(dy_);
}
 
double ComplexField2D::norm() const noexcept
{
    return std::sqrt(norm2());
}
 
bool ComplexField2D::normalize() noexcept
{
    const double n = norm();
    if (!(n > 0.0) || !std::isfinite(n)) {
        return false;
    }
 
    const float scale = static_cast<float>(1.0 / n);
    for (Value &v : data_) {
        v *= scale;
    }
    return true;
}
 
std::size_t ComplexField2D::index(std::size_t x, std::size_t y) const noexcept
{
    return y * width_ + x;
}
 
std::size_t ComplexField2D::checkedIndex(std::size_t x, std::size_t y) const
{
    if (x >= width_ || y >= height_) {
        throw std::out_of_range("ComplexField2D: coordinates outside field");
    }
    return index(x, y);
}
 
} // namespace qpe