annoviko / pyclustering

        @see get_clusters()

        """

        return self.__medians;

    def get_cluster_encoding(self):

        """!

        @brief Returns clustering result representation type that indicate how clusters are encoded.

        @return (type_encoding) Clustering result representation.

        @see get_clusters()

        """

        return type_encoding.CLUSTER_INDEX_LIST_SEPARATION;

    def __update_clusters(self):

        """!

        @brief Calculate Manhattan distance to each point from the each cluster. 

        @details Nearest points are captured by according clusters and as a result clusters are updated.

        @return (list) updated clusters as list of clusters where each cluster contains indexes of objects from data.

        """

        clusters = [[] for i in range(len(self.__medians))];

        for index_point in range(len(self.__pointer_data)):

            index_optim = -1;

            dist_optim = 0.0;

            Kw = (1.0 - K / N) * sigma_sqrt;

            Ks = ( 2.0 * alpha * sigma / (N ** 0.5) ) * ( (alpha ** 2.0) * sigma_sqrt / N + W - Kw / 2.0 ) ** 0.5;

            scores = sigma_sqrt * (2 * K)**0.5 * ((2 * K)**0.5 + betta) / N + W - sigma_sqrt + Ks + 2 * alpha**0.5 * sigma_sqrt / N

        return scores;

    def __bayesian_information_criterion(self, clusters, centers):

        """!

        @brief Calculates splitting criterion for input clusters using bayesian information criterion.

        @param[in] clusters (list): Clusters for which splitting criterion should be calculated.

        @param[in] centers (list): Centers of the clusters.

        @return (double) Splitting criterion in line with bayesian information criterion.

                High value of splitting criterion means that current structure is much better.

        @see __minimum_noiseless_description_length(clusters, centers)

        """

        scores = [float('inf')] * len(clusters)     # splitting criterion

        dimension = len(self.__pointer_data[0]);

        # estimation of the noise variance in the data set

        sigma_sqrt = 0.0;

        K = len(clusters);

        N = 0.0;

        for index_cluster in range(0, len(clusters), 1):

            for index_object in clusters[index_cluster]:

                sigma_sqrt += euclidean_distance_sqrt(self.__pointer_data[index_object], centers[index_cluster]);

            N += len(clusters[index_cluster]);

        if (N - K > 0):

            sigma_sqrt /= (N - K);

            p = (K - 1) + dimension * K + 1;

                #changes = max([euclidean_distance(self.__centers[index], updated_centers[index]) for index in range(len(self.__centers))]);        # Slow solution

                changes = max([euclidean_distance_sqrt(self.__centers[index], updated_centers[index]) for index in range(len(updated_centers))]);    # Fast solution

                self.__centers = updated_centers;

    def get_clusters(self):

        """!

        @brief Returns list of allocated clusters, each cluster contains indexes of objects in list of data.

        @see process()

        @see get_centers()

        """

        return self.__clusters;

    def get_centers(self):

        """!

        @brief Returns list of centers of allocated clusters.

        @see process()

        @see get_clusters()

        """

        return self.__centers;

    def get_cluster_encoding(self):

        """!

        @brief Returns clustering result representation type that indicate how clusters are encoded.

        return type_encoding.CLUSTER_INDEX_LIST_SEPARATION;

    def __update_clusters(self):

        """!

        @brief Calculate distance to each point from the each cluster. 

        @details Nearest points are captured by according clusters and as a result clusters are updated.

        @return (list) updated clusters as list of clusters where each cluster contains indexes of objects from data.

        """

        clusters = [[self.__medoid_indexes[i]] for i in range(len(self.__medoids))];

        for index_point in range(len(self.__pointer_data)):

            if (index_point in self.__medoid_indexes):

                continue;

            index_optim = -1;

            dist_optim = float('Inf');

            for index in range(len(self.__medoids)):

                dist = euclidean_distance_sqrt(self.__pointer_data[index_point], self.__medoids[index]);

                if ( (dist < dist_optim) or (index is 0)):

                    index_optim = index;

                    dist_optim = dist;

            clusters[index_optim].append(index_point);

        # If cluster is not able to capture object it should be removed

        clusters = [cluster for cluster in clusters if len(cluster) > 0];

        return clusters;

    def __update_medoids(self):