remordered.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// A utility procedure for removing an ordered set from another ordered set.
///
/////////////////////////////////////////////////////////////////////////////

// Copyright (C) 2009-2016 by Pawel Pilarczyk.
//
// This file is part of my research software package. This is free software:
// you can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
//
// This software 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this software; see the file "license.txt". If not,
// please, see <http://www.gnu.org/licenses/>.

// Started on March 24, 2009. Last revision: January 12, 2013.


#ifndef _CHAINCON_REMORDERED_H_
#define _CHAINCON_REMORDERED_H_


// include selected header files from the CHomP library
#include "chomp/system/config.h"


// --------------------------------------------------
// ----------------- remove ordered -----------------
// --------------------------------------------------

/// From the given set of objects, removes another one in such a way
/// that the order of objects in the first one is preserved.
/// In order to achieve this, this procedure creates a new vector
/// that contains all the elements appearing in K that are not in L.
/// This procedure is intended to be applied to hashed sets
/// and filtered complexes, or to other containers that provide
/// a few basic interface features, as one can see in the code.
/// It is thus very inefficient and thus should be used with care.
template <class Vector1T, class Vector2T>
inline void removeOrdered (Vector1T &K, const Vector2T &L)
{
        // check if there is any element in L that needs to be removed from K
        int_t sizeL = L. size ();
        bool disjoint = true;
        for (int_t i = 0; i < sizeL; ++ i)
        {
                if (!K. check (L [i]))
                        continue;
                disjoint = false;
                break;
        }
        if (disjoint)
                return;

        // prepare a new K
        Vector1T M;
        int_t sizeK = K. size ();
        for (int_t i = 0; i < sizeK; ++ i)
        {
                if (!L. check (K [i]))
                        M. add (K [i]);
        }
        M. swap (K);

        return;
} /* removeOrdered */


#endif // _CHAINCON_REMORDERED_H_