include/topology/cycles.h
author Dmitriy Morozov <dmitriy@mrzv.org>
Mon, 12 Jan 2009 15:33:04 -0800
branchdev
changeset 109 75eb7a4628f2
parent 107 a5debdc35559
child 125 0a2c2283e4a8
permissions -rw-r--r--
Debugged ZigzagPersistence (having added heavier consistency checking) * Added DEBUG_CONTAINERS option (uses std::__debug::* containers for chains and in ZigzagPersistence) * Added SizeStorage specialization for std::deque<T> * ZigzagPersistence got a lot more consistency checking (in debug mode only, which now crawls); as a result it's been debugged (running on non-trivial examples) * examples/rips/rips-zigzag takes command-line options * added ChainWrapper::clear() * added Simplex::VertexDimensionComparison * added PairwiseDistances class (for computing distances between points in a container according to a distance functor)

#ifndef __CYCLES_H__
#define __CYCLES_H__

#include "chain.h"
#include "utilities/circular_list.h"

#if DEBUG_CONTAINERS
    #include <debug/vector>
    #include <debug/deque>
    using std::__debug::vector;
    using std::__debug::deque;
#else
    #include <vector>
    #include <deque>
    using std::vector;
    using std::deque;
#endif

template<class OrderIndex_ = int>
struct VectorChains
{
    typedef             OrderIndex_                                             OrderIndex;
    typedef             ChainWrapper<vector<OrderIndex> >                       Chain;
    typedef             Chain                                                   Cycle;

    Cycle               cycle;

                        VectorChains()                                          {}
                        VectorChains(Cycle z): cycle(z)                         {}

    bool                sign() const                                            { return cycle.empty(); }

    template<class U> struct rebind
    { typedef           VectorChains<U>         other; };
};

template<class OrderIndex_ = int>
struct DequeChains
{
    typedef             OrderIndex_                                             OrderIndex;
    typedef             ChainWrapper<deque<OrderIndex> >                        Chain;
    typedef             Chain                                                   Cycle;

    Cycle               cycle;

                        DequeChains()                                           {}
                        DequeChains(Cycle z): cycle(z)                          {}

    bool                sign() const                                            { return cycle.empty(); }

    template<class U> struct rebind
    { typedef           DequeChains<U>         other; };
};

template<class OrderIndex_ = int>
struct ListChains
{
    typedef             OrderIndex_                                             OrderIndex;
    typedef             ChainWrapper<List<OrderIndex> >                         Chain;
    typedef             Chain                                                   Cycle;

    Cycle               cycle;

                        ListChains()                                            {}
                        ListChains(Cycle z): cycle(z)                           {}
    
    bool                sign() const                                            { return cycle.empty(); }
    
    template<class U> struct rebind
    { typedef           ListChains<U>           other; };
};

#endif // __CYCLES_H__