TAPsDatabaseDowkerNotation.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsDatabaseDowkerNotation.cpp


SUKITTI PUNAK   (04/25/2008)
UPDATE          (12/09/2010)
******************************************************************************/
#include "TAPsDatabaseDowkerNotation.hpp"
// Using Inclusion Model (i.e. definitions are included in declarations)
//                       (this name.cpp is included in name.hpp)
// Each friend is defined directly inside its declaration.

BEGIN_NAMESPACE_TAPs__Data
//=============================================================================
// Static Data Members
//-----------------------------------------------------------------------------
const unsigned int  DatabaseDowkerNotation::LIST_SIZE       = 8 + 4 + 8;
// -8 for the number of "fixing/forming the knot shape" that don't need to be checked
const unsigned int  DatabaseDowkerNotation::DATA_LIST_SIZE  = DatabaseDowkerNotation::LIST_SIZE - 8;
// +1 for undefined
const std::string   DatabaseDowkerNotation::KnotNames[LIST_SIZE + 1] = {
    "Single", "Single", "Double", "Double",
    "Square", "Square", "Surgeon's", "Surgeon's",

    "Single",   // HalfNeg_WithA_CrossNeg
    "Single",   // HalfNeg_WithA_CrossPos
    "Single",   // HalfPos_WithA_CrossNeg
    "Single",   // HalfPos_WithA_CrossPos

    // For fixing/forming the knot shape
    "Granny",
    "Square",
    "Square",
    "Granny",
    "Granny Surgeon's",
    "Surgeon's",
    "Surgeon's",
    "Granny Surgeon's",

    "Undefined"
};
const int   DatabaseDowkerNotation::HalfNeg[]   = { 3,  -4,-6,-2,   0 };
const int   DatabaseDowkerNotation::HalfPos[]   = { 3,   4, 6, 2,   1 };
const int   DatabaseDowkerNotation::DoubleNeg[] = { 5,  -6,-8,-10,-2,-4,   2 };
const int   DatabaseDowkerNotation::DoublePos[] = { 5,   6, 8, 10, 2, 4,   3 };
const int   DatabaseDowkerNotation::SquareNeg[] = { 6,  -10,-12, 8, 4, 6,-2,   4 };
const int   DatabaseDowkerNotation::SquarePos[] = { 6,   10, 12,-8,-4,-6, 2,   5 };
const int   DatabaseDowkerNotation::SurgeonsKnotNeg[]   = { 8,  -14,-16, 10, 12, 4, 6, 8,-2,   6 };
const int   DatabaseDowkerNotation::SurgeonsKnotPos[]   = { 8,   14, 16,-10,-12,-4,-6,-8, 2,   7 };

const int   DatabaseDowkerNotation::HalfNeg_WithA_CrossNeg[]    = { 4,  -6,-8,-4,-2,   8 };
const int   DatabaseDowkerNotation::HalfPos_WithA_CrossNeg[]    = { 4,   6, 8,-4, 2,   9 };
const int   DatabaseDowkerNotation::HalfNeg_WithA_CrossPos[]    = { 4,  -6,-8, 4,-2,   10 };
const int   DatabaseDowkerNotation::HalfPos_WithA_CrossPos[]    = { 4,   6, 8, 4, 2,   11 };

const int   DatabaseDowkerNotation::UndefinedData[] = { 0 };

// +1 for undefined
int const * const DatabaseDowkerNotation::EntryAccess[DATA_LIST_SIZE + 1] = {
        HalfNeg,            HalfPos, 
        DoubleNeg,          DoublePos, 
        SquareNeg,          SquarePos, 
        SurgeonsKnotNeg,    SurgeonsKnotPos,

        // A single knot with extra cross
        HalfNeg_WithA_CrossNeg,
        HalfNeg_WithA_CrossPos,
        HalfPos_WithA_CrossNeg,
        HalfPos_WithA_CrossPos,

        UndefinedData
};

//-----------------------------------------------------------------------------
//=============================================================================

//=============================================================================
//-----------------------------------------------------------------------------
// Return a string of the Dowker notation of the entry number (knot id) argument.
std::string DatabaseDowkerNotation::GetStrEntry ( unsigned int i )
{
    if ( i >= LIST_SIZE ) return "Undefined Knot";

    // Include the Dowker notation in the return string
    //if ( true ) {
    if ( false ) {
        if ( i < DATA_LIST_SIZE ) {
            char val[16];
            std::string str( "Dowker: " );
            str += "#";
            str += _itoa( EntryAccess[i][0], val, 10 );     // number of crossing pairs
            str += " --";
            int n = 1;
            for ( ; n <= EntryAccess[i][0]; ++n ) {
                str += " ";
                str += _itoa( EntryAccess[i][n], val, 10 );
            }
            str += " -- " + KnotNames[ EntryAccess[i][n] ] + " Knot";
            return str;
        }
    }
    else {
        return KnotNames[ EntryAccess[i][EntryAccess[i][0]+1] ] + " Knot";
    }
} // EOF: StrEntry (...)
//-----------------------------------------------------------------------------
// Find the knot with the given Dowker notation
int DatabaseDowkerNotation::FindKnotOfDowkerNotation ( 
        unsigned int numPairs, int * dowkerNotation, 
        std::string * knotName                       
)
{
    // Traverse the Dowker notation database
    for ( unsigned int i = 0; i < DATA_LIST_SIZE; ++i ) {
        // Match the size
        if ( numPairs == EntryAccess[i][0] ) {
            // Check the notation
            unsigned int j;
            for ( j = 0; j < numPairs; ++j ) {
                // If not match, exit this inner loop
                if ( dowkerNotation[j] != EntryAccess[i][j+1] ) j = numPairs*2;
            }
            // Found the matched knot name
            if ( j == numPairs ) {
                if ( knotName ) *knotName = KnotNames[ EntryAccess[i][j+1] ] + " Knot";
                return EntryAccess[i][j+1];
            }
        }
    }

    // no matched Dowker notation found
    if ( knotName ) *knotName = "n/a";
    return -1;
} // EOF: FindKnotOfDowkerNotation (...)
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs__Data
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----