tensor2.hpp

Go to the documentation of this file.

/*
 * This file is part of PLaSK (https://plask.app) by Photonics Group at TUL
 * Copyright (c) 2022 Lodz University of Technology
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */
#ifndef PLASK__TESNOR2_H
#define PLASK__TESNOR2_H
 
#include <boost/concept_check.hpp>
#include <iostream>
 
#include "../math.hpp"
#include "2d.hpp"
 
namespace plask {
 
template <typename T> struct Tensor2 {
    T c00,    
        c11;  
 
    T& tran() { return c00; }
    const T& tran() const { return c00; }
 
    T& vert() { return c11; }
    const T& vert() const { return c11; }
 
    Tensor2() {}
 
    template <typename OtherT> Tensor2(const Tensor2<OtherT>& p) : c00(p.c00), c11(p.c11) {}
 
    Tensor2(const T& val) : c00(val), c11(val) {}
 
    Tensor2(const T& c00, const T& c11) : c00(c00), c11(c11) {}
 
    template <typename T0, typename T1> Tensor2(const std::pair<T0, T1>& comp) : c00(comp.first), c11(comp.second) {}
 
    Tensor2(const Vec<2, T>& vec) : c00(vec.c0), c11(vec.c1) {}
 
    inline T& operator[](size_t i) {
        assert(i < 2);
        return *(&c00 + i);
    }
 
    inline const T& operator[](size_t i) const {
        assert(i < 2);
        return *(&c00 + i);
    }
 
    operator std::tuple<T, T>() const { return std::make_tuple(c00, c11); }
 
    template <typename OtherT> bool operator==(const Tensor2<OtherT>& p) const { return p.c00 == c00 && p.c11 == c11; }
 
    template <typename OtherT> constexpr bool equals(const Tensor2<OtherT>& p) const {
        return is_zero(p.c00 - c00) && is_zero(p.c11 - c11);
    }
 
    template <typename OtherT> bool operator!=(const Tensor2<OtherT>& p) const { return p.c00 != c00 || p.c11 != c11; }
 
    template <typename OtherT> auto operator+(const Tensor2<OtherT>& other) const -> Tensor2<decltype(c00 + other.c00)> {
        return Tensor2<decltype(this->c00 + other.c00)>(c00 + other.c00, c11 + other.c11);
    }
 
    Tensor2<T>& operator+=(const Tensor2<T>& other) {
        c00 += other.c00;
        c11 += other.c11;
        return *this;
    }
 
    template <typename OtherT> auto operator-(const Tensor2<OtherT>& other) const -> Tensor2<decltype(c00 - other.c00)> {
        return Tensor2<decltype(this->c00 - other.c00)>(c00 - other.c00, c11 - other.c11);
    }
 
    Tensor2<T>& operator-=(const Tensor2<T>& other) {
        c00 -= other.c00;
        c11 -= other.c11;
        return *this;
    }
 
    template <typename OtherT> auto operator*(const OtherT scale) const -> Tensor2<decltype(c00 * scale)> {
        return Tensor2<decltype(c00 * scale)>(c00 * scale, c11 * scale);
    }
 
    Tensor2<T>& operator*=(const T scalar) {
        c00 *= scalar;
        c11 *= scalar;
        return *this;
    }
 
    Tensor2<T> operator/(const T scale) const { return Tensor2<T>(c00 / scale, c11 / scale); }
 
    Tensor2<T>& operator/=(const T scalar) {
        c00 /= scalar;
        c11 /= scalar;
        return *this;
    }
 
    Tensor2<T> operator-() const { return Tensor2<T>(-c00, -c11); }
 
    // /**
    //  * Square each component of tensor
    //  * \return squared tensor
    //  */
    // Tensor2<T> sqr() const {
    //     return Tensor2<T>(c00*c00, c11*c11);
    // }
 
    // /**
    //  * Square each component of tensor in place
    //  * \return *this (squared)
    //  */
    // Tensor2<T>& sqr_inplace() {
    //     c00 *= c00; c11 *= c11;
    //     return *this;
    // }
 
    // /**
    //  * Square root of each component of tensor
    //  * \return squared tensor
    //  */
    // Tensor2<T> sqrt() const {
    //     return Tensor2<T>(std::sqrt(c00), std::sqrt(c11));
    // }
 
    // /**
    //  * Square root of each component of tensor in place
    //  * \return *this (squared)
    //  */
    // Tensor2<T>& sqrt_inplace() {
    //     c00 = std::sqrt(c00); c11 = std::sqrt(c11);
    //     return *this;
    // }
 
    Tensor2<T> pow(double a) const { return Tensor2<T>(std::pow(c00, a), std::pow(c11, a)); }
 
    friend inline std::ostream& operator<<(std::ostream& out, const Tensor2<T>& to_print) {
        return out << '(' << str(to_print.c00) << ", " << str(to_print.c11) << ')';
    }
};
 
template <typename T, typename OtherT> auto operator*(const OtherT scale, const Tensor2<T>& tensor) -> decltype(tensor * scale) {
    return tensor * scale;
}
 
template <typename T> inline Tensor2<T> conj(const Tensor2<T>& v) { return Tensor2<T>(conj(v.c00), conj(v.c11)); }
 
template <typename T> struct NaNImpl<Tensor2<T>> {
    static constexpr Tensor2<T> get() { return Tensor2<T>(NaN<T>()); }
};
 
template <typename T> struct ZeroImpl<Tensor2<T>> {
    static constexpr Tensor2<T> get() { return Tensor2<T>(0.); }
};
 
template <typename T> inline bool is_zero(const Tensor2<T>& v) { return is_zero(v.c00) && is_zero(v.c11); }
 
/*
PLASK_API_EXTERN_TEMPLATE_STRUCT(Tensor2<double>)
PLASK_API_EXTERN_TEMPLATE_STRUCT(Tensor2< std::complex<double> >)
*/
 
}  // namespace plask
 
namespace std {
 
template <typename T> plask::Tensor2<T> sqrt(plask::Tensor2<T> tens) { return tens.sqrt(); }
 
template <typename T, typename OtherT> plask::Tensor2<T> pow(plask::Tensor2<T> tens, OtherT a) { return tens.pow(a); }
 
template <typename T> inline bool isnan(plask::Tensor2<T> tens) { return isnan(tens.c00) || isnan(tens.c11); }
 
}  // namespace std
 
#endif  // PLASK__TESNOR2_H