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