public IList <Cluster <TNode, double> > Solve([NotNull] IList <TNode> Nodes, [NotNull] CostAnalyzer <double> costanalyzer, double maxCostOfNearestNeighbor, int maxNodesPerCluster = -1)
{
var clusterFactory = new ClusterFactory(Nodes, costanalyzer);
var transposedCostMatrix = CostMatrix <double> .CreateTransposed(costanalyzer.CostMatrix);
var transposedCostanalyzer = new CostAnalyzer <double>(transposedCostMatrix);
// While unhandled indexes available and the loop runs for at most a certain amount of times, continue the algorithm
for (var counter = 0; counter < Nodes.Count * maxFactorOfLoopCount && clusterFactory.NodesAsIndexes.Count > 0; counter++)
{
// set the current pointer to a random node index among the nodes not yet classified in a cluster
int currentPointer = clusterFactory.NodesAsIndexes[randomizer.Next(0, clusterFactory.NodesAsIndexes.Count - 1)];
var candidateCluster = CalculateCluster(clusterFactory.NodesAsIndexes, costanalyzer, transposedCostanalyzer, maxCostOfNearestNeighbor, maxNodesPerCluster);
if (candidateCluster.Count > 1)
{
// loop over the cluster again maybe to cut the cluster in pieces. Clusters with one item are thrown back in the pool
for (int indexInCluster = 0; indexInCluster < candidateCluster.Count - 1; indexInCluster++)
{
var maxCostInCluster = indexInCluster == 0 ?
costanalyzer.AllNeighborsOrdered(candidateCluster[0])[candidateCluster[1]]
: candidateCluster.Take(indexInCluster + 1).Tuples().Max(t => costanalyzer.AllNeighborsOrdered(t.Item1)[t.Item2]);
var nodesOutsideClusterQuiteCloseToCluster = costanalyzer.AllNeighborsOrdered(candidateCluster[indexInCluster])
.Where(neighbor =>
!candidateCluster.Contains(neighbor.Key) && neighbor.Value <= maxCostInCluster);
if (nodesOutsideClusterQuiteCloseToCluster.Count() > 1) // Split the cluster
{
var firstPart = candidateCluster.GetRange(0, indexInCluster + 1);
clusterFactory.CreateCluster(firstPart);
candidateCluster.RemoveRange(0, indexInCluster + 1);
indexInCluster = -1;
}
}
}
clusterFactory.CreateCluster(candidateCluster);
}
// Here we add the singleton clusters from the remaining nodes
clusterFactory.CreateSingletonClusters();
return(clusterFactory.ListOfClusters);
}
// methods
public ICluster BuildCluster()
{
IStreamFactory streamFactory = new TcpStreamFactory(_tcpStreamSettings);
if (_sslStreamSettings != null)
{
streamFactory = new SslStreamFactory(_sslStreamSettings, streamFactory);
}
streamFactory = _streamFactoryWrapper(streamFactory);
var connectionFactory = new BinaryConnectionFactory(
_connectionSettings,
streamFactory,
_connectionListener);
var connectionPoolFactory = new ExclusiveConnectionPoolFactory(
_connectionPoolSettings,
connectionFactory,
_connectionPoolListener);
var serverFactory = new ServerFactory(
_serverSettings,
connectionPoolFactory,
connectionFactory,
_serverListener);
var clusterFactory = new ClusterFactory(
_clusterSettings,
serverFactory,
_clusterListener);
return(clusterFactory.CreateCluster());
}
// methods
public ICluster BuildCluster()
{
IStreamFactory streamFactory = new TcpStreamFactory(_tcpStreamSettings);
// TODO: SSL gets handled here specifically...
streamFactory = _streamFactoryWrapper(streamFactory);
var connectionFactory = new BinaryConnectionFactory(
_connectionSettings,
streamFactory,
_connectionListener);
var connectionPoolFactory = new ExclusiveConnectionPoolFactory(
_connectionPoolSettings,
connectionFactory,
_connectionPoolListener);
var serverFactory = new ServerFactory(
_serverSettings,
connectionPoolFactory,
connectionFactory,
_serverListener);
var clusterFactory = new ClusterFactory(
_clusterSettings,
serverFactory,
_clusterListener);
return(clusterFactory.CreateCluster());
}
// methods
/// <summary>
/// Builds the cluster.
/// </summary>
/// <returns>A cluster.</returns>
public ICluster BuildCluster()
{
IStreamFactory streamFactory = new TcpStreamFactory(_tcpStreamSettings);
if (_sslStreamSettings != null)
{
streamFactory = new SslStreamFactory(_sslStreamSettings, streamFactory);
}
streamFactory = _streamFactoryWrapper(streamFactory);
var connectionFactory = new BinaryConnectionFactory(
_connectionSettings,
streamFactory,
_eventAggregator);
var connectionPoolFactory = new ExclusiveConnectionPoolFactory(
_connectionPoolSettings,
connectionFactory,
_eventAggregator);
var serverMonitorConnectionSettings = _connectionSettings.With(authenticators: new IAuthenticator[] { });
var serverMonitorConnectionFactory = new BinaryConnectionFactory(
serverMonitorConnectionSettings,
streamFactory,
new EventAggregator());
var serverMonitorFactory = new ServerMonitorFactory(
_serverSettings,
serverMonitorConnectionFactory,
_eventAggregator);
var serverFactory = new ServerFactory(
_clusterSettings.ConnectionMode,
_serverSettings,
connectionPoolFactory,
serverMonitorFactory,
_eventAggregator);
var clusterFactory = new ClusterFactory(
_clusterSettings,
serverFactory,
_eventAggregator);
return(clusterFactory.CreateCluster());
}
// methods
private ICluster CreateCluster(ClusterKey clusterKey)
{
var clusterSettings = CreateClusterSettings(clusterKey);
var serverSettings = CreateServerSettings(clusterKey);
var connectionSettings = CreateConnectionSettings(clusterKey);
var connectionPoolSettings = CreateConnectionPoolSettings(clusterKey);
var listener = EmptyListener.Instance;
var streamFactory = CreateStreamFactory(clusterKey);
var connectionFactory = new BinaryConnectionFactory(connectionSettings, streamFactory, listener);
var connectionPoolFactory = new ExclusiveConnectionPoolFactory(connectionPoolSettings, connectionFactory, listener);
var serverFactory = new ServerFactory(serverSettings, connectionPoolFactory, connectionFactory, listener);
var clusterFactory = new ClusterFactory(clusterSettings, serverFactory, listener);
var cluster = clusterFactory.CreateCluster();
cluster.Initialize();
return(cluster);
}
