author Dmitriy Morozov <dmitriy@mrzv.org>
Sat, 28 Nov 2009 16:45:42 -0800
changeset 174 3f1034dca432
parent 157 700cbac5b23c
permissions -rw-r--r--
Instrumented code for counting: * added counters to addition in cohomology and ChainWrapper * rips-pairwise-cohomology counts the maximum elements stored in the cycles * added alphashapes3d-cohomology * moved progress_display from DynamicPersistence to StaticPersistence

 * Wrapper class
 * At points we need to wrap primitive data types in classes, so that we can
 * pass them as template arguments to classes that like to inherit from their
 * template arguments--this is done in CohomologyPersistence, for example.

template<typename Primitive>
class    Wrapper


        Wrapper () {}
        Wrapper (Primitive v)                       { value = v;    }

        void       setValue  (const Primitive &v)   { value = v;    }
        Primitive &getValue  ()                     { return value; }

        /* provide seemless integration */
        Wrapper   &operator =(const Primitive &v)   { setValue(v);     return *this; }
        operator  Primitive()                       { return getValue;               }


        Primitive value;


 * IndirectIndexComparison class
 * This class serves as a comparison function for arrays that are being sorted
 * even though they only contain *indices* to the real data. Therefore, a reference
 * to the original data as well as the data comparison function needs to be passed
 * to this class for it to be functional.

template<class DataContainer, class DataComparison>
class IndirectIndexComparison


        IndirectIndexComparison(const DataContainer &dstor, const DataComparison &dcmp) :
            container(dstor), comparison(dcmp) { }

        bool operator()(const unsigned &idx_1, const unsigned &idx_2) const
            return comparison(container[idx_1], container[idx_2]);


        const DataContainer  &container;
        const DataComparison &comparison;