ImathShear.h

//
// SPDX-License-Identifier: BSD-3-Clause
// Copyright Contributors to the OpenEXR Project.
//
 
//
// A representation of a shear transformation
//
 
#ifndef INCLUDED_ATOMSMATHSHEAR_H
#define INCLUDED_ATOMSMATHSHEAR_H
 
#include <AtomsMath/ImathMath.h>
#include <AtomsMath/ImathNamespace.h>
#include <AtomsMath/ImathVec.h>
#include <iostream>
 
ATOMSMATH_INTERNAL_NAMESPACE_HEADER_ENTER
 
 
template <class T> class Shear6
{
  public:
 
 
    T xy, xz, yz, yx, zx, zy;
 
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 T& operator[] (int i);
 
    ATOMSMATH_HOSTDEVICE constexpr const T& operator[] (int i) const;
 
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Shear6();
    
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Shear6 (T XY, T XZ, T YZ);
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Shear6 (const Vec3<T>& v);
 
    template <class S>
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Shear6 (const Vec3<S>& v);
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Shear6 (T XY,
                                               T XZ,
                                               T YZ,
                                               T YX,
                                               T ZX,
                                               T ZY);
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Shear6 (const Shear6& h);
 
    template <class S> ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Shear6 (const Shear6<S>& h);
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Shear6& operator= (const Shear6& h);
 
    template <class S>
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Shear6& operator= (const Vec3<S>& v);
 
    ~Shear6() = default;
 
    
 
    template <class S> ATOMSMATH_HOSTDEVICE void setValue (S XY, S XZ, S YZ, S YX, S ZX, S ZY);
 
    template <class S> ATOMSMATH_HOSTDEVICE void setValue (const Shear6<S>& h);
 
    template <class S>
    ATOMSMATH_HOSTDEVICE void getValue (S& XY, S& XZ, S& YZ, S& YX, S& ZX, S& ZY) const;
 
    template <class S> ATOMSMATH_HOSTDEVICE void getValue (Shear6<S>& h) const;
 
    ATOMSMATH_HOSTDEVICE T* getValue();
 
    ATOMSMATH_HOSTDEVICE const T* getValue() const;
 
 
    
    template <class S> ATOMSMATH_HOSTDEVICE constexpr bool operator== (const Shear6<S>& h) const;
 
    template <class S> ATOMSMATH_HOSTDEVICE constexpr bool operator!= (const Shear6<S>& h) const;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool equalWithAbsError (const Shear6<T>& h, T e) const;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool equalWithRelError (const Shear6<T>& h, T e) const;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Shear6& operator+= (const Shear6& h);
 
    ATOMSMATH_HOSTDEVICE constexpr Shear6 operator+ (const Shear6& h) const;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Shear6& operator-= (const Shear6& h);
 
    ATOMSMATH_HOSTDEVICE constexpr Shear6 operator- (const Shear6& h) const;
 
    ATOMSMATH_HOSTDEVICE constexpr Shear6 operator-() const;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Shear6& negate();
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Shear6& operator*= (const Shear6& h);
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Shear6& operator*= (T a);
 
    ATOMSMATH_HOSTDEVICE constexpr Shear6 operator* (const Shear6& h) const;
 
    ATOMSMATH_HOSTDEVICE constexpr Shear6 operator* (T a) const;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Shear6& operator/= (const Shear6& h);
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Shear6& operator/= (T a);
 
    ATOMSMATH_HOSTDEVICE constexpr Shear6 operator/ (const Shear6& h) const;
 
    ATOMSMATH_HOSTDEVICE constexpr Shear6 operator/ (T a) const;
 
    
    
    ATOMSMATH_HOSTDEVICE constexpr static T baseTypeLowest() noexcept { return std::numeric_limits<T>::lowest(); }
 
    ATOMSMATH_HOSTDEVICE constexpr static T baseTypeMax() noexcept { return std::numeric_limits<T>::max(); }
 
    ATOMSMATH_HOSTDEVICE constexpr static T baseTypeSmallest() noexcept { return std::numeric_limits<T>::min(); }
 
    ATOMSMATH_HOSTDEVICE constexpr static T baseTypeEpsilon() noexcept { return std::numeric_limits<T>::epsilon(); }
 
 
    ATOMSMATH_HOSTDEVICE constexpr static unsigned int dimensions() { return 6; }
 
    typedef T BaseType;
};
 
template <class T> std::ostream& operator<< (std::ostream& s, const Shear6<T>& h);
 
template <class S, class T>
ATOMSMATH_HOSTDEVICE constexpr Shear6<T> operator* (S a, const Shear6<T>& h);
 
typedef Vec3<float> Shear3f;
 
typedef Vec3<double> Shear3d;
 
typedef Shear6<float> Shear6f;
 
typedef Shear6<double> Shear6d;
 
//-----------------------
// Implementation of Shear6
//-----------------------
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline T&
Shear6<T>::operator[] (int i)
{
    return (&xy)[i]; // NOSONAR - suppress SonarCloud bug report.
}
 
template <class T>
constexpr inline const T&
Shear6<T>::operator[] (int i) const
{
    return (&xy)[i]; // NOSONAR - suppress SonarCloud bug report.
}
 
template <class T> ATOMSMATH_CONSTEXPR14 inline Shear6<T>::Shear6()
{
    xy = xz = yz = yx = zx = zy = 0;
}
 
template <class T> ATOMSMATH_CONSTEXPR14 inline Shear6<T>::Shear6 (T XY, T XZ, T YZ)
{
    xy = XY;
    xz = XZ;
    yz = YZ;
    yx = 0;
    zx = 0;
    zy = 0;
}
 
template <class T> ATOMSMATH_CONSTEXPR14 inline Shear6<T>::Shear6 (const Vec3<T>& v)
{
    xy = v.x;
    xz = v.y;
    yz = v.z;
    yx = 0;
    zx = 0;
    zy = 0;
}
 
template <class T> template <class S> ATOMSMATH_CONSTEXPR14 inline Shear6<T>::Shear6 (const Vec3<S>& v)
{
    xy = T (v.x);
    xz = T (v.y);
    yz = T (v.z);
    yx = 0;
    zx = 0;
    zy = 0;
}
 
template <class T> ATOMSMATH_CONSTEXPR14 inline Shear6<T>::Shear6 (T XY, T XZ, T YZ, T YX, T ZX, T ZY)
{
    xy = XY;
    xz = XZ;
    yz = YZ;
    yx = YX;
    zx = ZX;
    zy = ZY;
}
 
template <class T> ATOMSMATH_CONSTEXPR14 inline Shear6<T>::Shear6 (const Shear6& h)
{
    xy = h.xy;
    xz = h.xz;
    yz = h.yz;
    yx = h.yx;
    zx = h.zx;
    zy = h.zy;
}
 
template <class T>
template <class S>
ATOMSMATH_CONSTEXPR14 inline Shear6<T>::Shear6 (const Shear6<S>& h)
{
    xy = T (h.xy);
    xz = T (h.xz);
    yz = T (h.yz);
    yx = T (h.yx);
    zx = T (h.zx);
    zy = T (h.zy);
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Shear6<T>&
Shear6<T>::operator= (const Shear6& h)
{
    xy = h.xy;
    xz = h.xz;
    yz = h.yz;
    yx = h.yx;
    zx = h.zx;
    zy = h.zy;
    return *this;
}
 
template <class T>
template <class S>
ATOMSMATH_CONSTEXPR14 inline const Shear6<T>&
Shear6<T>::operator= (const Vec3<S>& v)
{
    xy = T (v.x);
    xz = T (v.y);
    yz = T (v.z);
    yx = 0;
    zx = 0;
    zy = 0;
    return *this;
}
 
template <class T>
template <class S>
inline void
Shear6<T>::setValue (S XY, S XZ, S YZ, S YX, S ZX, S ZY)
{
    xy = T (XY);
    xz = T (XZ);
    yz = T (YZ);
    yx = T (YX);
    zx = T (ZX);
    zy = T (ZY);
}
 
template <class T>
template <class S>
inline void
Shear6<T>::setValue (const Shear6<S>& h)
{
    xy = T (h.xy);
    xz = T (h.xz);
    yz = T (h.yz);
    yx = T (h.yx);
    zx = T (h.zx);
    zy = T (h.zy);
}
 
template <class T>
template <class S>
inline void
Shear6<T>::getValue (S& XY, S& XZ, S& YZ, S& YX, S& ZX, S& ZY) const
{
    XY = S (xy);
    XZ = S (xz);
    YZ = S (yz);
    YX = S (yx);
    ZX = S (zx);
    ZY = S (zy);
}
 
template <class T>
template <class S>
inline void
Shear6<T>::getValue (Shear6<S>& h) const
{
    h.xy = S (xy);
    h.xz = S (xz);
    h.yz = S (yz);
    h.yx = S (yx);
    h.zx = S (zx);
    h.zy = S (zy);
}
 
template <class T>
inline T*
Shear6<T>::getValue()
{
    return (T*) &xy;
}
 
template <class T>
inline const T*
Shear6<T>::getValue() const
{
    return (const T*) &xy;
}
 
template <class T>
template <class S>
constexpr inline bool
Shear6<T>::operator== (const Shear6<S>& h) const
{
    return xy == h.xy && xz == h.xz && yz == h.yz && yx == h.yx && zx == h.zx && zy == h.zy;
}
 
template <class T>
template <class S>
constexpr inline bool
Shear6<T>::operator!= (const Shear6<S>& h) const
{
    return xy != h.xy || xz != h.xz || yz != h.yz || yx != h.yx || zx != h.zx || zy != h.zy;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline bool
Shear6<T>::equalWithAbsError (const Shear6<T>& h, T e) const
{
    for (int i = 0; i < 6; i++)
        if (!ATOMSMATH_INTERNAL_NAMESPACE::equalWithAbsError ((*this)[i], h[i], e))
            return false;
 
    return true;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline bool
Shear6<T>::equalWithRelError (const Shear6<T>& h, T e) const
{
    for (int i = 0; i < 6; i++)
        if (!ATOMSMATH_INTERNAL_NAMESPACE::equalWithRelError ((*this)[i], h[i], e))
            return false;
 
    return true;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Shear6<T>&
Shear6<T>::operator+= (const Shear6& h)
{
    xy += h.xy;
    xz += h.xz;
    yz += h.yz;
    yx += h.yx;
    zx += h.zx;
    zy += h.zy;
    return *this;
}
 
template <class T>
constexpr inline Shear6<T>
Shear6<T>::operator+ (const Shear6& h) const
{
    return Shear6 (xy + h.xy, xz + h.xz, yz + h.yz, yx + h.yx, zx + h.zx, zy + h.zy);
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Shear6<T>&
Shear6<T>::operator-= (const Shear6& h)
{
    xy -= h.xy;
    xz -= h.xz;
    yz -= h.yz;
    yx -= h.yx;
    zx -= h.zx;
    zy -= h.zy;
    return *this;
}
 
template <class T>
constexpr inline Shear6<T>
Shear6<T>::operator- (const Shear6& h) const
{
    return Shear6 (xy - h.xy, xz - h.xz, yz - h.yz, yx - h.yx, zx - h.zx, zy - h.zy);
}
 
template <class T>
constexpr inline Shear6<T>
Shear6<T>::operator-() const
{
    return Shear6 (-xy, -xz, -yz, -yx, -zx, -zy);
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Shear6<T>&
Shear6<T>::negate()
{
    xy = -xy;
    xz = -xz;
    yz = -yz;
    yx = -yx;
    zx = -zx;
    zy = -zy;
    return *this;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Shear6<T>&
Shear6<T>::operator*= (const Shear6& h)
{
    xy *= h.xy;
    xz *= h.xz;
    yz *= h.yz;
    yx *= h.yx;
    zx *= h.zx;
    zy *= h.zy;
    return *this;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Shear6<T>&
Shear6<T>::operator*= (T a)
{
    xy *= a;
    xz *= a;
    yz *= a;
    yx *= a;
    zx *= a;
    zy *= a;
    return *this;
}
 
template <class T>
constexpr inline Shear6<T>
Shear6<T>::operator* (const Shear6& h) const
{
    return Shear6 (xy * h.xy, xz * h.xz, yz * h.yz, yx * h.yx, zx * h.zx, zy * h.zy);
}
 
template <class T>
constexpr inline Shear6<T>
Shear6<T>::operator* (T a) const
{
    return Shear6 (xy * a, xz * a, yz * a, yx * a, zx * a, zy * a);
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Shear6<T>&
Shear6<T>::operator/= (const Shear6& h)
{
    xy /= h.xy;
    xz /= h.xz;
    yz /= h.yz;
    yx /= h.yx;
    zx /= h.zx;
    zy /= h.zy;
    return *this;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Shear6<T>&
Shear6<T>::operator/= (T a)
{
    xy /= a;
    xz /= a;
    yz /= a;
    yx /= a;
    zx /= a;
    zy /= a;
    return *this;
}
 
template <class T>
constexpr inline Shear6<T>
Shear6<T>::operator/ (const Shear6& h) const
{
    return Shear6 (xy / h.xy, xz / h.xz, yz / h.yz, yx / h.yx, zx / h.zx, zy / h.zy);
}
 
template <class T>
constexpr inline Shear6<T>
Shear6<T>::operator/ (T a) const
{
    return Shear6 (xy / a, xz / a, yz / a, yx / a, zx / a, zy / a);
}
 
//-----------------------------
// Stream output implementation
//-----------------------------
 
template <class T>
std::ostream&
operator<< (std::ostream& s, const Shear6<T>& h)
{
    return s << '(' << h.xy << ' ' << h.xz << ' ' << h.yz << h.yx << ' ' << h.zx << ' ' << h.zy
             << ')';
}
 
//-----------------------------------------
// Implementation of reverse multiplication
//-----------------------------------------
 
template <class S, class T>
constexpr inline Shear6<T>
operator* (S a, const Shear6<T>& h)
{
    return Shear6<T> (a * h.xy, a * h.xz, a * h.yz, a * h.yx, a * h.zx, a * h.zy);
}
 
ATOMSMATH_INTERNAL_NAMESPACE_HEADER_EXIT
 
#endif // INCLUDED_ATOMSMATHSHEAR_H