membertrix.h

Go to the documentation of this file.

#pragma once

#include <Eigen/Dense>
#include "np_data.h"
#include "np_cluster.h"

#include <map>
#include <unordered_map>

typedef std::unordered_map<cluster_id_t, cluster_t*> clusters_t;

typedef std::unordered_map<cluster_id_t, dataset_t*> clusters_dataset_t;

enum np_error_t { error_none, error_already_assigned, error_assignment_remaining, error_assignment_absent };

static std::map< np_error_t, const char * > np_error_str = {
    {error_none,                       "none"},
    {error_already_assigned,           "already assigned"},
    {error_assignment_remaining,       "assignment remaining"},
    {error_assignment_absent,          "assignment absent"}
};

typedef Eigen::Matrix<bool, Eigen::Dynamic, Eigen::Dynamic> binary_matrix_t;

class membertrix {
    private:
        // membership matrix
        binary_matrix_t _membership_matrix;

        // map from cluster pointers to column entries
        clusters_t _cluster_objects; 

        // map from data pointers to row entries
        dataset_t _data_objects; 

        // store data items per cluster
        clusters_dataset_t _clusters_dataset;

        // verbosity
        char _verbosity;

    protected:
        
        bool exists(cluster_id_t cluster_id);
        
    public:
        membertrix();

        membertrix(const membertrix &other);

        membertrix* clone();

        ~membertrix();

        cluster_id_t addCluster(cluster_t *cluster);

        cluster_t * getCluster(cluster_id_t cluster_id);

        data_id_t addData(data_t & data);

        data_t * getDatum(data_id_t data_id);

        np_error_t assign(cluster_id_t cluster_id, data_id_t data_id);
        
        np_error_t retract(cluster_id_t cluster_id, data_id_t data_id, bool auto_remove = true);

        np_error_t retract(data_id_t data_id, bool auto_remove = true);

        np_error_t remove(cluster_id_t cluster_id);

        bool assigned(data_id_t data_id) const;

        void getAssignments(cluster_id_t cluster_id, data_ids_t & data_ids) const;

        cluster_id_t getClusterId(data_id_t data_id) const;

        const clusters_t & getClusters() const;

        size_t getClusterCount() const;

        void relabel();

        void print(cluster_id_t cluster_id, std::ostream &os) const;
        
        void print(std::ostream& os) const;

        friend std::ostream& operator<<(std::ostream& os, const membertrix& m);  

        dataset_t* getData();
        
        dataset_t* getData(const cluster_id_t cluster_id) const;

        void getData(const cluster_id_t cluster_id, dataset_t & dataset) const;

        void getData(const data_ids_t data_ids, dataset_t & dataset) const;

        size_t count(cluster_id_t cluster_id) const;

        size_t count() const;
    
        bool empty(cluster_id_t cluster_id);

        int cleanup();

        membertrix &operator=(membertrix other);

        friend void swap(membertrix& first, membertrix& second) {
            using std::swap;

            swap(first._membership_matrix, second._membership_matrix);
            swap(first._cluster_objects, second._cluster_objects);
            swap(first._data_objects, second._data_objects);
            swap(first._clusters_dataset, second._clusters_dataset);
            swap(first._verbosity, second._verbosity);
        }
};