/// <summary>
/// найти кластер с минимальный объёмом
/// найти кластер с минимальный объёмом
/// </summary>
/// <param name="startIndex">starting index/стартовый индекс</param>
/// <param name="endIndex">final index /конечный индекс</param>
/// <param name="typeCluster">type of volume in the cluster/тип объёма в кластере</param>
/// <returns></returns>
public HorizontalVolumeCluster FindMinVolumeCluster(int startIndex, int endIndex, ClusterType typeCluster)
{
if (VolumeClusters == null ||
VolumeClusters.Count == 0)
{
return(null);
}
HorizontalVolumeCluster cluster = null;
if (startIndex < 0)
{
startIndex = 0;
}
for (int i = startIndex; VolumeClusters != null && i < endIndex && i < VolumeClusters.Count; i++)
{
if (VolumeClusters[i].MinSummVolumeLine == null)
{
continue;
}
if (typeCluster == ClusterType.SummVolume)
{
if (cluster == null ||
cluster.MinSummVolumeLine.VolumeSumm > VolumeClusters[i].MinSummVolumeLine.VolumeSumm)
{
cluster = VolumeClusters[i];
}
}
else if (typeCluster == ClusterType.BuyVolume)
{
if (cluster == null ||
cluster.MinBuyVolumeLine.VolumeBuy > VolumeClusters[i].MinBuyVolumeLine.VolumeBuy)
{
cluster = VolumeClusters[i];
}
}
else if (typeCluster == ClusterType.SellVolume)
{
if (cluster == null ||
cluster.MinSellVolumeLine.VolumeSell > VolumeClusters[i].MinSellVolumeLine.VolumeSell)
{
cluster = VolumeClusters[i];
}
}
else if (typeCluster == ClusterType.DeltaVolume)
{
if (cluster == null ||
cluster.MinDeltaVolumeLine.VolumeDelta > VolumeClusters[i].MinDeltaVolumeLine.VolumeDelta)
{
cluster = VolumeClusters[i];
}
}
}
return(cluster);
}
// cluster calculation
// расчёт кластеров
/// <summary>
/// compute the clusters
/// просчитать кластеры
/// </summary>
public void Process(List <Candle> candles)
{
if (candles == null)
{
return;
}
if (_myCandles != null &&
candles.Count < _myCandles.Count)
{
Clear();
}
if (candles.Count == 1 && candles[0].Trades.Count == 0)
{
return;
}
_myCandles = candles;
int index = _lastCandlesCount - 2;
if (index < 0)
{
index = 0;
}
for (int i = index; i < candles.Count; i++)
{
if (candles[i].Trades.Count == 0)
{
continue;
}
// take the cluster from the storage, if not, then create a new
// берём кластер из хранилища, если нет, то создаём новый
if (candles[i].Trades == null ||
candles[i].Trades.Count == 0)
{
continue;
}
HorizontalVolumeCluster cluster = VolumeClusters.Find(c => c.Time == candles[i].TimeStart);
if (cluster == null)
{
cluster = new HorizontalVolumeCluster(_lineStep, Security);
VolumeClusters.Add(cluster);
cluster.NumCluster = VolumeClusters.Count - 1;
cluster.Time = candles[i].TimeStart;
cluster.LogMessageEvent += SendNewLogMessage;
cluster.MaxSummLineChangeEvent += delegate(HorizontalVolumeLine line)
{
MaxSummLineChangeEvent?.Invoke(line);
};
cluster.MaxBuyLineChangeEvent += delegate(HorizontalVolumeLine line)
{
MaxBuyLineChangeEvent?.Invoke(line);
};
cluster.MaxSellLineChangeEvent += delegate(HorizontalVolumeLine line)
{
MaxSellLineChangeEvent?.Invoke(line);
};
cluster.MaxDeltaLineChangeEvent += delegate(HorizontalVolumeLine line)
{
MaxDeltaLineChangeEvent?.Invoke(line);
};
cluster.MinSummLineChangeEvent += delegate(HorizontalVolumeLine line)
{
MinSummLineChangeEvent?.Invoke(line);
};
cluster.MinBuyLineChangeEvent += delegate(HorizontalVolumeLine line)
{
MinBuyLineChangeEvent?.Invoke(line);
};
cluster.MinSellLineChangeEvent += delegate(HorizontalVolumeLine line)
{
MinSellLineChangeEvent?.Invoke(line);
};
cluster.MinDeltaLineChangeEvent += delegate(HorizontalVolumeLine line)
{
MinDeltaLineChangeEvent?.Invoke(line);
};
cluster.NewLineCreateEvent += delegate(HorizontalVolumeLine line) { VolumeClusterLines.Add(line); };
}
// upload the cluster with data
// прогружаем кластер данными
cluster.Process(candles[i].Trades);
// calculate the maximum / minimum clusters
// рассчитываем максимальные / минимальные кластеры
if (MaxSummVolumeCluster == null ||
cluster.MaxSummVolumeLine.VolumeSumm > MaxSummVolumeCluster.MaxSummVolumeLine.VolumeSumm)
{
MaxSummVolumeCluster = cluster;
MaxSummClusterChangeEvent?.Invoke(cluster);
}
if (MinSummVolumeCluster == null ||
cluster.MinSummVolumeLine.VolumeSumm < MinSummVolumeCluster.MinSummVolumeLine.VolumeSumm)
{
MinSummVolumeCluster = cluster;
MinSummClusterChangeEvent?.Invoke(cluster);
}
//
if (MaxBuyVolumeCluster == null ||
cluster.MaxBuyVolumeLine.VolumeBuy > MaxBuyVolumeCluster.MaxBuyVolumeLine.VolumeBuy)
{
MaxBuyVolumeCluster = cluster;
MaxBuyClusterChangeEvent?.Invoke(cluster);
}
if (MinBuyVolumeCluster == null ||
cluster.MinBuyVolumeLine.VolumeBuy < MinBuyVolumeCluster.MinBuyVolumeLine.VolumeBuy)
{
MinBuyVolumeCluster = cluster;
MinBuyClusterChangeEvent?.Invoke(cluster);
}
//
if (MaxSellVolumeCluster == null ||
cluster.MaxSellVolumeLine.VolumeSell > MaxSellVolumeCluster.MaxSellVolumeLine.VolumeSell)
{
MaxSellVolumeCluster = cluster;
MaxSellClusterChangeEvent?.Invoke(cluster);
}
if (MinSellVolumeCluster == null ||
cluster.MinSellVolumeLine.VolumeSell < MinSellVolumeCluster.MinSellVolumeLine.VolumeSell)
{
MinSellVolumeCluster = cluster;
MinSellClusterChangeEvent?.Invoke(cluster);
}
//
if (MaxDeltaVolumeCluster == null ||
cluster.MaxDeltaVolumeLine.VolumeDelta > MaxDeltaVolumeCluster.MaxDeltaVolumeLine.VolumeDelta)
{
MaxDeltaVolumeCluster = cluster;
MaxDeltaClusterChangeEvent?.Invoke(cluster);
}
if (MinDeltaVolumeCluster == null ||
cluster.MinDeltaVolumeLine.VolumeDelta < MinDeltaVolumeCluster.MinDeltaVolumeLine.VolumeDelta)
{
MinDeltaVolumeCluster = cluster;
MinDeltaClusterChangeEvent?.Invoke(cluster);
}
//
if (MaxPriceCluster == null ||
cluster.MaxPriceLine.Price > MaxPriceCluster.MaxPriceLine.Price)
{
MaxPriceCluster = cluster;
}
if (MinPriceCluster == null ||
cluster.MinPriceLine.Price < MinPriceCluster.MinPriceLine.Price)
{
MinPriceCluster = cluster;
}
}
_lastCandlesCount = candles.Count;
}
