spvecfp.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 SPVECFP_H
#define SPVECFP_H

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

#ifdef LEDA_GE_V5
#include <LEDA/core/array.h>
#include <LEDA/core/list.h>
#include <LEDA/core/tuple.h>
#include <LEDA/system/error.h>
#include <LEDA/system/assert.h>
#else
#include <LEDA/array.h>
#include <LEDA/list.h>
#include <LEDA/tuple.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::two_tuple;
    using leda::three_tuple;
    using leda::array;
#endif

    
    class spvecfp { 
        
        public:

        spvecfp();
        spvecfp( const ptype& p );
        
        spvecfp( const spvecfp& a );

        ~spvecfp();

        void reset( const ptype& p );

        // assign a vector to the current vector
        // cast between types, retain the current's vector type
        spvecfp& operator=( const spvecfp& i );

        // assign current vector to e_i
        spvecfp& operator=( const indextype& i );

        spvecfp operator-() const;

        ptype operator*( const spvecfp& a ) const;

        spvecfp operator+( const spvecfp& a ) const;

        spvecfp operator*( const ptype& a );

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

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

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

        void append( indextype index, const ptype& value );

        void sort();

        // define access stuff, like leda lists

        bool empty() const;

        void clear();

        indextype size() const;

        ptype pvalue() const;

        list_item first() const;
        
        list_item last() const;

        list_item succ( list_item it ) const;

        list_item pred( list_item it ) const;

        indextype index( list_item it ) const;

        ptype inf( list_item it ) const;

        private:

        typedef two_tuple<indextype,ptype> entry;
        // list of tuples (tuple = < index, value >)
        list< entry > l;
        ptype p;

        // compare two entries of a spvecfp
        static inline int compare( const entry& a, const entry& b ) {
            return leda::compare( a.first(), b.first() );
        }
    };

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


} // end of mcb namespace

#endif // SPVECFP_H