Cartesian2d.h

Go to the documentation of this file.

 
#ifndef GMATTENSOR_CARTESIAN2D_H
#define GMATTENSOR_CARTESIAN2D_H
 
#include <xtensor/xadapt.hpp>
#include <xtensor/xnoalias.hpp>
#include <xtensor/xrandom.hpp>
#include <xtensor/xtensor.hpp>
#include <xtensor/xview.hpp>
 
#include "config.h"
#include "detail.hpp"
#include "version.h"
 
namespace GMatTensor {
 
namespace Cartesian2d {
 
inline array_type::tensor<double, 2> Random2();
 
inline array_type::tensor<double, 4> Random4();
 
inline array_type::tensor<double, 2> O2();
 
inline array_type::tensor<double, 4> O4();
 
inline array_type::tensor<double, 2> I2();
 
inline array_type::tensor<double, 4> II();
 
inline array_type::tensor<double, 4> I4();
 
inline array_type::tensor<double, 4> I4rt();
 
inline array_type::tensor<double, 4> I4s();
 
inline array_type::tensor<double, 4> I4d();
 
template <class T>
inline auto Trace(const T& A);
 
template <class T, class R>
inline void trace(const T& A, R& ret);
 
template <class T>
inline auto Hydrostatic(const T& A);
 
template <class T, class R>
inline void hydrostatic(const T& A, R& ret);
 
template <class T>
inline auto A2_ddot_B2(const T& A, const T& B);
 
template <class T, class R>
inline void A2_ddot_B2(const T& A, const T& B, R& ret);
 
template <class T>
inline auto A2s_ddot_B2s(const T& A, const T& B);
 
template <class T, class R>
inline void A2s_ddot_B2s(const T& A, const T& B, R& ret);
 
template <class T>
inline auto Norm_deviatoric(const T& A);
 
template <class T, class R>
inline void norm_deviatoric(const T& A, R& ret);
 
template <class T>
inline auto Deviatoric(const T& A);
 
template <class T, class R>
inline void deviatoric(const T& A, R& ret);
 
template <class T>
inline auto Sym(const T& A);
 
template <class T, class R>
inline void sym(const T& A, R& ret);
 
template <class T>
inline auto A2_dot_B2(const T& A, const T& B);
 
template <class T, class R>
inline void A2_dot_B2(const T& A, const T& B, R& ret);
 
template <class T>
inline auto A2_dyadic_B2(const T& A, const T& B);
 
template <class T, class R>
inline void A2_dyadic_B2(const T& A, const T& B, R& ret);
 
template <class T, class U>
inline auto A4_ddot_B2(const T& A, const U& B);
 
template <class T, class U, class R>
inline void A4_ddot_B2(const T& A, const U& B, R& ret);
 
template <class T>
inline size_t underlying_size_A2(const T& A)
{
    return detail::impl_A2<T, 2>::toSizeT0(A.shape());
}
 
template <class T>
inline size_t underlying_size_A4(const T& A)
{
    return detail::impl_A4<T, 2>::toSizeT0(A.shape());
}
 
template <class T>
inline auto underlying_shape_A2(const T& A) -> std::array<size_t, detail::impl_A2<T, 2>::rank>
{
    return detail::impl_A2<T, 2>::toShapeT0(A.shape());
}
 
template <class T>
inline auto underlying_shape_A4(const T& A) -> std::array<size_t, detail::impl_A4<T, 2>::rank>
{
    return detail::impl_A4<T, 2>::toShapeT0(A.shape());
}
 
template <size_t N>
class Array {
public:
    constexpr static std::size_t rank = N;
 
    Array() = default;
 
    Array(const std::array<size_t, N>& shape);
 
    const std::array<size_t, N>& shape() const;
 
    const std::array<size_t, N + 2>& shape_tensor2() const;
 
    const std::array<size_t, N + 4>& shape_tensor4() const;
 
    array_type::tensor<double, N + 2> O2() const;
 
    array_type::tensor<double, N + 4> O4() const;
 
    array_type::tensor<double, N + 2> I2() const;
 
    array_type::tensor<double, N + 4> II() const;
 
    array_type::tensor<double, N + 4> I4() const;
 
    array_type::tensor<double, N + 4> I4rt() const;
 
    array_type::tensor<double, N + 4> I4s() const;
 
    array_type::tensor<double, N + 4> I4d() const;
 
protected:
    void init(const std::array<size_t, N>& shape);
 
    static constexpr size_t m_ndim = 2;
 
    static constexpr size_t m_stride_tensor2 = 4;
 
    static constexpr size_t m_stride_tensor4 = 16;
 
    size_t m_size;
 
    std::array<size_t, N> m_shape;
 
    std::array<size_t, N + 2> m_shape_tensor2;
 
    std::array<size_t, N + 4> m_shape_tensor4;
};
 
namespace pointer {
 
template <class T>
inline void O2(T* ret);
 
template <class T>
inline void O4(T* ret);
 
template <class T>
inline void I2(T* ret);
 
template <class T>
inline void II(T* ret);
 
template <class T>
inline void I4(T* ret);
 
template <class T>
inline void I4rt(T* ret);
 
template <class T>
inline void I4s(T* ret);
 
template <class T>
inline void I4d(T* ret);
 
template <class T>
inline T Trace(const T* A);
 
template <class T>
inline T Hydrostatic(const T* A);
 
template <class T>
inline void sym(const T* A, T* ret);
 
template <class T>
inline T Hydrostatic_deviatoric(const T* A, T* ret);
 
template <class T>
inline T Deviatoric_ddot_deviatoric(const T* A);
 
template <class T>
inline T Norm_deviatoric(const T* A);
 
template <class T>
inline T A2_ddot_B2(const T* A, const T* B);
 
template <class T>
inline T A2s_ddot_B2s(const T* A, const T* B);
 
template <class T>
inline void A2_dyadic_B2(const T* A, const T* B, T* ret);
 
template <class T>
inline void A2_dot_B2(const T* A, const T* B, T* ret);
 
template <class T>
inline void A4_ddot_B2(const T* A, const T* B, T* ret);
 
} // namespace pointer
 
} // namespace Cartesian2d
} // namespace GMatTensor
 
#include "Cartesian2d.hpp"
#include "Cartesian2d_Array.hpp"
 
#endif