#pragma warning restore
#endregion fields & pins
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
FInput.Sync();
FVec.Sync();
FBin.Sync();
if (FInput.IsChanged || FVec.IsChanged || FBin.IsChanged)
{
if (FInput.Length > 0 && FVec.Length > 0 && FBin.Length > 0)
{
int vecSize = Math.Max(1, FVec.GetReader().Read());
spread.Sync(FInput, vecSize, FBin);
FOutput.Length = spread.Count * vecSize;
using (var dataWriter = FOutput.GetWriter())
for (int b = 0; b < spread.Count; b++)
{
for (int v = 0; v < vecSize; v++)
{
dataWriter.Write(spread.GetBinColumn(b, v).Sum(), 1);
}
}
}
else
{
FOutput.Length = 0;
}
}
}
#pragma warning restore
#endregion fields & pins
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
FInput.Sync();
FVec.Sync();
FBin.Sync();
if (FInput.IsChanged || FVec.IsChanged || FBin.IsChanged)
{
if (FInput.Length > 0 && FVec.Length > 0 && FBin.Length > 0)
{
int vecSize = Math.Max(1, FVec.GetReader().Read());
spread.Sync(FInput, vecSize, FBin);
FOutput.Length = Math.Max(spread.ItemCount - (spread.NonEmptyBinCount * vecSize), 0);
FOutBin.Length = spread.Count;
FOffset.Length = spread.Count * vecSize;
using (var offWriter = FOffset.GetWriter())
using (var binWriter = FOutBin.GetWriter())
using (var dataWriter = FOutput.GetWriter())
{
int incr = 0;
for (int b = 0; b < spread.Count; b++)
{
if (spread[b].Length > 0)
{
for (int v = 0; v < vecSize; v++)
{
dataWriter.Position = incr + v;
var column = spread.GetBinColumn(b, v);
for (int s = 0; s < column.Count - 1; s++)
{
dataWriter.Write(column[s + 1] - column[s], vecSize);
}
}
incr += spread[b].Length - vecSize;
binWriter.Write((spread[b].Length / vecSize) - 1, 1);
offWriter.Write(spread[b], 0, vecSize);
}
else
{
binWriter.Write(0, 1);
double[] zero = new double[vecSize];
offWriter.Write(zero, 0, vecSize);
}
}
}
}
else
{
FOutput.Length = FOutBin.Length = FOffset.Length;
}
}
}
#pragma warning restore
#endregion fields & pins
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
FInput.Sync();
FVec.Sync();
FBin.Sync();
if (FInput.IsChanged || FVec.IsChanged || FBin.IsChanged)
{
if (FInput.Length > 0 && FVec.Length > 0 && FBin.Length > 0)
{
int vecSize = Math.Max(1, FVec.GetReader().Read());
spread.Sync(FInput, vecSize, FBin);
FLast.Length = spread.NonEmptyBinCount * vecSize;
if (FLast.Length == spread.ItemCount || spread.ItemCount == 0)
{
FRemainder.Length = 0;
if (spread.ItemCount != 0)
{
FLast.AssignFrom(FInput);
}
else
{
FLast.Length = 0;
}
}
else
{
FRemainder.Length = spread.ItemCount - FLast.Length;
using (var rWriter = FRemainder.GetWriter())
using (var lWriter = FLast.GetWriter())
{
for (int b = 0; b < spread.Count; b++)
{
if (spread[b].Length > 0)
{
int rLength = spread[b].Length - vecSize;
rWriter.Write(spread[b], 0, rLength);
lWriter.Write(spread[b], rLength, vecSize);
}
}
}
}
}
else
{
FRemainder.Length = FLast.Length = 0;
}
}
}
#pragma warning restore
#endregion fields & pins
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
FInput.Sync();
FVec.Sync();
FBin.Sync();
if (FInput.IsChanged || FVec.IsChanged || FBin.IsChanged || FOffset.IsChanged || FInclOffset.IsChanged)
{
if (FInput.Length > 0 && FVec.Length > 0 && FBin.Length > 0 && FOffset.SliceCount > 0 && FInclOffset.SliceCount > 0)
{
int vecSize = Math.Max(1, FVec.GetReader().Read());
int offsetCount = (int)Math.Ceiling(FOffset.SliceCount / (double)vecSize);
offsetCount = offsetCount.CombineWith(FInclOffset);
spread.Sync(FInput, vecSize, FBin, offsetCount);
FOutBin.Length = spread.Count;
FOutput.Length = spread.ItemCount + (spread.Count * spread.VectorSize);
using (var binWriter = FOutBin.GetWriter())
using (var dataWriter = FOutput.GetWriter())
{
int incr = 0;
for (int b = 0; b < spread.Count; b++)
{
for (int v = 0; v < vecSize; v++)
{
dataWriter.Position = incr + v;
double sum = FOffset[b * vecSize + v];
if (FInclOffset[b])
{
dataWriter.Write(sum, vecSize);
}
double[] column = spread.GetBinColumn(b, v).ToArray();
for (int s = 0; s < column.Length; s++)
{
sum += column[s];
dataWriter.Write(sum, vecSize);
}
}
incr += spread[b].Length + (FInclOffset[b] ? vecSize:0);
binWriter.Write((spread[b].Length / vecSize) + 1, 1);
}
FOutput.Length = incr;
}
}
else
{
FOutput.Length = FOutBin.Length = 0;
}
}
}
#pragma warning restore
#endregion fields & pins
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
FInput.Sync();
FVec.Sync();
FBin.Sync();
if (FInput.IsChanged || FVec.IsChanged || FBin.IsChanged)
{
if (FVec.Length > 0)
{
int vecSize = Math.Max(1, FVec.GetReader().Read());
spread.Sync(FInput, vecSize, FBin);
FCenter.Length = FWidth.Length = FMin.Length = FMax.Length = spread.Count * vecSize;
using (var cWriter = FCenter.GetWriter())
using (var wWriter = FWidth.GetWriter())
using (var minWriter = FMin.GetWriter())
using (var maxWriter = FMax.GetWriter())
{
for (int b = 0; b < spread.Count; b++)
{
for (int v = 0; v < vecSize; v++)
{
if (spread[b].Length > 0)
{
double min = spread.GetBinColumn(b, v).Min();
double max = spread.GetBinColumn(b, v).Max();
double width = max - min;
cWriter.Write(max - width / 2);
wWriter.Write(width);
minWriter.Write(min);
maxWriter.Write(max);
}
else
{
cWriter.Write(double.NaN);
wWriter.Write(double.NaN);
minWriter.Write(double.MinValue);
maxWriter.Write(double.MaxValue);
}
}
}
}
}
else
{
FCenter.Length = FWidth.Length = FMin.Length = FMax.Length = 0;
}
}
}
#pragma warning restore
#endregion fields & pins
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
FInput.Sync();
FVec.Sync();
FBin.Sync();
FSelect.Sync();
if (FInput.IsChanged || FVec.IsChanged || FBin.IsChanged || FSelect.IsChanged)
{
if (FInput.Length > 0 && FVec.Length > 0 && FBin.Length > 0 && FSelect.Length > 0)
{
int vecSize = Math.Max(1, FVec.GetReader().Read());
spread.Sync(FInput, vecSize, FBin, FSelect.Length);
using (var selReader = FSelect.GetCyclicReader())
using (var outputWriter = FOutput.GetDynamicWriter())
using (var formerIdWriter = FFormer.GetDynamicWriter())
{
int offset = 0;
for (int b = 0; b < spread.Count; b++)
{
var data = spread[b];
int binSize = data.Length / vecSize;
int sel = selReader.Read();
if (sel > 0 && binSize > 0)
{
int[] ids = new int[binSize];
for (int i = 0; i < binSize; i++)
{
ids[i] = offset + i;
}
for (int s = 0; s < sel; s++)
{
outputWriter.Write(data, 0, data.Length);
formerIdWriter.Write(ids, 0, ids.Length);
}
}
offset += binSize;
}
}
}
else
{
FOutput.Length = FFormer.Length = 0;
}
}
}
#pragma warning restore
#endregion fields & pins
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
FInput.Sync();
FVec.Sync();
FBin.Sync();
if (FInput.IsChanged || FVec.IsChanged || FBin.IsChanged)
{
if (FInput.Length > 0 && FVec.Length > 0 && FBin.Length > 0)
{
int vecSize = Math.Max(1, FVec.GetReader().Read());
spread.Sync(FInput, vecSize, FBin);
if (spread.ItemCount == 0)
{
FOutput.Length = 0;
}
else
{
FOutput.Length = spread.Count * vecSize;
using (var dataWriter = FOutput.GetWriter())
for (int b = 0; b < spread.Count; b++)
{
if (spread[b].Length > 0)
{
for (int v = 0; v < vecSize; v++)
{
dataWriter.Write(spread.GetBinColumn(b, v).DefaultIfEmpty(1).Aggregate((work, next) => work * next), 1);
}
}
}
}
}
else
{
FOutput.Length = 0;
}
}
}
#pragma warning restore
#endregion fields & pins
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
FInput.Sync();
FVec.Sync();
FBin.Sync();
if (FInput.IsChanged || FVec.IsChanged || FBin.IsChanged || FReverse.IsChanged)
{
if (FVec.Length > 0)
{
int vecSize = Math.Max(1, FVec.GetReader().Read());
spread.Sync(FInput, vecSize, FBin, FReverse.SliceCount);
FOutput.Length = spread.ItemCount;
using (var dataWriter = FOutput.GetWriter())
{
for (int b = 0; b < spread.Count; b++)
{
if (FReverse[b])
{
for (int r = spread[b].Length - vecSize; r >= 0; r -= vecSize)
{
dataWriter.Write(spread[b], r, vecSize);
}
}
else
{
dataWriter.Write(spread[b], 0, spread[b].Length);
}
}
}
}
else
{
FOutput.Length = 0;
}
}
}
#pragma warning restore
#endregion fields & pins
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
FInput.Sync();
FVec.Sync();
FBin.Sync();
if (FInput.IsChanged || FVec.IsChanged || FBin.IsChanged || FClose.IsChanged)
{
if (FVec.Length > 0)
{
int vecSize = Math.Max(1, FVec.GetReader().Read());
spread.Sync(FInput, vecSize, FBin, FClose.SliceCount);
int outCount = 0;
for (int o = 0; o < spread.Count; o++)
{
int curCount = spread[o].Length * 2;
if (!FClose[o])
{
curCount -= 2 * spread.VectorSize;
}
outCount += Math.Max(curCount, 0);
}
FOutBin.Length = spread.Count;
FOutput.Length = outCount;
using (var binWriter = FOutBin.GetWriter())
using (var dataWriter = FOutput.GetWriter())
{
int incr = 0;
for (int b = 0; b < spread.Count; b++)
{
int c = FClose[b] ? 0:1;
int binSize = Math.Max((spread[b].Length / vecSize - c) * 2, 0);
if (spread[b].Length > 0)
{
for (int v = 0; v < vecSize; v++)
{
dataWriter.Position = incr + v;
double[] src = spread.GetBinColumn(b, v).ToArray();
int s = 0;
while (s < src.Length - 1)
{
dataWriter.Write(src[s], vecSize);
s++;
dataWriter.Write(src[s], vecSize);
}
if (FClose[b])
{
dataWriter.Write(src[s], vecSize);
dataWriter.Write(src[0], vecSize);
}
}
incr += binSize * vecSize;
}
binWriter.Write(binSize, 1);
}
FOutput.Length = incr;
}
}
else
{
FOutBin.Length = FOutput.Length = 0;
}
}
}
#pragma warning restore
#endregion fields & pins
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
FInput.Sync();
FVec.Sync();
FBin.Sync();
if (FInput.IsChanged || FVec.IsChanged || FBin.IsChanged || FTogPhase.IsChanged || FPhase.IsChanged)
{
if (FInput.Length > 0 && FVec.Length > 0 && FBin.Length > 0 && FTogPhase.SliceCount > 0 && FPhase.SliceCount > 0)
{
int vecSize = Math.Max(1, FVec.GetReader().Read());
spread.Sync(FInput, vecSize, FBin, FPhase.CombineWith(FTogPhase));
FOutBin.Length = spread.Count;
FOutput.Length = spread.ItemCount;
using (var binWriter = FOutBin.GetWriter())
using (var dataWriter = FOutput.GetWriter())
{
int incr = 0;
for (int b = 0; b < spread.Count; b++)
{
int phase = 0;
if (FTogPhase[b])
{
phase = (int)FPhase[b];
}
else
{
phase = (int)Math.Round(FPhase[b] * (spread[b].Length / vecSize));
}
if (spread[b].Length > 0)
{
for (int v = 0; v < vecSize; v++)
{
dataWriter.Position = incr + v;
double[] src = spread.GetBinColumn(b, v).ToArray();
phase = VMath.Zmod(phase, src.Length);
if (phase != 0)
{
double[] dst = new double[src.Length];
Array.Copy(src, 0, dst, phase, src.Length - phase);
Array.Copy(src, src.Length - phase, dst, 0, phase);
for (int s = 0; s < dst.Length; s++)
{
dataWriter.Write(dst[s], vecSize);
}
}
else
{
for (int s = 0; s < src.Length; s++)
{
dataWriter.Write(src[s], vecSize);
}
}
}
incr += spread[b].Length;
}
binWriter.Write((spread[b].Length / vecSize), 1);
}
}
}
else
{
FOutput.Length = FOutBin.Length = 0;
}
}
}
