author Christos Mantoulidis <cmad@stanford.edu>
Tue, 04 Aug 2009 16:58:44 -0700
changeset 157 700cbac5b23c
permissions -rw-r--r--
Modified cohomology code (unweighted and weighted) so that it doesn't use std::map for boundary computations, which should optimize memory usage.

 * 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;