public bool TryGetValue(long time, out TemporalValue <T> result)
{
if (m_values.Count > 0)
{
if (m_observers.Count == 1)
{
m_values.TryDequeue(out result);
}
else
{
if (m_lasttime == time)
{
if (m_refcount == 1)
{
m_values.TryDequeue(out result);
}
else
{
m_refcount--;
m_values.TryPeek(out result);
}
}
else
{
m_refcount = m_observers.Count - 1;
m_lasttime = time;
m_values.TryPeek(out result);
}
}
return(true);
}
result = new TemporalValue <T>(time, default(T));
return(false);
}
public void Apply(TemporalValue <double[]> newCandle)
{
if (m_nexttimeframe == 0)
{
m_nexttimeframe = newCandle.TimeStamp + m_timeframe;
m_value = CandleFactory.GetOhlcCandle(m_nexttimeframe, newCandle.Value);
}
else
{
if (newCandle.TimeStamp < m_nexttimeframe)
{
m_value.SetClose(newCandle.Close());
m_value.SetOpenInterest(newCandle.OpenInterest());
m_value.SetHigh(Math.Max(newCandle.High(), m_value.High()));
m_value.SetLow(Math.Min(newCandle.Low(), m_value.Low()));
m_value.SetVolume(m_value.Volume() + newCandle.Volume());
m_value.SetVolumeAsk(m_value.VolumeAsk() + newCandle.VolumeAsk());
}
else
{
m_manager.AddTemporalValue(m_restoken, m_value);
m_nexttimeframe = newCandle.TimeStamp + m_timeframe;
m_value = CandleFactory.GetOhlcCandle(m_nexttimeframe, newCandle.Value);
}
}
}
public void Apply(TemporalValue value)
{
LastTimeStamp = value.TimeStamp;
_manager.AddTemporalValue(_out_tokens[0], value);
_manager.AddTemporalValue(_out_tokens[1], value);
_manager.AddTemporalValue(_out_tokens[2], value);
}
void ICollection <TemporalValue <T> > .CopyTo(TemporalValue <T>[] array, int arrayIndex)
{
foreach (var v in m_values.OrderBy(v => v.Key))
{
array[arrayIndex++] = new TemporalValue <T>(v.Key, v.Value);
}
}
public void Apply(TemporalValue <double> value)
{
if (m_period == m_window.Count)
{
var last = m_window.Min;
//m_manager.AddTemporalValue(m_restoken, new TemporalValue<double>(m_window.Max.TimeStamp, m_sum / m_period));
if (queue == null)
{
queue = (ICollection <TemporalValue <double> >)m_manager[m_restoken];
if (queue == null)
{
m_manager.AddTemporalValue(m_restoken, new TemporalValue <double>(m_window.Max.TimeStamp, m_sum / m_period));
goto icontinue;
}
}
queue.Add(new TemporalValue <double>(m_window.Max.TimeStamp, m_sum / m_period));
icontinue:
m_sum -= last;
m_window.Remove(last);
}
m_sum += value;
m_window.Add(value);
}
public IndSlice(TemporalContextManager manager, string token)
{
m_manager = manager;
m_token = token;
m_values = new TemporalValue[0];
m_columns = new IndParameter[0];
m_outTokens = new string[0];
}
void ICollection <TemporalValue <T> > .Add(TemporalValue <T> value)
{
m_values.Enqueue(value);
foreach (var observer in m_observers)
{
observer.Key.Apply(value);
}
}
public void Reset()
{
m_values = new TemporalValue[m_values.Length];
for (int i = 0; i < m_outTokens.Length; i++)
{
m_manager.ResetStream(m_outTokens[i]);
m_manager.ClearStream(m_outTokens[i]);
}
}
void ICollection <TemporalValue <T> > .Add(TemporalValue <T> value)
{
//if (m_values.ContainsKey(value.TimeStamp)) return;
//m_values.Add(value.TimeStamp, value.Value);
m_values[value.TimeStamp] = value.Value;
foreach (var observer in m_observers)
{
observer.Key.Apply(value);
}
}
public void Apply(TemporalValue value)
{
if (m_period == m_window.Count)
{
m_manager.AddTemporalValue(m_tokens,
new TemporalValue(m_window.Max.TimeStamp, m_window.Max.Value / m_window.Min.Value));
m_window.Remove(m_window.Min);
}
m_window.Add(value);
}
bool ICollection <TemporalValue <T> > .Remove(TemporalValue <T> item)
{
TemporalValue <T> forDeleteItem;
if (m_values.TryPeek(out forDeleteItem) && forDeleteItem.TimeStamp == item.TimeStamp)
{
m_values.TryDequeue(out forDeleteItem);
return(true);
}
return(false);
}
public bool TryGetValue(long time, out TemporalValue <T> result)
{
T res;
if (m_values.TryGetValue(time, out res))
{
result = new TemporalValue <T>(time, res);
return(true);
}
result = new TemporalValue <T>(time, default(T));
return(false);
}
public void Apply(TemporalValue value)
{
//if (m_period == m_window.Count)
//{
// var last = m_window.Min;
// m_manager.AddTemporalValue(m_outToken, new TemporalValue(m_window.Max.TimeStamp, m_sum / m_period));
// m_sum -= last;
// m_window.Remove(last);
//}
//m_sum += value;
//m_window.Add(value);
}
public void Apply(TemporalValue <double> value)
{
if (queue == null)
{
queue = (ICollection <TemporalValue <double[]> >)m_manager[m_restoken];
if (queue == null)
{
m_manager.AddTemporalValue(m_restoken,
new TemporalValue <double[]>(value.TimeStamp, new[] { (1 - _k) * value.Value, (1 + _k) * value.Value }));
return;
}
}
queue.Add(new TemporalValue <double[]>(value.TimeStamp, new [] { (1 - _k) * value.Value, (1 + _k) * value.Value }));
}
public int Compare(TemporalValue <T> x, TemporalValue <T> y)
{
if (x.TimeStamp > y.TimeStamp)
{
return(1);
}
if (x.TimeStamp < y.TimeStamp)
{
return(-1);
}
return(0);
//long xy = x.TimeStamp - y.TimeStamp;
//long yx = y.TimeStamp - x.TimeStamp;
//return (int)(xy >> 63) | (int)((ulong)yx >> 63);
}
public void Apply(TemporalValue <double> value)
{
if (m_period + 1 == m_window.Count)
{
m_window.Remove(m_window.Min);
m_wma = 0; double k = 1;
foreach (var tv in m_window)
{
m_wma += tv * k; k++;
}
m_manager.AddTemporalValue <double>(m_restoken, new TemporalValue <double>(m_window.Max.TimeStamp, m_wma / m_sumWeight));
}
m_window.Add(value);
}
public void Apply(TemporalValue <T> value)
{
if (m_end >= value.TimeStamp - m_period)
{
m_end = value.TimeStamp;
return;
}
else
if (m_start == 0 && m_end == 0)
{
m_start = m_end = value.TimeStamp;
return;
}
m_manager.AddTemporalValue(m_restoken, new TemporalValue <long>(m_start, m_end));
m_start = m_end = value.TimeStamp;
}
public void Apply(TemporalValue <double> value)
{
m_ema = (m_next) ? m_KE * m_ema + m_KC * value : value;
//m_manager.AddTemporalValue(m_restoken, new TemporalValue<double>(value.TimeStamp, m_ema));
if (queue == null)
{
queue = (ICollection <TemporalValue <double> >)m_manager[m_restoken];
if (queue == null)
{
m_manager.AddTemporalValue(m_restoken, new TemporalValue <double>(value.TimeStamp, m_ema));
return;
}
}
queue.Add(new TemporalValue <double>(value.TimeStamp, m_ema));
m_next = true;
}
public void Apply(TemporalValue <double> tv)
{
if (m_calls % 2 == 0)
{
m_line = tv.Value;
}
else
{
if (queue == null)
{
queue = (ICollection <TemporalValue <double[]> >)m_manager[m_token];
}
//m_manager.SendTemporalValue<double[]>(m_token,
// new TemporalValue<double[]>((long)tv, new []{ m_line, tv.Value}));
queue.Add(new TemporalValue <double[]>((long)tv, new[] { m_line, tv.Value }));
}
m_calls++;
}
public void Apply(TemporalValue <double> value)
{
if (m_calls % 2 == 0)
{
m_fast = value;
}
else
{
if (queue == null)
{
queue = (ICollection <TemporalValue <double> >)m_manager[m_token];
}
//m_manager.SendTemporalValue<double>(m_token,
// new TemporalValue<double>((long)m_fast, (double)m_fast - (double)value));
queue.Add(new TemporalValue <double>((long)m_fast, (double)m_fast - (double)value));
}
m_calls++;
}
public void Apply(TemporalValue <double[]> tv)
{
// line, signal, hist
if (queue == null)
{
queue = (ICollection <TemporalValue <double[]> >)m_manager[m_restoken];
if (queue == null)
{
m_manager.AddTemporalValue(m_restoken,
new TemporalValue <double[]>(tv.TimeStamp,
new[] { tv.Value[0], tv.Value[1], tv.Value[0] - tv.Value[1] }));
return;
}
}
queue.Add(new TemporalValue <double[]>(tv.TimeStamp,
new[] { tv.Value[0], tv.Value[1], tv.Value[0] - tv.Value[1] }));
}
public void Apply(TemporalValue <double[]> tv)
{
Apply(new TemporalValue <double>((long)tv, tv.Value[m_index]));
}
public void Apply(TemporalValue <T> value)
{
}
public void AddTemporalValue <T>(string token, TemporalValue <T> value)
{
ITemporalStream stream = AddTemporalStream <T>(token);
((ICollection <TemporalValue <T> >)stream).Add(value);
}
public void Apply(TemporalValue <T> value)
{
m_context.RegToken(m_index, value.TimeStamp);
m_manager.m_reg_contexts.Add(m_context);
}
public bool Equals(TemporalValue <T> key)
{
return(key.TimeStamp == TimeStamp);
}
bool ICollection <TemporalValue <T> > .Remove(TemporalValue <T> item)
{
T i;
return(m_values.TryRemove(item.TimeStamp, out i));
}
public void SendTemporalValue <T>(string token, TemporalValue <T> value)
{
ITemporalStream queue = AddTemporalQueue <T>(token);
((ICollection <TemporalValue <T> >)queue).Add(value);
}
bool ICollection <TemporalValue <T> > .Contains(TemporalValue <T> item)
{
return(m_values.ContainsKey(item.TimeStamp));
}
public override bool Equals(object obj)
{
TemporalValue <T> key = (TemporalValue <T>)obj;
return(key.TimeStamp == TimeStamp);
}
