spvecgf2.h

Go to the documentation of this file.

//
// This program can be freely used in an academic environment
// ONLY for research purposes, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
//    claim that you wrote the original software. If you use this software
//    an acknowledgment in the product documentation is required.
// 2. Altered source versions must be plainly marked as such, and must not be
//    misrepresented as being the original software.
// 3. This notice may not be removed or altered from any source distribution.
//
// Any other use is strictly prohibited by the author, without an explicit 
// permission.
//
// Note that this program uses the LEDA library, which is NOT free. For more 
// details visit Algorithmic Solutions at http://www.algorithmic-solutions.com/
// There is also a free version of LEDA 6.0 or newer.
//
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// ! Any commercial use of this software is strictly !
// ! prohibited without explicit permission by the   !
// ! author.                                         !
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//
// 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.
//
// Copyright (C) 2004-2008 - Dimitrios Michail <dimitrios.michail@gmail.com>
//

#ifndef SPVECGF2_H
#define SPVECGF2_H

#include <iostream>
#include <LEP/mcb/config.h>

#ifdef LEDA_GE_V5
#include <LEDA/system/basic.h>
#include <LEDA/core/list.h>
#include <LEDA/core/d_int_set.h>
#include <LEDA/system/error.h>
#include <LEDA/system/assert.h>
#else
#include <LEDA/basic.h>
#include <LEDA/list.h>
#include <LEDA/d_int_set.h>
#include <LEDA/error.h>
#include <LEDA/assert.h>
#endif
#include <LEP/mcb/edge_num.h>
#include <LEP/mcb/arithm.h>

namespace mcb
{

#if defined(LEDA_NAMESPACE)
    using leda::list;
    using leda::list_item;
    using leda::error_handler;
    using leda::d_int_set;
#endif


    class spvecgf2
    {
        public:

            spvecgf2();

            spvecgf2( const spvecgf2 & a );

            explicit spvecgf2( const int& i );

            ~spvecgf2(  );



            spvecgf2& operator=( const spvecgf2& i );

            spvecgf2& operator=( const int& i );

#if (__LEDA__ >= 500)
            spvecgf2& operator=( const d_int_set& i );
#else
            spvecgf2& operator=( d_int_set& i );
#endif

            spvecgf2 operator-(  ) const;

            int operator*( const spvecgf2& a ) const;

            spvecgf2 operator+( const spvecgf2& a ) const;

            void add( const spvecgf2& a ); 

            spvecgf2 operator%( const spvecgf2& a ) const;

            d_int_set operator%( const d_int_set& a ) const;

            spvecgf2 intersect( const spvecgf2& a ) const;

            spvecgf2& operator+=( const spvecgf2& a );

            spvecgf2& operator-=( const spvecgf2& a );

            spvecgf2& operator%=( const spvecgf2& a );

            void swap( spvecgf2& a );


            d_int_set to_d_int_set() const;

            list<int> to_list() const { return l; }


            void clear( ) { l.clear(); }

            void print( std::ostream & o ) const;

            void append( int index );

            void insert( int index );

            int pop() { return l.pop(); }

            void sort() { l.sort(); }

            // define access stuff, like leda lists

            bool empty() const { return l.empty(); }

            int size(  ) const { return l.size(); }


            list_item first(  ) const { return l.first(); }

            list_item last(  ) const { return l.last(); }

            list_item succ( list_item it ) const { return l.succ(it); }

            list_item pred( list_item it ) const { return l.pred(it); }

            int index( list_item it ) const { return l.contents(it); }

            int inf( list_item it ) const { return l.contents(it); }

            // allow the LEDA forall() macro to work
            typedef list_item item;

            item first_item()       const { return l.first(); }
            item last_item()        const { return l.last(); }
            item next_item(item it) const { return it ? l.succ(it) : 0; }

        private:

            list < int > l;
    };

    std::ostream & operator<<( std::ostream & o, const spvecgf2& v );

    std::istream & operator>>( std::istream & o, spvecgf2& v );


}

// helper swap
namespace std { 
    template<>
    void swap<mcb::spvecgf2>( mcb::spvecgf2& a, mcb::spvecgf2& b );
}
   

#endif

/* ex: set ts=4 sw=4 sts=4 et: */