1 #ifndef AGGLOMERATIVE_H
2 #define AGGLOMERATIVE_H
4 #include "../base/algorithm.h"
5 #include "../base/clusterdissimilaritymeasure.h"
6 #include "../base/solutionprovider.h"
7 #include "../base/inputsetter.h"
8 #include "../base/clustermeasuresetter.h"
9 #include "../datastructure/partitionsolution.h"
10 #include "../exception/invalidruntimeconfigurationexception.h"
52 virtual void setInput(std::vector<T*>
const*);
70 measure(m==NULL?NULL:m->clone()), mode(cm)
75 input(rhs.input), measure(rhs.measure==NULL?NULL:rhs.measure->clone()), mode(rhs.mode)
82 Algorithm::operator=(rhs);
86 this->input = rhs.
input;
87 this->mode = rhs.
mode;
98 if (this->input==NULL)
100 if (this->measure==NULL)
108 unsigned int N = this->input->size();
111 std::clog <<
"CluE::Agglomerative<T>::compute() - starting with " << N <<
" singleton clusters..." << std::endl;
112 std::vector<std::vector<T*> > partitionzero;
113 for (
unsigned int i=0; i<N; i++)
115 std::vector<T*> singleton;
116 singleton.push_back((*this->input)[i]);
117 partitionzero.push_back(singleton);
119 solution->
partitions.push_back(partitionzero);
124 if (this->mode==Precompute)
126 std::clog <<
"CluE::Agglomerative<T>::compute() - precomputing dissimilarities..." << std::endl;
127 dis =
new double[N*N];
129 for (
unsigned int i=0; i<N; i++)
130 for (
unsigned int j=0; j<N; j++)
134 for (
unsigned int n=1; n<N; n++)
136 std::clog <<
"CluE::Agglomerative<T>::compute() - currently computing round " << n << std::endl;
140 double min = std::numeric_limits<double>::infinity();
141 for (
unsigned int i=0; i<N-n+1; i++)
142 for (
unsigned int j=0; j<N-n+1; j++)
148 if (this->mode==Precompute)
172 while (!solution->
partitions[n][second].empty())
180 if (this->mode==Precompute)
183 for (
unsigned int i=0; i<N-n; i++)
185 dis[N*second+i] = dis[N*(N-n)+i];
186 dis[N*i+second] = dis[N*i+(N-n)];
189 for (
unsigned int i=0; i<N-n; i++)
191 dis[N*first+i] = this->measure->dissimilarity(solution->
partitions[n][first], solution->
partitions[n][i]);
192 dis[N*i+first] = this->measure->dissimilarity(solution->
partitions[n][i], solution->
partitions[n][first]);
198 solution->
seconds=double(end-start)/CLOCKS_PER_SEC;
199 std::clog <<
"CluE::Agglomerative<T>::compute() - finished" << std::endl;
210 this->measure = m==NULL?NULL:m->
clone();
std::vector< std::vector< std::vector< T * > > > partitions
Agglomerative< T > & operator=(const Agglomerative< T > &)
Abstract base class for cluster dissimilarity measurement.
std::vector< T * > const * input
ClusterDissimilarityMeasure< T > * measure
Agglomerative clustering algorithm.
virtual void setInput(std::vector< T * > const *)
static Agglomerative< T > * toAgglomerative(Algorithm *s)
does a dynamic cast of the given Algorithm to Agglomerative
Agglomerative(std::vector< T * > const *data, ClusterDissimilarityMeasure< T > *measure=NULL, int calculationTime=OnDemand)
Abstract base class for algorithms.
Abstract base class for dissimilarity measurement.
virtual ClusterDissimilarityMeasure< T > * clone() const =0
virtual void setMeasure(ClusterDissimilarityMeasure< T > const *)
virtual PartitionSolution< T > * compute()
Interface to propagate the ability to set a ClusterDissimilarityMeasure.
Indicates that a computation entered an invalid configuration state.
Data structure for partitions.