
/*
**  This file forms part of the GOBLIN C++ Class Library.
**
**  Written by Christian Fremuth-Paeger, December 1998.
**  
**  Copying, compiling, distribution and modification
**  of this source code is permitted only in accordance
**  with the GOBLIN general licence information.
*/             


#if !defined(_BIG2FNW_H_)

#define _BIG2FNW_H_

#include <absdig.h>
#include <absbig.h>


class big2FNW : public abstractDiGraph
{                                        
friend class iBig2FNW;
protected:

    abstractBiGraph &G;       // The original graph

    TNode           n0;       // Number of nodes in the original network
    TNode           n1;       // Number of outer nodes in the original network
    TNode           n2;       // Number of inner nodes in the original network
    TArc            m0;       // Number of arcs in the original network

    TNode           s1;       // Sorce node, s1 == Source()
    TNode           t1;       // Sink node, t1 == Target()
    TNode           s2;       // Additional source node
    TNode           t2;       // Additional target node
    TArc            ret1;     // Return arc with end nodes t1 and s1
    TArc            ret2;     // Return arc with end nodes t2 and s2
    TArc            art1;     // Artifical arc with end nodes s1 and t2
    TArc            art2;     // Artifical arc with end nodes s2 and t1

    TFloat*         dgl;      // Array of node degrees in the original graph
    TCap            ccap;     // Node capacity constant
    TCap*           cap;      // Array of (upper-lower) node capacities
    TCap*           lower;    // Array of lower node capacities
    
    TCap            sumLower1; // sum of lower degree bounds on the outer nodes
    TCap            sumLower2; // sum of lower degree bounds on the inner nodes
    TCap            sumUpper;  // sum of upper degree bounds
    
public:             

    big2FNW(abstractBiGraph &GC,TCap *pLower,TCap *pCap = NULL) throw();
    big2FNW(abstractBiGraph &GC,TCap cCap) throw();
    big2FNW(abstractBiGraph &GC) throw();
    ~big2FNW() throw();

    void            Init() throw();
    void            SetDegrees() throw();
    unsigned long   Size() throw();     
    unsigned long   Allocated() throw();

    bool            Perfect() throw();     

    TNode           Source() throw()        {return s1;};
    TNode           Target() throw()        {return t1;};     

    TNode           StartNode(TArc a) throw(ERRange);
    TNode           EndNode(TArc a) throw(ERRange);
   
    TArc            First(TNode v) throw(ERRange);
    TArc            Right(TArc a,TNode u) throw(ERRange);

    TCap            Demand(TNode v) throw(ERRange);
    TCap            LCap(TArc a) throw() {return 0;};
    bool            CLCap() throw() {return 1;};
    TCap            UCap(TArc a) throw(ERRange);
    bool            CUCap() throw() {return 0;};
    TFloat          Length(TArc a) throw(ERRange);     
    bool            CLength() throw()
                        {return G.CLength() & (G.MaxLength()==0);};
    bool            Blocking(TArc a) throw() {return a&1;};

    TFloat          C(TNode v,char i) throw(ERRange);
    TFloat          CMax(char i) throw(ERRange);
    char            Dim() throw() {return G.Dim();};
    bool            HiddenNode(TNode v) throw(ERRange);

    TFloat          Flow(TArc a) throw(ERRange);
    void            Push(TArc a,TFloat Lambda) throw(ERRange,ERRejected);
    
    TFloat          Sub(TArc a) throw(ERRange) {return Flow(a);};
    void            AddArc(TArc a,TFloat Lambda) throw() {};
    void            OmitArc(TArc a,TFloat Lambda) throw() {};
    
    void            Write(char* fileName) throw(ERFile)
                        {WriteDiGraph(fileName,WRITE_INCIDENCES);};

};                             


#endif
