src/halfmatrix.h

/*****************************************************************************
* This file is provided under the Creative Commons Attribution 3.0 license.
*
* You are free to share, copy, distribute, transmit, or adapt this work
* PROVIDED THAT you attribute the work to the authors listed below.
* For more information, please see the following web page:
* http://creativecommons.org/licenses/by/3.0/
*
* This file is a component of the Sleipnir library for functional genomics,
* authored by:
* Curtis Huttenhower (chuttenh@princeton.edu)
* Mark Schroeder
* Maria D. Chikina
* Olga G. Troyanskaya (ogt@princeton.edu, primary contact)
*
* If you use this library, the included executable tools, or any related
* code in your work, please cite the following publication:
* Curtis Huttenhower, Mark Schroeder, Maria D. Chikina, and
* Olga G. Troyanskaya.
* "The Sleipnir library for computational functional genomics"
*****************************************************************************/
#ifndef HALFMATRIX_H
#define HALFMATRIX_H

#include <string.h>

#include "halfmatrixi.h"
#include "meta.h"

namespace Sleipnir {

template<class tType>
class CHalfMatrix : protected CHalfMatrixBase {
public:
    static size_t GetSpace( size_t iSize ) {

        return ( ( ( iSize * ( iSize - 1 ) ) / 2 ) * sizeof(tType) ); }

    CHalfMatrix( ) : m_aaData(NULL) { }

    virtual ~CHalfMatrix( ) {

        Reset( ); }

    void Reset( ) {
        size_t  i;

        if( m_aaData && m_fMemory ) {
            for( i = 0; ( i + 1 ) < m_iSize; ++i )
                delete[] m_aaData[ i ];
            delete[] m_aaData; }

        m_iSize = 0;
        m_aaData = NULL; }

    tType* GetFullRow( size_t iY ) {
        size_t i, j;
        tType *newData = new tType[m_iSize];
        for(i=0; i<m_iSize; i++){
            if(i==iY){
                newData[i] = 0;
            }else if(i<iY){
                newData[i] = m_aaData[i][iY-i-1];
            }else{
                for(j=i; j<m_iSize; j++){
                    newData[j] = m_aaData[iY][j-iY-1];
                }
                break;
            }
        }
        return newData;
    }

    const tType* Get( size_t iY ) const {

        return m_aaData[ iY ]; }

    tType* Get( size_t iY ) {

        return m_aaData[ iY ]; }

    tType& Get( size_t iY, size_t iX ) const {
        static tType    c_Zero  = 0;

        if( iX == iY )
            return c_Zero;

        HalfIndex( iY, iX );
        return m_aaData[ iY ][ iX ]; }

    void Set( size_t iY, size_t iX, const tType& Value ) {

        if( iX == iY )
            return;

        HalfIndex( iY, iX );
        m_aaData[ iY ][ iX ] = Value; }

    void Set( size_t iY, const tType* aValues ) {

        memcpy( m_aaData[ iY ], aValues, sizeof(*m_aaData[ iY ]) * ( m_iSize - iY - 1 ) ); }

    void Initialize( const CHalfMatrix& Mat ) {

        Initialize( Mat.GetSize( ), Mat.m_aaData ); }

    virtual void Initialize( size_t iSize, tType** aaData = NULL ) {
        size_t  i;

        Reset( );
        m_iSize = iSize;
        if( m_fMemory = !( m_aaData = aaData ) ) {
            m_aaData = iSize ? new tType*[ m_iSize - 1 ] : NULL;
            for( i = 0; ( i + 1 ) < m_iSize; ++i )
                m_aaData[ i ] = new tType[ m_iSize - i - 1 ]; } }

    size_t GetSize( ) const {

        return m_iSize; }

    bool SetSize( size_t iSize, bool fClear = false ) {
        tType** aaData;
        size_t  i, iCur;

        if( !m_fMemory )
            return false;
        if( !iSize ) {
            Reset( );
            return true; }

        aaData = new tType*[iSize - 1];
        for( i = 0; ( i + 1 ) < iSize; ++i ) {
            aaData[i] = new tType[iCur = ( iSize - i - 1 )];
            if( i < m_iSize )
                memcpy( aaData[i], m_aaData[i], ( min( iSize, m_iSize ) - i - 1 ) * sizeof(*aaData[i]) );
            if( fClear && ( iSize > m_iSize ) )
                std::fill( aaData[i] + ( ( i < m_iSize ) ? ( m_iSize - i - 1 ) : 0 ), aaData[i] + iCur, CMeta::GetNaN( ) ); }
        Reset( );
        m_iSize = iSize;
        m_aaData = aaData;

        return true; }

    void Clear( ) {
        size_t  i;

        for( i = 0; ( i + 1 ) < m_iSize; ++i )
            memset( m_aaData[ i ], 0, ( m_iSize - i - 1 ) * sizeof(*m_aaData[ i ]) ); }

    bool Save( std::ostream& ostm, bool fBinary, char cSeparator = '\t' ) const {

        return ( fBinary ? SaveBinary( ostm ) : SaveText( ostm, cSeparator ) ); }

protected:

    bool SaveBinary( std::ostream& ostm ) const {
        size_t      i;
        uint32_t    iSize;

        iSize = (uint32_t)GetSize( );
        ostm.write( (const char*)&iSize, sizeof(iSize) );
        for( i = 0; i < GetSize( ); ++i )
            ostm.write( (const char*)Get( i ), (std::streamsize)( sizeof(*Get( i )) *
                ( GetSize( ) - i - 1 ) ) );

        return true; }

    bool SaveText( std::ostream& ostm, char cSeparator ) const {
        size_t  i, j;

        if( !GetSize( ) )
            return false;

        for( i = 0; ( i + 1 ) < GetSize( ); ++i ) {
            for( j = 0; j <= i; ++j )
                ostm << cSeparator;
            ostm << Get( i, j++ );
            for( ; j < GetSize( ); ++j )
                ostm << cSeparator << Get( i, j );
            ostm << std::endl; }

        return true; }

    bool    m_fMemory;
    tType** m_aaData;
};

typedef CHalfMatrix<float>  CDistanceMatrix;

class CBinaryMatrix : public CHalfMatrix<unsigned char> {
public:
    bool Get( size_t iY, size_t iX ) const {

        if( iX == iY )
            return false;
        HalfIndex( iY, iX );
        return ( ( m_aaData[ iY ][ iX / 8 ] >> ( iX % 8 ) ) & 1 ); }

    void Set( size_t iY, size_t iX, bool fValue ) {
        unsigned char   c;

        if( iX == iY )
            return;
        HalfIndex( iY, iX );
        c = 1 << (unsigned char)( iX % 8 );
        m_aaData[ iY ][ iX / 8 ] = ( m_aaData[ iY ][ iX / 8 ] & ~c ) | ( fValue ? c : 0 ); }

    void Initialize( size_t iSize, bool fClear = false, unsigned char** aabData = NULL ) {
        size_t  i, iCount;

        Reset( );
        m_iSize = iSize;
        if( m_fMemory = !( m_aaData = aabData ) ) {
            m_aaData = new unsigned char*[ m_iSize - 1 ];
            for( i = 0; ( i + 1 ) < m_iSize; ++i ) {
                m_aaData[ i ] = new unsigned char[ iCount = ( ( ( m_iSize - i - 1 ) / 8 ) + 1 ) ];
                if( fClear )
                    memset( m_aaData[ i ], 0, iCount * sizeof(*m_aaData[ i ]) ); } } }
};

}

#endif // HALFMATRIX_H