public UsersWithinDistanceCommandHandler(
IUserRepository userRepository,
IDistanceAlgorithm distanceAlgorithm)
{
this.userRepository = userRepository;
this.distanceAlgorithm = distanceAlgorithm;
}
public DfekmProcessor(Guid id, Int32 myId, Uri librarian, Int32 clusterCount, Task[] problemData, Int32 start, Int32 len, IDistanceAlgorithm<Task> alg)
{
// Initialize stuff
this._id = id;
this._myId = myId;
this._problemData = problemData;
this._processorData = new ArraySegment<Task>(_problemData, start, len);
this._distanceAlg = alg;
// Initialize WCF librarian proxy
EndpointAddress endpoint = new EndpointAddress(librarian);
_librarian = ChannelFactory<ILibrarianService>.CreateChannel(new BasicHttpBinding(), endpoint);
_librarian.InitializeKMeans(id);
// Check if this is node-zero
if (myId == 0)
{
// Grab a random sample
Int32 sampleSize = (Int32)Math.Ceiling(Math.Sqrt(_problemData.Length));
if (sampleSize < clusterCount) sampleSize = clusterCount;
Task[] sample = _problemData.OrderBy((Task t) => { return rand.Next(); }).Take(sampleSize).ToArray();
// Run k-medoid on the sample
// Create the first row of CA Table
}
}
public DfekmProcessor(Guid id, Int32 myId, Uri librarian, Int32 clusterCount, Task[] problemData, Int32 start, Int32 len, IDistanceAlgorithm <Task> alg)
{
// Initialize stuff
this._id = id;
this._myId = myId;
this._problemData = problemData;
this._processorData = new ArraySegment <Task>(_problemData, start, len);
this._distanceAlg = alg;
// Initialize WCF librarian proxy
EndpointAddress endpoint = new EndpointAddress(librarian);
_librarian = ChannelFactory <ILibrarianService> .CreateChannel(new BasicHttpBinding(), endpoint);
_librarian.InitializeKMeans(id);
// Check if this is node-zero
if (myId == 0)
{
// Grab a random sample
Int32 sampleSize = (Int32)Math.Ceiling(Math.Sqrt(_problemData.Length));
if (sampleSize < clusterCount)
{
sampleSize = clusterCount;
}
Task[] sample = _problemData.OrderBy((Task t) => { return(rand.Next()); }).Take(sampleSize).ToArray();
// Run k-medoid on the sample
// Create the first row of CA Table
}
}
public TileNavigator(
IBlockedProvider blockedProvider,
INeighborProvider neighborProvider,
IDistanceAlgorithm distanceAlgorithm,
IDistanceAlgorithm heuristicAlgorithm)
{
this.blockedProvider = blockedProvider;
this.neighborProvider = neighborProvider;
this.distanceAlgorithm = distanceAlgorithm;
this.heuristicAlgorithm = heuristicAlgorithm;
}
/// <summary>
/// Constructor
/// Creates a iteration-restricted instance of PAM algorithm
/// </summary>
/// <param name="data">Data to be clustered</param>
/// <param name="clusterCount">Number of clusters to produce</param>
/// <param name="alg">Distance calculation algorithm</param>
/// <param name="maxIterations">Maximum number of iterations allowed</param>
public PAMClusteringAlgorithm(T[] data, Int32 clusterCount, IDistanceAlgorithm <T> alg, Int32 maxIterations)
{
this._data = data;
this._centroids = new T[clusterCount];
this._dist = alg;
this._maxIterations = maxIterations;
this._clusters = new List <T> [clusterCount];
this._clusterAssignment = new Dictionary <T, int>();
for (int i = 0; i < _clusters.Length; i++)
{
_clusters[i] = new List <T>();
}
}
public IEnumerable <ClusterBucket <T> > BuildCluster <T, TValue>(IEnumerable <T> data, Func <T, TValue> valueSelector,
IDistanceAlgorithm <TValue> distanceAlgorithm, double threshold)
{
var clusterBuckets = data.Select(x => new ClusterBucket <T>(new List <T> {
x
})).ToArray();
var entriesMatrix = new double?[clusterBuckets.Length, clusterBuckets.Length];
for (var i = 0; i < clusterBuckets.Length; i++)
{
for (var j = 0; j < clusterBuckets.Length; j++)
{
if (i == j)
{
// diagonal is zero
entriesMatrix[i, j] = 0;
}
else
{
// already set
if (entriesMatrix[i, j] != null)
{
continue;
}
var distance = distanceAlgorithm.CalculateDistance(
valueSelector(clusterBuckets[i].Entities.Single()),
valueSelector(clusterBuckets[j].Entities.Single()));
// as distance is symmetrical
entriesMatrix[i, j] = distance;
entriesMatrix[j, i] = distance;
}
}
}
while (TryMergeSimilarBuckets(clusterBuckets, entriesMatrix, threshold))
{
}
return(clusterBuckets.Where(x => x.Entities.Any()));
}
public CustomerSearch(IDistanceAlgorithm searchAlgorithm)
{
_algorithm = searchAlgorithm;
}
public CustomerSearch(IDistanceAlgorithm searchAlgorithm)
{
_algorithm = searchAlgorithm;
}
/// <summary>
/// Constructor
/// Creates an unrestricted instance of PAM algorithm
/// </summary>
/// <param name="data">Data to be clustered</param>
/// <param name="clusterCount">Number of clusters to produce</param>
/// <param name="alg">Distance calculation algorithm</param>
public PAMClusteringAlgorithm(T[] data, Int32 clusterCount, IDistanceAlgorithm <T> alg)
: this(data, clusterCount, alg, Int32.MaxValue)
{
}
public Generator(IGrid gridToManipulate, IMazeAlgorithm algorithmToApply, IDistanceAlgorithm solver)
{
this.gridToManipulate = gridToManipulate;
this.algorithmToApply = algorithmToApply;
this.solver = solver;
}
public CLARAClusteringAlgorithm(T[] items, Int32 clusterCount, Int32 samplingRuns, IDistanceAlgorithm <T> alg)
: this(items, clusterCount, samplingRuns, alg, Int32.MaxValue)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="items">Items to cluster</param>
/// <param name="clusterCount">Number of clusters to produce</param>
/// <param name="samplingRuns">Number of sampling runs</param>
/// <param name="alg">Distance calculation algorithm</param>
/// <param name="maxIterations">Maximum number of iterations allowed</param>
public CLARAClusteringAlgorithm(T[] items, Int32 clusterCount, Int32 samplingRuns, IDistanceAlgorithm <T> alg, Int32 maxIterations)
: base(items, clusterCount, alg, maxIterations)
{
this.SamplingRuns = samplingRuns;
this._sampleSize = (int)Math.Sqrt(items.Length);
this._workers = new Thread[Environment.ProcessorCount * WORKER_PER_PROCESSOR];
}
public NearestNeighbour(int alpha, IDistanceAlgorithm dist)
{
_alpha = alpha;
_dist = dist;
}
public NearestAverage(IDistanceAlgorithm dist)
{
_dist = dist;
}
