/Users/jst/src/grafalgo/cpp/include/Flograph.h

Go to the documentation of this file.

#ifndef FLOGRAPH_H
#define FLOGRAPH_H

#include "stdinc.h"
#include "Util.h"
#include "Digraph.h"

namespace grafalgo {

typedef int flow;

class Flograph : public Digraph {
public:         Flograph(int=3,int=2,int=1,int=2);
                Flograph(const Flograph&);
                virtual ~Flograph();

        void    resize(int,int);
        void    resize(int numv) { resize(numv, numv); }
        void    expand(int,int);
        void    expand(int numv) { resize(numv, max(numv,m())); }
        void    copyFrom(const Flograph&);

        // methods for accessing, setting source and sink
        vertex  src() const;
        vertex  snk() const;    
        void    setSrc(vertex);
        void    setSnk(vertex);

        // methods for dealing with flows
        flow    cap(vertex,edge) const; 
        flow    f(vertex,edge) const;
        flow    res(vertex,edge) const;
        void    addFlow(vertex,edge,flow); 
        void    setFlow(edge,flow); 
        void    clearFlow(); 
        void    setCapacity(edge,flow); 

        virtual edge join(vertex,vertex);

        string& edge2string(edge, string&) const;
        string& toDotString(string&) const;

        void    randCapacity(flow, flow);       
        void    rgraph(int, int, int);
protected:
        vertex  s, t;                   
        struct FloInfo {                
        flow    cpy;                    
        flow    flo;                    
        };
        FloInfo *floInfo;               


        // various helper methods
        void    makeSpace(int,int);     
        void    freeSpace();                    
        void    virtual shuffle(int*, int*);   
        string& adjList2string(edge,string&) const; 
        bool    readAdjList(istream&);

        Flograph& operator=(const Flograph&); 
};

inline vertex Flograph::src() const { return s; }

inline vertex Flograph::snk() const { return t; }

inline flow Flograph::cap(vertex v, edge e) const { 
        assert(1 <= v && v <= n() && 1 <= e && e <= m());
        return tail(e) == v ? floInfo[e].cpy : 0;
}

inline flow Flograph::f(vertex v, edge e) const {
        assert(1 <= v && v <= n() && 1 <= e && e <= m());
        return tail(e) == v ? floInfo[e].flo : -floInfo[e].flo;
}

inline flow Flograph::res(vertex v, edge e) const {
        assert(1 <= v && v <= n() && 1 <= e && e <= m());
        return tail(e) == v ? floInfo[e].cpy - floInfo[e].flo : floInfo[e].flo;
}

inline void Flograph::setFlow(edge e, flow fval) {
        assert(1 <= e && e <= m());
        floInfo[e].flo = fval;
}

inline void Flograph::setCapacity(edge e, flow capp) {
        assert(1 <= e && e <= m());
        floInfo[e].cpy = capp;
}

inline void Flograph::setSrc(vertex ss) { s = ss; }

inline void Flograph::setSnk(vertex tt) { t = tt; }

} // ends namespace

#endif