Matrix2f.cpp

#include "Matrix2f.h"

#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>

#include "Vector2f.h"

Matrix2f::Matrix2f( float fill )
{
    for( int i = 0; i < 4; ++i )
    {
        m_elements[ i ] = fill;
    }
}

Matrix2f::Matrix2f( float m00, float m01,
                    float m10, float m11 )
{
    m_elements[ 0 ] = m00;
    m_elements[ 1 ] = m10;

    m_elements[ 2 ] = m01;
    m_elements[ 3 ] = m11;
}

Matrix2f::Matrix2f( const Vector2f& v0, const Vector2f& v1, bool setColumns )
{
    if( setColumns )
    {
        setCol( 0, v0 );
        setCol( 1, v1 );
    }
    else
    {
        setRow( 0, v0 );
        setRow( 1, v1 );
    }
}

Matrix2f::Matrix2f( const Matrix2f& rm )
{
    memcpy( m_elements, rm.m_elements, 2 * sizeof( float ) );
}

Matrix2f& Matrix2f::operator = ( const Matrix2f& rm )
{
    if( this != &rm )
    {
        memcpy( m_elements, rm.m_elements, 2 * sizeof( float ) );
    }
    return *this;
}

const float& Matrix2f::operator () ( int i, int j ) const
{
    return m_elements[ j * 2 + i ];
}

float& Matrix2f::operator () ( int i, int j )
{
    return m_elements[ j * 2 + i ];
}

Vector2f Matrix2f::getRow( int i ) const
{
    return Vector2f
           (
               m_elements[ i ],
               m_elements[ i + 2 ]
           );
}

void Matrix2f::setRow( int i, const Vector2f& v )
{
    m_elements[ i ] = v.x();
    m_elements[ i + 2 ] = v.y();
}

Vector2f Matrix2f::getCol( int j ) const
{
    int colStart = 2 * j;

    return Vector2f
           (
               m_elements[ colStart ],
               m_elements[ colStart + 1 ]
           );
}

void Matrix2f::setCol( int j, const Vector2f& v )
{
    int colStart = 2 * j;

    m_elements[ colStart ] = v.x();
    m_elements[ colStart + 1 ] = v.y();
}

float Matrix2f::determinant()
{
    return Matrix2f::determinant2x2(
        m_elements[ 0 ], m_elements[ 2 ],
        m_elements[ 1 ], m_elements[ 3 ]
    );
}

Matrix2f Matrix2f::inverse( bool* pbIsSingular, float epsilon )
{
    float determinant = m_elements[ 0 ] * m_elements[ 3 ] - m_elements[ 2 ] * m_elements[ 1 ];

    bool isSingular = ( fabs( determinant ) < epsilon );
    if( isSingular )
    {
        if( pbIsSingular != NULL )
        {
            *pbIsSingular = true;
        }
        return Matrix2f();
    }
    else
    {
        if( pbIsSingular != NULL )
        {
            *pbIsSingular = false;
        }

        float reciprocalDeterminant = 1.0f / determinant;

        return Matrix2f(
             m_elements[ 3 ] * reciprocalDeterminant, -m_elements[ 2 ] * reciprocalDeterminant,
            -m_elements[ 1 ] * reciprocalDeterminant,  m_elements[ 0 ] * reciprocalDeterminant
        );
    }
}

void Matrix2f::transpose()
{
    float m01 = ( *this )( 0, 1 );
    float m10 = ( *this )( 1, 0 );

    ( *this )( 0, 1 ) = m10;
    ( *this )( 1, 0 ) = m01;
}

Matrix2f Matrix2f::transposed() const
{
    return Matrix2f(
        ( *this )( 0, 0 ), ( *this )( 1, 0 ),
        ( *this )( 0, 1 ), ( *this )( 1, 1 )
    );
}

const float *Matrix2f::getElements() const
{
    return m_elements;
}

void Matrix2f::print() const
{
    printf( "[ %.4f %.4f ]\n[ %.4f %.4f ]\n",
            m_elements[ 0 ], m_elements[ 2 ],
            m_elements[ 1 ], m_elements[ 3 ] );
}

// static
float Matrix2f::determinant2x2( float m00, float m01,
                                float m10, float m11 )
{
    return( m00 * m11 - m01 * m10 );
}

// static
Matrix2f Matrix2f::ones()
{
    Matrix2f m;
    for( int i = 0; i < 4; ++i )
    {
        m.m_elements[ i ] = 1;
    }
    return m;
}

// static
Matrix2f Matrix2f::identity()
{
    Matrix2f m;

    m( 0, 0 ) = 1;
    m( 1, 1 ) = 1;

    return m;
}

// static
Matrix2f Matrix2f::rotation( float degrees )
{
    float c = cos( degrees );
    float s = sin( degrees );

    return Matrix2f(
        c, -s,
        s, c
    );
}

//////////////////////////////////////////////////////////////////////////
// Operators
//////////////////////////////////////////////////////////////////////////

Matrix2f operator * ( float f, const Matrix2f& m )
{
    Matrix2f output;

    for( int i = 0; i < 2; ++i )
    {
        for( int j = 0; j < 2; ++j )
        {
            output( i, j ) = f * m( i, j );
        }
    }

    return output;
}

Matrix2f operator * ( const Matrix2f& m, float f )
{
    return f * m;
}

Vector2f operator * ( const Matrix2f& m, const Vector2f& v )
{
    Vector2f output( 0, 0 );

    for( int i = 0; i < 2; ++i )
    {
        for( int j = 0; j < 2; ++j )
        {
            output[ i ] += m( i, j ) * v[ j ];
        }
    }

    return output;
}

Matrix2f operator * ( const Matrix2f& x, const Matrix2f& y )
{
    Matrix2f product; // zeroes

    for( int i = 0; i < 2; ++i )
    {
        for( int j = 0; j < 2; ++j )
        {
            for( int k = 0; k < 2; ++k )
            {
                product( i, k ) += x( i, j ) * y( j, k );
            }
        }
    }

    return product;
}