BipartiteGraphBicoloring/BipartiteGraphCore.cpp

Go to the documentation of this file.

/************************************************************************************
    Copyright (C) 2005-2008 Assefaw H. Gebremedhin, Arijit Tarafdar, Duc Nguyen,
    Alex Pothen

    This file is part of ColPack.

    ColPack is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published
    by the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    ColPack is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with ColPack.  If not, see <http://www.gnu.org/licenses/>.
************************************************************************************/

#include "ColPackHeaders.h"

using namespace std;

namespace ColPack
{
        //Virtual Function 2102:3102
        void BipartiteGraphCore::Clear()
        {
                m_i_MaximumLeftVertexDegree = _UNKNOWN;
                m_i_MaximumRightVertexDegree = _UNKNOWN;
                m_i_MaximumVertexDegree = _UNKNOWN;

                m_i_MinimumLeftVertexDegree = _UNKNOWN;
                m_i_MinimumRightVertexDegree = _UNKNOWN;
                m_i_MinimumVertexDegree = _UNKNOWN;

                m_d_AverageLeftVertexDegree = _UNKNOWN;
                m_d_AverageRightVertexDegree = _UNKNOWN;
                m_d_AverageVertexDegree = _UNKNOWN;

                m_s_InputFile.clear();

                m_vi_LeftVertices.clear();
                m_vi_RightVertices.clear();

                m_vi_Edges.clear();

                m_mimi2_VertexEdgeMap.clear();

        }

        //Public Function 2103:3103
        string BipartiteGraphCore::GetInputFile()
        {
                return(m_s_InputFile);
        }
        
        vector<int>* BipartiteGraphCore::GetLeftVerticesPtr()
        {
                return &m_vi_LeftVertices;
        }

        vector<int>* BipartiteGraphCore::GetRightVerticesPtr()
        {
                return &m_vi_RightVertices;
        }


        //Public Function 2104:3104
        void BipartiteGraphCore::GetRowVertices(vector<int> &output)  const
        {
                output = (m_vi_LeftVertices);
        }

        unsigned int BipartiteGraphCore::GetRowVertices(unsigned int** ip2_RowVertex)
        {
                (*ip2_RowVertex) = (unsigned int*) malloc(m_vi_LeftVertices.size() * sizeof(unsigned int));
                for(unsigned int i=0; i < m_vi_LeftVertices.size(); i++) {
                        (*ip2_RowVertex)[i] = m_vi_LeftVertices[i];
                }
                return m_vi_LeftVertices.size();
        }

        unsigned int BipartiteGraphCore::GetColumnIndices(unsigned int** ip2_ColumnIndex)
        {
                unsigned int ui_UpperBound = m_vi_LeftVertices[m_vi_LeftVertices.size() - 1];
                (*ip2_ColumnIndex) = (unsigned int*) malloc(ui_UpperBound * sizeof(unsigned int));
                for(unsigned int i=0; i < ui_UpperBound; i++) {
                        (*ip2_ColumnIndex)[i] = m_vi_Edges[i];
                }
                return ui_UpperBound;
        }

        void BipartiteGraphCore::GetLeftVertices(vector<int> &output)  const
        {
                output = (m_vi_LeftVertices);
        }

        //Public Function 2105:3105
        void BipartiteGraphCore::GetColumnVertices(vector<int> &output)  const
        {
                output = (m_vi_RightVertices);
        }

        void BipartiteGraphCore::GetRightVertices(vector<int> &output)  const
        {
                output = (m_vi_RightVertices);
        }

        //Public Function 2106:3106
        void BipartiteGraphCore::GetEdges(vector<int> &output)  const
        {
                output = (m_vi_Edges);
        }

        //Public Function 2107:3107
        void BipartiteGraphCore::GetVertexEdgeMap(map< int, map<int, int> > &output)
        {
                output = (m_mimi2_VertexEdgeMap);
        }


        //Public Function 2108:3108
        int BipartiteGraphCore::GetRowVertexCount()
        {
                return(STEP_DOWN(m_vi_LeftVertices.size()));
        }

        int BipartiteGraphCore::GetLeftVertexCount()
        {
                return(STEP_DOWN(m_vi_LeftVertices.size()));
        }


        //Public Function 2109:3109
        int BipartiteGraphCore::GetColumnVertexCount()
        {
                return(STEP_DOWN(m_vi_RightVertices.size()));
        }

        int BipartiteGraphCore::GetRightVertexCount()
        {
                return(STEP_DOWN(m_vi_RightVertices.size()));
        }


        //Public Function 2110:3110
        int BipartiteGraphCore::GetEdgeCount()
        {
                return(m_vi_Edges.size()/2);
        }


        //Public Function 2111:3111
        int BipartiteGraphCore::GetMaximumRowVertexDegree()
        {
                return(m_i_MaximumLeftVertexDegree);
        }


        //Public Function 2112:3112
        int BipartiteGraphCore::GetMaximumColumnVertexDegree()
        {
                return(m_i_MaximumRightVertexDegree);
        }


        //Public Function 2113:3113
        int BipartiteGraphCore::GetMaximumVertexDegree()
        {
                return(m_i_MaximumVertexDegree);
        }


        //Public Function 2114:3114
        int BipartiteGraphCore::GetMinimumRowVertexDegree()
        {
                return(m_i_MinimumLeftVertexDegree);
        }


        //Public Function 2115:3115
        int BipartiteGraphCore::GetMinimumColumnVertexDegree()
        {
                return(m_i_MinimumRightVertexDegree);
        }


        //Public Function 2116:3116
        int BipartiteGraphCore::GetMinimumVertexDegree()
        {
                return(m_i_MinimumVertexDegree);
        }


        //Public Function 2117:3117
        double BipartiteGraphCore::GetAverageRowVertexDegree()
        {
                return(m_d_AverageLeftVertexDegree);
        }

        //Public Function 2118:3118
        double BipartiteGraphCore::GetAverageColumnVertexDegree()
        {
                return(m_d_AverageRightVertexDegree);
        }

        //Public Function 2119:3119
        double BipartiteGraphCore::GetAverageVertexDegree()
        {
                return(m_d_AverageVertexDegree);
        }
        
        bool BipartiteGraphCore::operator==(const BipartiteGraphCore &other) const {
                // Check for self-assignment!
                if (this == &other)      // Same object?
                  return true;        // Yes, so the 2 objects are equal
                  
                //Compare vector<int> m_vi_LeftVertices; vector<int> m_vi_RightVertices; vector<int> m_vi_Edges;
                vector<int> other_LeftVertices, other_RightVertices, other_Edges;
                
                other.GetLeftVertices(other_LeftVertices);
                other.GetRightVertices(other_RightVertices);
                other.GetEdges(other_Edges);
                
                /*
                if(m_vi_LeftVertices==other_LeftVertices) cout<<"m_vi_LeftVertices==other_LeftVertices"<<endl;
                else  cout<<"m_vi_LeftVertices!=other_LeftVertices"<<endl;
                
                if(m_vi_Edges==other_Edges) cout<<"m_vi_Edges==other_Edges"<<endl;
                else  cout<<"m_vi_Edges!=other_Edges"<<endl;
                
                if( m_vi_RightVertices==other_RightVertices) cout<<" m_vi_RightVertices==other_RightVertices"<<endl;
                else  cout<<"m_vi_RightVertices!=other_RightVertices"<<endl;
                //*/
                
                if(m_vi_LeftVertices==other_LeftVertices && m_vi_Edges==other_Edges && m_vi_RightVertices==other_RightVertices ) return true;
                else return false;

        }
}