public void Register(uint tick, uint entityId, Vector2 pos)
{
if (!Buffer.ContainsKey(tick))
{
Buffer.Add(tick, new Dictionary <uint, Vector2>(10));
}
if (!Buffer[tick].ContainsKey(entityId))
{
Buffer[tick].Add(entityId, pos); //Initial size of 5 commands per frame per player
}
else
{
throw new Exception();
}
}
private void AddLeftParenthesis(string input)
{
//left parenthesis cannot immediately follow a value or unary operator
if (KeyHistory.Last() == KeyType.Value || KeyHistory.Last() == KeyType.Unary)
{
throw new InvalidOperationException("Missing Operators.");
}
//left parenthesis cannot immediately follow right parenthesis
if (KeyHistory.Last() == KeyType.Right)
{
throw new InvalidOperationException("Mismatched Parentheses.");
}
Buffer.Add(input);
KeyHistory.Add(KeyType.Left);
}
/// <summary>
/// To handle the input value.
/// </summary>
/// <param name="input">The input value.</param>
/// <returns>The resulting value.</returns>
protected override IIndicatorValue OnProcess(IIndicatorValue input)
{
var price = input.GetValue <Candle>().ClosePrice;
if (Buffer.Count > Length)
{
Buffer.RemoveAt(0);
}
if (input.IsFinal)
{
Buffer.Add(price);
}
return(new DecimalIndicatorValue(this, price));
}
/// <summary>Pump the content of a source into a list</summary>
public static async Task <List <T> > PumpToListAsync <T>(this IAsyncSource <T> source, CancellationToken ct)
{
if (ct.IsCancellationRequested)
{
ct.ThrowIfCancellationRequested();
}
var buffer = new Buffer <T>();
var target = CreateTarget <T>(
(x, _) => buffer.Add(x)
);
await PumpToAsync <T>(source, target, ct).ConfigureAwait(false);
return(buffer.ToList());
}
void LinearCrossover()
{
Buffer.Clear();
for (int i = 0; i < Population.Count - 1; i++)
{
var Children = Tuple.Create(new PopulationParameters
(0, Population[i].Child((x, y) => (x + y) / 2, Population[i + 1], Funct)),
new PopulationParameters(0, Population[i].Child((x, y) => (3 * x - y) / 2, Population[i + 1], Funct)),
new PopulationParameters(0, Population[i].Child((x, y) => (-x + 3 * y) / 2, Population[i + 1], Funct)));
Children.Item1.Fitness = Funct.Function(Children.Item1.Args);
Children.Item2.Fitness = Funct.Function(Children.Item2.Args);
Children.Item3.Fitness = Funct.Function(Children.Item3.Args);
var BestChildren = Tournament(Children);
Buffer.Add(BestChildren.Item1);
Buffer.Add(BestChildren.Item2);
}
}
/// <summary>
/// Обработать входное значение.
/// </summary>
/// <param name="input">Входное значение.</param>
/// <returns>Результирующее значение.</returns>
protected override IIndicatorValue OnProcess(IIndicatorValue input)
{
var candle = input.GetValue <Candle>();
decimal?result = null;
var buff = _buffer;
if (input.IsFinal)
{
_buffer.Add(candle);
// если буффер стал достаточно большим (стал больше длины)
if (_buffer.Count > Length)
{
_buffer.RemoveAt(0);
}
}
else
{
buff = _buffer.Skip(1).Concat(candle).ToList();
}
if (buff.Count >= Length)
{
// рассчитываем значение
var max = buff.Max(t => t.HighPrice);
var min = buff.Min(t => t.LowPrice);
if (Kijun.IsFormed && input.IsFinal)
{
Buffer.Add((max + min) / 2);
}
if (Buffer.Count >= Kijun.Length)
{
result = Buffer[0];
}
if (Buffer.Count > Kijun.Length)
{
Buffer.RemoveAt(0);
}
}
return(result == null ? new DecimalIndicatorValue(this) : new DecimalIndicatorValue(this, result.Value));
}
private TagHelperContent AppendCore(object entry)
{
if (!_hasContent)
{
_isSingleContentSet = true;
_singleContent = entry;
}
else
{
Buffer.Add(entry);
}
_isModified = true;
_hasContent = true;
return(this);
}
private static void SendPlcSignals(Signal s)
{
/* using (var sw = File.AppendText(file))
* {
* sw.WriteLine("Start: " + processStart.ToString("HH:mm:ss") + " End: " + processEnd.ToString("HH:mm:ss") + " Elapsed: " + processEnd.Subtract(processStart).TotalMilliseconds);
* }
*/
if (_inProcess)
{
Buffer.Add(s, 0);
}
else
{
_inProcess = true;
SendSignal(s.Cell, s.Offsets, s.Px, s.Py, s.Type, s.Count, s.CellFull, s.Boxed, s.OffX, s.OffY,
s.KatMax);
}
}
/// <summary>
/// To handle the input value.
/// </summary>
/// <param name="input">The input value.</param>
/// <returns>The resulting value.</returns>
protected override IIndicatorValue OnProcess(IIndicatorValue input)
{
var candle = input.GetValue<Candle>();
decimal average = (candle.HighPrice + candle.LowPrice) / 2;
var halfRange = (candle.HighPrice - candle.LowPrice) / 2;
Buffer.Add(average);
//var Chec1 = Buffer[Buffer.Count - 1];
if (IsFormed)
{
if (Buffer.Count > Length)
Buffer.RemoveAt(0);
//Сглаженное приращение ****************************************************************************
var avgDiff = Buffer[Buffer.Count - 1] - Buffer[Buffer.Count - 2];
decimal smoothDiff = _smoothConstant * avgDiff + _smoothConstant1 * _value1Old;
_value1Old = smoothDiff;
//Сглаженный Half Range *********************************************************************************
decimal smoothRng = _smoothConstant * halfRange + _smoothConstant1 * _value2Old;
_value2Old = smoothRng;
//Tracking index ***********************************************************************************
if (smoothRng != 0)
_lambda = System.Math.Abs(smoothDiff / smoothRng);
//Alfa для альфа фильтра ***************************************************************************
_alpha = (-_lambda * _lambda + (decimal)System.Math.Sqrt((double)(_lambda * _lambda * _lambda * _lambda + 16 * _lambda * _lambda))) / 8;
//Smoothed result **********************************************************************************
var check2 = _alpha * average;
var check3 = (1 - _alpha) * _resultOld;
decimal result = check2 + check3;
_resultOld = result;
return new DecimalIndicatorValue(this, result);
}
_value2Old = halfRange;
_resultOld = average;
return new DecimalIndicatorValue(this, _resultOld);
}
public override void init_population()
{
int targetLength = StrTarget.Length;
Population.Clear();
Buffer.Clear();
for (int i = 0; i < GaPopSize; i++)
{
StringGen citizen = new StringGen(Rand, targetLength);
//for (int j = 0; j < targetLength; j++)
//{
// var randVal = Rand.Next();
// citizen.Str += Convert.ToChar((randVal % 90) + 32);
//}
Population.Add(citizen);
Buffer.Add(new StringGen());
}
}
private void UpdateAngularVelocityHistory()
{
if (rotationHistory.Count < 2)
{
return;
}
float delta = Time.deltaTime;
float angleDegrees = 0.0f;
Vector3 unitAxis = Vector3.zero;
Quaternion rotation = Quaternion.identity;
rotation = (rotationHistory[rotationHistory.Count - 1]) * Quaternion.Inverse(rotationHistory[rotationHistory.Count - 2]);
rotation.ToAngleAxis(out angleDegrees, out unitAxis);
Vector3 angular = unitAxis * ((angleDegrees * Mathf.Deg2Rad) / delta);
angularVelocityHistory.Add(angular);
}
/// <summary>
/// To handle the input value.
/// </summary>
/// <param name="input">The input value.</param>
/// <returns>The resulting value.</returns>
protected override IIndicatorValue OnProcess(IIndicatorValue input)
{
//если кол-во в буфере больше Shift, то первое значение отдали в прошлый раз, удалим его.
if (Buffer.Count > Shift)
{
Buffer.RemoveAt(0);
}
var smaResult = _sma.Process(_medianPrice.Process(input));
if (_sma.IsFormed & input.IsFinal)
{
Buffer.Add(smaResult.GetValue <decimal>());
}
return(Buffer.Count > Shift
? new DecimalIndicatorValue(this, Buffer[0])
: new DecimalIndicatorValue(this));
}
public override void TraceFromCallback()
{
var regs = DebuggableCore.GetCpuFlagsAndRegisters();
uint pc = (uint)regs["M68K PC"].Value;
var length = 0;
var disasm = Disassembler.Disassemble(MemoryDomains.SystemBus, pc, out length);
var traceInfo = new TraceInfo
{
Disassembly = string.Format("{0:X6}: {1}", pc, disasm)
};
var sb = new StringBuilder();
foreach (var r in regs)
{
if (r.Key.StartsWith("M68K")) // drop Z80 regs until it has its own debugger/tracer
{
if (r.Key != "M68K SP" && r.Key != "M68K ISP" && // copies of a7
r.Key != "M68K PC" && // already present in every line start
r.Key != "M68K IR") // copy of last opcode, already shown in raw bytes
{
sb.Append(
string.Format("{0}:{1} ",
r.Key.Replace("M68K", string.Empty).Trim(),
r.Value.Value.ToHexString(r.Value.BitSize / 4)));
}
}
}
var sr = regs["M68K SR"].Value;
sb.Append(
string.Format("{0}{1}{2}{3}{4}",
(sr & 16) > 0 ? "X" : "x",
(sr & 8) > 0 ? "N" : "n",
(sr & 4) > 0 ? "Z" : "z",
(sr & 2) > 0 ? "V" : "v",
(sr & 1) > 0 ? "C" : "c"));
traceInfo.RegisterInfo = sb.ToString().Trim();
Buffer.Add(traceInfo);
}
public void SetCharacterSize(ECharacterSize size)
{
LogController("SetCharacterSize(size:" + size.ToString() + ")");
while ((CursorState.CurrentRow + TopRow) >= Buffer.Count)
{
Buffer.Add(new TerminalLine());
}
var currentLine = Buffer[CursorState.CurrentRow + TopRow];
switch (size)
{
default:
case ECharacterSize.SingleWidthLine:
currentLine.DoubleWidth = false;
currentLine.DoubleHeightTop = false;
currentLine.DoubleHeightBottom = false;
break;
case ECharacterSize.DoubleHeightLineTop:
currentLine.DoubleWidth = true;
currentLine.DoubleHeightBottom = false;
currentLine.DoubleHeightTop = true;
break;
case ECharacterSize.DoubleHeightLineBottom:
currentLine.DoubleWidth = true;
currentLine.DoubleHeightTop = false;
currentLine.DoubleHeightBottom = true;
break;
case ECharacterSize.DoubleWidthLine:
currentLine.DoubleHeightTop = false;
currentLine.DoubleHeightBottom = false;
currentLine.DoubleWidth = true;
break;
case ECharacterSize.ScreenAlignmentTest:
ScreenAlignmentTest();
break;
}
}
protected bool Replaying(object message)
{
switch (message)
{
case ReplayedEvent replayed:
Buffer.Add(new EventEnvelope(
offset: new Sequence(replayed.Offset),
persistenceId: replayed.Persistent.PersistenceId,
sequenceNr: replayed.Persistent.SequenceNr,
@event: replayed.Persistent.Payload));
CurrentOffset = replayed.Offset;
Buffer.DeliverBuffer(TotalDemand);
return(true);
case EventReplaySuccess success:
Log.Debug("event replay completed, currOffset [{0}], highestSequenceNr [{1}]", CurrentOffset, success.HighestSequenceNr);
ReceiveRecoverySuccess(success.HighestSequenceNr);
return(true);
case EventReplayFailure failure:
Log.Debug("event replay failed, due to [{0}]", failure.Cause.Message);
Buffer.DeliverBuffer(TotalDemand);
OnErrorThenStop(failure.Cause);
return(true);
case Request _:
Buffer.DeliverBuffer(TotalDemand);
return(true);
case Cancel _:
Context.Stop(Self);
return(true);
case AllEventsPublisher.Continue _:
case NewEventAppended _:
return(true);
default:
return(false);
}
}
public C64Sprite Undo(C64Sprite currentState)
{
if (!CanUndo)
{
throw new SystemException();
}
if (NeedsCurrentState(currentState))
{
Buffer.Add(currentState.Clone());
}
var result = Buffer[UndoPointer];
UndoPointer--;
if (result.CompareTo(currentState))
{
result = Buffer[UndoPointer];
UndoPointer--;
}
return(result);
}
private static void TestBufferInternal(int interation, ManualResetEvent sinkWaitHandle, Buffer <int> buffer)
{
Task.Run(() =>
{
for (int i = 0; i < 20; i++)
{
buffer.Add(i);
}
});
Thread.Sleep(500);
//Should block
int count = buffer.Count;
Assert.InRange(count, 10, 11);
buffer.Requeue(-1, true);
Assert.Equal(count + 1, buffer.Count);
sinkWaitHandle.Set();
Thread.Sleep(500);
Assert.Equal(0, buffer.Count);
}
public void AddBinary(string input)
{
//consecutive binary operator input is not allowed
if (KeyHistory.Last() == KeyType.Binary)
{
throw new InvalidOperationException("Missing Operand.");
}
/*
* when binary operator input follows left parenthesis or nothing,
* a value of zero will be added as default operand
*/
if (KeyHistory.Last() == KeyType.Left || KeyHistory.Last() == KeyType.Empty)
{
AddValue(0);
}
Buffer.Add(input);
KeyHistory.Add(KeyType.Binary);
}
public void ImplicitRemoveAt()
{
Buffer.MaxCapacity = 16;
// generate 32 extra messsages to exceed the max capacity which
// forces a RemoveAt() call of the oldest messages
var bufferCount = Buffer.Count;
var msgs = new List <MessageModel>(Buffer);
for (int i = 1; i <= 32; i++)
{
var builder = new MessageBuilder();
builder.AppendText("msg{0}", bufferCount + i);
var msg = builder.ToMessage();
msgs.Add(msg);
Buffer.Add(msg);
}
Assert.AreEqual(Buffer.MaxCapacity, Buffer.Count);
Assert.AreEqual(msgs[32 - (Buffer.MaxCapacity - bufferCount)].ToString(), Buffer[0].ToString());
}
public override void init_population()
{
Population.Clear();
Buffer.Clear();
for (int i = 0; i < GaPopSize; i++)
{
List <int> emptyVols = Enumerable.Repeat(-1, _volumes.Count).ToList();
VolumesGen volumesGen = new VolumesGen(emptyVols);
List <int> vols = new List <int>(_volumes);
for (int j = 0; j < _volumes.Count; j++)
{
var index = Rand.Next() % vols.Count;
volumesGen.Volumes[j] = vols[index];
vols.RemoveAt(index);
}
Population.Add(volumesGen);
Buffer.Add(new VolumesGen(emptyVols));
}
}
public void PutChar(char character)
{
LogExtreme("PutChar(ch:'" + character + "'=" + ((int)character).ToString() + ")");
if (CursorState.InsertMode == EInsertReplaceMode.Insert)
{
while (Buffer.Count <= (TopRow + CursorState.CurrentRow))
{
Buffer.Add(new TerminalLine());
}
var line = Buffer[TopRow + CursorState.CurrentRow];
while (line.Count < CursorState.CurrentColumn)
{
line.Add(new TerminalCharacter());
}
line.Insert(CursorState.CurrentColumn, new TerminalCharacter());
}
if (CursorState.WordWrap)
{
if (CursorState.CurrentColumn >= Columns)
{
CursorState.CurrentColumn = 0;
NewLine();
}
}
SetCharacter(CursorState.CurrentColumn, CursorState.CurrentRow, character, CursorState.Attribute);
CursorState.CurrentColumn++;
var lineToClip = Buffer[TopRow + CursorState.CurrentRow];
while (lineToClip.Count > Columns)
{
lineToClip.RemoveAt(lineToClip.Count - 1);
}
ChangeCount++;
}
private void AddRightParenthesis(string input)
{
//right parenthesis cannot immediately follow binary operator
if (KeyHistory.Last() == KeyType.Binary)
{
throw new InvalidOperationException("Missing Operand.");
}
//parentheses must match
if (MissingParentheses(Expression) < 1)
{
throw new InvalidOperationException("Mismatched Parentheses.");
}
if (KeyHistory.Last() == KeyType.Left)
{
AddValue(0);
}
Buffer.Add(input);
KeyHistory.Add(KeyType.Right);
}
/// <summary>
/// Обработать входное значение.
/// </summary>
/// <param name="input">Входное значение.</param>
/// <returns>Результирующее значение.</returns>
protected override IIndicatorValue OnProcess(IIndicatorValue input)
{
var newValue = input.GetValue <decimal>();
if (input.IsFinal)
{
Buffer.Add(newValue);
if (Buffer.Count > Length)
{
Buffer.RemoveAt(0);
}
}
if (input.IsFinal)
{
return(new DecimalIndicatorValue(this, Buffer.Sum() / Length));
}
return(new DecimalIndicatorValue(this, (Buffer.Skip(1).Sum() + newValue) / Length));
}
private void SetCharacter(int currentColumn, int currentRow, char ch, TerminalAttribute attribute)
{
while (Buffer.Count < (currentRow + TopRow + 1))
{
Buffer.Add(new TerminalLine());
}
var line = Buffer[currentRow + TopRow];
while (line.Count < (currentColumn + 1))
{
line.Add(new TerminalCharacter {
Char = ' ', Attributes = CursorState.Attribute
});
}
var character = line[currentColumn];
character.Char = ch;
character.Attributes = attribute.Clone();
}
/// <inheritdoc />
protected override IIndicatorValue OnProcess(IIndicatorValue input)
{
var newValue = input.GetValue <decimal>();
if (input.IsFinal)
{
Buffer.Add(newValue);
if ((Buffer.Count - 1) > Length)
{
Buffer.RemoveAt(0);
}
}
if (Buffer.Count == 0)
{
return(new DecimalIndicatorValue(this));
}
return(new DecimalIndicatorValue(this, newValue - Buffer[0]));
}
/// <summary>
/// To handle the input value.
/// </summary>
/// <param name="input">The input value.</param>
/// <returns>The resulting value.</returns>
protected override IIndicatorValue OnProcess(IIndicatorValue input)
{
var smaValue = _sma.Process(input);
if (_sma.IsFormed && input.IsFinal)
{
Buffer.Add(smaValue.GetValue <decimal>());
}
if (!IsFormed)
{
return(new DecimalIndicatorValue(this));
}
if (Buffer.Count > Length)
{
Buffer.RemoveAt(0);
}
return(new DecimalIndicatorValue(this, input.GetValue <decimal>() - Buffer[0]));
}
public void RunOpenBufferBenchmark(int itemCount)
{
Buffer.Dispose();
Buffer = CreateBuffer();
var bufferType = Buffer.GetType().Name;
// generate items
for (int i = 0; i < itemCount; i++)
{
Buffer.Add(new MessageModel(SimpleMessage));
}
// flush/close buffer
Buffer.Dispose();
int runs = 10;
var messageCount = 0;
DateTime start, stop;
start = DateTime.UtcNow;
for (int i = 0; i < runs; i++)
{
Buffer = OpenBuffer();
messageCount += Buffer.Count;
Buffer.Dispose();
}
stop = DateTime.UtcNow;
Assert.AreEqual(runs * itemCount, messageCount);
var total = (stop - start).TotalMilliseconds;
Console.WriteLine(
"{0}(): avg: {1:0.00} ms items: {2} runs: {3} took: {4:0.00} ms",
bufferType,
total / runs,
itemCount,
runs,
total
);
}
/// <summary>
/// Copies the values of the objects to capture
/// into the buffer by reading capture objects.
/// </summary>
public void Capture(GXDLMSServer server)
{
lock (this)
{
object[] values = new object[CaptureObjects.Count];
int pos = 0;
ValueEventArgs[] args = new ValueEventArgs[] { new ValueEventArgs(server, this, 2, 0, null) };
server.PreGet(args);
if (!args[0].Handled)
{
foreach (GXKeyValuePair <GXDLMSObject, GXDLMSCaptureObject> it in CaptureObjects)
{
if (it.Value.AttributeIndex == 0)
{
values[pos] = it.Key.GetValues();
}
else
{
values[pos] = it.Key.GetValues()[it.Value.AttributeIndex - 1];
}
++pos;
}
lock (Buffer)
{
//Remove first items if buffer is full.
if (ProfileEntries != 0 && ProfileEntries == Buffer.Count)
{
--EntriesInUse;
Buffer.RemoveAt(0);
}
Buffer.Add(values);
++EntriesInUse;
}
}
server.PostGet(args);
server.NotifyAction(args);
server.NotifyPostAction(args);
}
}
public override SignalAndValue Process(Candle candle)
{
var val = candle.CloseBid;
if (candle.IsComplete == 1)
{
Buffer.Add(val);
}
var smaValue = Sma.Process(candle).Value;
if (Buffer.Count > Length)
{
Buffer.RemoveAt(0);
}
var md = candle.IsComplete == 1
? Buffer.Sum(t => Math.Abs(t - smaValue))
: Buffer.Skip(IsFormed ? 1 : 0).Sum(t => Math.Abs(t - smaValue)) + Math.Abs(val - smaValue);
return(new SignalAndValue(md / Length, IsFormed));
}
protected override IIndicatorValue OnProcess(IIndicatorValue input)
{
var candle = input.GetValue <Candle>();
var medianPrice = (candle.ClosePrice + candle.OpenPrice + candle.HighPrice + candle.LowPrice) / 4m;
Buffer.Add(medianPrice);
Vector <double> val = DenseVector.Create(1, (i) => 0);
val[0] = (double)medianPrice;
RecalculateFilterParameters(val);
if (Buffer.Count < 5)
{
return(new DecimalIndicatorValue(this, medianPrice));
}
IsFormed = true;
return(new DecimalIndicatorValue(this, (decimal)xplus[0]));
}