Class Matrix2

source/MRMesh/MRMatrix2.h:20–132

/// \ingroup MatrixGroup
template <typename T>
struct Matrix2
{
    using ValueType = T;
    using VectorType = Vector2<T>;

    /// rows, identity matrix by default
    Vector2<T> x{ 1, 0 };
    Vector2<T> y{ 0, 1 };

    constexpr Matrix2() noexcept
    {
        static_assert( sizeof( Matrix2<ValueType> ) == 2 * sizeof( VectorType ), "Struct size invalid" );
    }
    /// initializes matrix from its 2 rows
    constexpr Matrix2( const Vector2<T> & x, const Vector2<T> & y ) : x( x ), y( y ) { }
    template <typename U>
    constexpr explicit Matrix2( const Matrix2<U> & m ) : x( m.x ), y( m.y ) { }
    static constexpr Matrix2 zero() noexcept { return Matrix2( Vector2<T>(), Vector2<T>() ); }
    static constexpr Matrix2 identity() noexcept { return Matrix2(); }
    /// returns a matrix that scales uniformly
    static constexpr Matrix2 scale( T s ) noexcept { return Matrix2( { s, T(0) }, { T(0), s } ); }
    /// returns a matrix that has its own scale along each axis
    static constexpr Matrix2 scale( T sx, T sy ) noexcept { return Matrix2( { sx, T(0) }, { T(0), sy } ); }
    static constexpr Matrix2 scale( const Vector2<T> & s ) noexcept { return Matrix2( { s.x, T(0) }, { T(0), s.y } ); }
    /// creates matrix representing rotation around origin on given angle
    static constexpr Matrix2 rotation( T angle ) noexcept MR_REQUIRES_IF_SUPPORTED( std::is_floating_point_v<T> );
    /// creates matrix representing rotation that after application to (from) makes (to) vector
    static constexpr Matrix2 rotation( const Vector2<T> & from, const Vector2<T> & to ) noexcept MR_REQUIRES_IF_SUPPORTED( std::is_floating_point_v<T> );
    /// constructs a matrix from its 2 rows
    static constexpr Matrix2 fromRows( const Vector2<T> & x, const Vector2<T> & y ) noexcept { return Matrix2( x, y ); }
    /// constructs a matrix from its 2 columns;
    /// use this method to get the matrix that transforms basis vectors ( plusX, plusY ) into vectors ( x, y ) respectively
    static constexpr Matrix2 fromColumns( const Vector2<T> & x, const Vector2<T> & y ) noexcept { return Matrix2( x, y ).transposed(); }

    /// row access
    constexpr const Vector2<T> & operator []( int row ) const noexcept { return *( ( VectorType* )this + row ); }
    constexpr       Vector2<T> & operator []( int row )       noexcept { return *( ( VectorType* )this + row ); }

    /// column access
    constexpr Vector2<T> col( int i ) const noexcept { return { x[i], y[i] }; }

    /// computes trace of the matrix
    constexpr T trace() const noexcept { return x.x + y.y; }
    /// compute sum of squared matrix elements
    constexpr T normSq() const noexcept { return x.lengthSq() + y.lengthSq(); }
    constexpr auto norm() const noexcept
    {
        // Calling `sqrt` this way to hopefully support boost.multiprecision numbers.
        // Returning `auto` to not break on integral types.
        using std::sqrt;
        return sqrt( normSq() );
    }
    /// computes determinant of the matrix
    constexpr T det() const noexcept;
    /// computes inverse matrix
    constexpr Matrix2<T> inverse() const noexcept MR_REQUIRES_IF_SUPPORTED( std::is_floating_point_v<T> );
    /// computes transposed matrix
    constexpr Matrix2<T> transposed() const noexcept;