public void SetDataArray(DataArray<double> array)
{
if (array == null)
{
throw new ArgumentNullException("array", "DataArray<double> cannot be null.");
}
_data = array;
}
static private int[] prevType = new int[4] { -1, -1, -1, -1 }; //to force update at start
/// <summary>
/// Used to change the address of the Ardunio
/// WARNING: don't use it except if you really know what you are doing
/// </summary>
/// <param name="OldAddr">old address</param>
/// <param name="NewAddr">new address</param>
/// <returns></returns>
private async Task<bool> BrickPiChangeAddress(byte OldAddr, byte NewAddr)
{
DataArray dataArray = new DataArray();
dataArray.myArray[BYTE_MSG_TYPE] = MSG_TYPE_CHANGE_ADDR;
dataArray.myArray[BYTE_NEW_ADDRESS] = NewAddr;
BrickPiTx(OldAddr, 2, dataArray.myArray);
byte[] InArray = await BrickPiRx(5);
byte[] OutArray;
return CheckRetMessage(InArray, MSG_TYPE_CHANGE_ADDR, out OutArray);
}
public void SetDataArray(DataArray<double> top, DataArray<double> bottom)
{
if (top == null)
{
throw new ArgumentNullException("top", "DataArray cannot be null.");
}
if (bottom == null)
{
throw new ArgumentNullException("bottom", "DataArray cannot be null.");
}
if ((top.Count != bottom.Count) || (top.StartIndex != bottom.StartIndex))
{
throw new ArgumentException("The top and bottom arrays do not match.");
}
_top = top;
_bottom = bottom;
}
public static DataArray<double> Abs(DataArray<double> data)
{
if (data == null)
{
throw new ArgumentNullException("data", "DataArray must not be null.");
}
var array = new DataArray<double>(data.Count);
for (int i = 0; i < data.StartIndex; i++)
{
array.Add(0.0);
}
for (int j = data.StartIndex; j < data.Count; j++)
{
array.Add(Math.Abs(data[j]));
}
array.StartIndex = data.StartIndex;
return array;
}
public static DataArray<double> Cumulate(DataArray<double> data)
{
if (data == null)
{
throw new ArgumentNullException("data", "DataArray must not be null.");
}
var array = new DataArray<double>(data.Count);
for (int i = 0; i < data.StartIndex; i++)
{
array.Add(0.0);
}
if (data.StartIndex < data.Count)
{
array.Add(data[data.StartIndex]);
for (int j = data.StartIndex + 1; j < data.Count; j++)
{
array.Add(data[j] + array[j - 1]);
}
}
array.StartIndex = data.StartIndex;
return array;
}
/// <summary>
/// Set a new timeout on the brick
/// </summary>
/// <returns>true if all worked</returns>
private async Task<bool> BrickPiSetTimeout()
{
DataArray dataArray = new DataArray();
bool retval = false;
for (int i = 0; i < 2; i++)
{
dataArray.myArray[BYTE_MSG_TYPE] = MSG_TYPE_TIMEOUT_SETTINGS;
dataArray.myArray[BYTE_TIMEOUT] = (byte)(brickPi.Timeout & 0xFF);
dataArray.myArray[BYTE_TIMEOUT + 1] = (byte)((brickPi.Timeout / 256) & 0xFF);
dataArray.myArray[BYTE_TIMEOUT + 2] = (byte)((brickPi.Timeout / 65536) & 0xFF);
dataArray.myArray[BYTE_TIMEOUT + 3] = (byte)((brickPi.Timeout / 16777216) & 0xFF);
BrickPiTx(brickPi.Address[i], 5, dataArray.myArray);
// IMPORTANT: theoritical timeout is 2.5 ms
// Working all the time with 20
byte[] InArray = await BrickPiRx(20); //0.002500
if (InArray == null)
return false;
if ((InArray[0] == MSG_TYPE_TIMEOUT_SETTINGS) && (InArray.Length == 1))
return true;
}
return retval;
}
public static DataArray<double> Xor(DataArray<double> data, double value)
{
return PerformLogicalOperation(data, value, LogicalOperation.Xor);
}
public static DataArray<double> Xor(DataArray<double> data1, DataArray<double> data2)
{
return PerformLogicalOperation(data1, data2, LogicalOperation.Xor);
}
public static DataArray<double> Variance(StockSeriesData data, int periods)
{
if (data == null)
{
throw new ArgumentNullException("data", "DataArray<double> must not be null.");
}
if (periods <= 0)
{
throw new ArgumentOutOfRangeException("periods", "Periods must not be negative or zero.");
}
var array = new DataArray<double>(data.Count);
int num = (((data.StartIndex + periods) - 1) < data.Count) ? ((data.StartIndex + periods) - 1) : data.Count;
for (int i = 0; i < num; i++)
{
array.Add(0.0);
}
if (num < data.Count)
{
double num3 = 0.0;
double num4 = 0.0;
for (int j = data.StartIndex; j < (data.StartIndex + periods); j++)
{
num3 += (double)data[j].close;
num4 += (double)(data[j].close * data[j].close);
}
array.Add((num4 / (periods)) - ((num3 / (periods)) * (num3 / (periods))));
for (int k = num + 1; k < data.Count; k++)
{
num3 = (num3 - (double)data[k - periods].close) + (double)data[k].close;
num4 = (num4 - (double)(data[k - periods].close * data[k - periods].close)) + (double)(data[k].close * data[k].close);
array.Add((num4 / (periods)) - ((num3 / (periods)) * (num3 / (periods))));
}
}
array.StartIndex = num;
return array;
}
public static T Deserialize <T>(this DataArray array) where T : IDataSerializable, new()
{
var obj = new T();
var properties = obj.GetType().GetProperties();
foreach (var field in properties)
{
var name = CamelToSnake(field.Name);
var value = array.Array(name);
if (value == null && !IsNullable(field.PropertyType))
{
throw new InvalidDataException("Data array is missing field: " + name);
}
if (field.PropertyType.IsGenericType)
{
var gtd = field.PropertyType.GetGenericTypeDefinition();
var args = field.PropertyType.GetGenericArguments();
if (gtd == typeof(List <>))
{
// Add list elements
if (!typeof(IDataSerializable).IsAssignableFrom(args[0]))
{
throw new NotImplementedException("Cannot handle non-serializable types in lists yet");
}
object list = Activator.CreateInstance(field.PropertyType);
field.SetValue(obj, list, null);
MethodInfo method = typeof(IDataSerializableExtensions).GetMethod(nameof(Deserialize));
MethodInfo generic = method.MakeGenericMethod(args[0]);
foreach (var c in value.Children)
{
if (c is DataArray da)
{
((IList)list).Add(generic.Invoke(null, new[] { da }));
}
}
}
else if (gtd == typeof(Dictionary <,>))
{
// Add dictionary elements
if (args[0] != typeof(string))
{
throw new NotImplementedException("Cannot serialize dictionaries with non-string keys");
}
if (!typeof(IDataSerializable).IsAssignableFrom(args[1]))
{
throw new NotImplementedException("Cannot handle non-serializable types in dictionaries yet");
}
object list = Activator.CreateInstance(field.PropertyType);
field.SetValue(obj, list, null);
MethodInfo method = typeof(IDataSerializableExtensions).GetMethod(nameof(Deserialize));
MethodInfo generic = method.MakeGenericMethod(args[1]);
foreach (var c in value.Children)
{
if (c is DataArray da)
{
((IDictionary)list).Add(da.Any(0), generic.Invoke(null, new[] { da }));
}
}
}
else if (gtd == typeof(Tuple <,>))
{
MethodInfo method = typeof(Tuple).GetMethods().First(x => x.Name == nameof(Tuple.Create) && x.GetParameters().Length == 2);
MethodInfo generic = method.MakeGenericMethod(args[0], args[1]);
field.SetValue(obj, generic.Invoke(null, new[] { DeserializeNode(value.Node(1)), DeserializeNode(value.Node(2)) }), null);
}
else if (gtd == typeof(Nullable <>))
{
if (value != null)
{
field.SetValue(obj, DeserializeNode(value.Node(1)), null);
}
}
else
{
throw new NotImplementedException($"Generic type deserialization for {field.PropertyType.FullName} not yet implemented");
}
}
else
{
if (typeof(IDataSerializable).IsAssignableFrom(field.PropertyType))
{
MethodInfo method = typeof(IDataSerializableExtensions).GetMethod(nameof(Deserialize));
MethodInfo generic = method.MakeGenericMethod(field.PropertyType);
field.SetValue(obj, generic.Invoke(null, new[] { value }), null);
}
else if (field.PropertyType.IsEnum)
{
var enumName = SnakeToCamel(value.String(1));
field.SetValue(obj, Enum.Parse(field.PropertyType, enumName, true), null);
}
else
{
field.SetValue(obj, DeserializeNode(value.Node(1)), null);
}
}
}
return(obj);
}
public static DataArray Serialize(this IDataSerializable obj)
{
var array = new DataArray();
foreach (var field in obj.GetType().GetProperties())
{
var name = CamelToSnake(field.Name);
if (field.PropertyType.IsGenericType)
{
var gtd = field.PropertyType.GetGenericTypeDefinition();
var args = field.PropertyType.GetGenericArguments();
if (gtd == typeof(List <>))
{
// Add list elements
if (!typeof(IDataSerializable).IsAssignableFrom(args[0]))
{
throw new NotImplementedException("Cannot handle non-serializable types in lists yet");
}
var listArray = new DataArray();
var value = (IList)field.GetValue(obj, null);
var typename = CamelToSnake(args[0].Name);
var namedValues = field.GetCustomAttributes(typeof(AnonymousListAttribute), true).Length == 0;
foreach (var f in value)
{
var valueNode = SerializeObject(f);
listArray.AddNode(namedValues ? NamedItem(typename, valueNode) : valueNode);
}
array.AddNode(NamedItem(name, listArray));
}
else if (gtd == typeof(Dictionary <,>))
{
// Add dictionary elements
if (args[0] != typeof(string))
{
throw new NotImplementedException("Cannot serialize dictionaries with non-string keys");
}
if (!typeof(IDataSerializable).IsAssignableFrom(args[1]))
{
throw new NotImplementedException("Cannot handle non-serializable types in dictionaries yet");
}
var dictArray = new DataArray();
var value = (IDictionary)field.GetValue(obj, null);
foreach (var k in value.Keys)
{
dictArray.AddNode(NamedItem((string)k, SerializeObject(value[k])));
}
array.AddNode(NamedItem(name, dictArray));
}
else if (gtd == typeof(Tuple <,>))
{
var tupleArray = new DataArray();
tupleArray.AddNode(new DataAtom(name));
var tuple = field.GetValue(obj, null) as ITuple;
for (var i = 0; i < tuple.Length; i++)
{
tupleArray.AddNode(SerializeObject(tuple[i]));
}
array.AddNode(tupleArray);
}
else if (gtd == typeof(Nullable <>))
{
var value = field.GetValue(obj, null);
if (value != null)
{
array.AddNode(NamedItem(name, SerializeObject(value)));
}
}
else
{
throw new NotImplementedException("Generic type support for " + field.PropertyType.FullName + " not implemented");
}
}
else
{
array.AddNode(NamedItem(name, SerializeObject(field.GetValue(obj, null))));
}
}
return(array);
}
internal Compiler(Project.ProjectState state) : base(state.Engine)
{
OwnerState = state;
DynamicTagGroups = new DataArray();
Strings = new Util.StringPool(true, CalculateStringPoolBaseAddress());
InitializeTypeIndicies();
}
private void CreateTable_NativeObjects(List <APITable> tables)
{
APITable table = new APITable(this, m_Snapshot, m_Snapshot.nativeObjects.dataSet);
table.AddColumn(
new MetaColumn("name", "name", typeof(string), false, Grouping.groupByDuplicate, null)
, DataArray.MakeColumn(m_Snapshot.nativeObjects.objectName)
);
table.AddColumn(
new MetaColumn("instanceId", "instanceId", typeof(int), true, Grouping.groupByDuplicate, null)
, DataArray.MakeColumn(m_Snapshot.nativeObjects.instanceId)
);
table.AddColumn(
new MetaColumn("size", "size", typeof(ulong), false, Grouping.groupByDuplicate
, Grouping.GetMergeAlgo(Grouping.MergeAlgo.sum, typeof(ulong)), "size")
, DataArray.MakeColumn(m_Snapshot.nativeObjects.size)
);
table.AddColumn(
new MetaColumn("nativeObjectAddress", "nativeObjectAddress", typeof(ulong), false, Grouping.groupByDuplicate, null)
, DataArray.MakeColumn(m_Snapshot.nativeObjects.nativeObjectAddress)
);
table.AddColumn(
new MetaColumn("rootReferenceId", "rootReferenceId", typeof(long), false, Grouping.groupByDuplicate, null)
, DataArray.MakeColumn(m_Snapshot.nativeObjects.rootReferenceId)
);
table.AddColumn(
new MetaColumn("nativeTypeArrayIndex", "nativeTypeArrayIndex", typeof(int), false, Grouping.groupByDuplicate, null)
, DataArray.MakeColumn(m_Snapshot.nativeObjects.nativeTypeArrayIndex)
);
table.AddColumn(
new MetaColumn("isPersistent", "isPersistent", typeof(bool), false, Grouping.groupByDuplicate, null)
, DataArray.MakeColumn_Transform(m_Snapshot.nativeObjects.flags, (a) => HasBit(a, ObjectFlags.IsPersistent), (ref ObjectFlags o, bool v) => SetBit(ref o, ObjectFlags.IsPersistent, v))
);
table.AddColumn(
new MetaColumn("isDontDestroyOnLoad", "isDontDestroyOnLoad", typeof(bool), false, Grouping.groupByDuplicate, null)
, DataArray.MakeColumn_Transform(m_Snapshot.nativeObjects.flags, (a) => HasBit(a, ObjectFlags.IsDontDestroyOnLoad), (ref ObjectFlags o, bool v) => SetBit(ref o, ObjectFlags.IsDontDestroyOnLoad, v))
);
table.AddColumn(
new MetaColumn("isManager", "isManager", typeof(bool), false, Grouping.groupByDuplicate, null)
, DataArray.MakeColumn_Transform(m_Snapshot.nativeObjects.flags, (a) => HasBit(a, ObjectFlags.IsManager), (ref ObjectFlags o, bool v) => SetBit(ref o, ObjectFlags.IsManager, v))
);
table.AddColumn(
new MetaColumn("HideInHierarchy", "HideInHierarchy", typeof(bool), false, Grouping.groupByDuplicate, null)
, DataArray.MakeColumn_Transform(m_Snapshot.nativeObjects.hideFlags, (a) => HasBit(a, HideFlags.HideInHierarchy), (ref HideFlags o, bool v) => SetBit(ref o, HideFlags.HideInHierarchy, v))
);
table.AddColumn(
new MetaColumn("HideInInspector", "HideInInspector", typeof(bool), false, Grouping.groupByDuplicate, null)
, DataArray.MakeColumn_Transform(m_Snapshot.nativeObjects.hideFlags, (a) => HasBit(a, HideFlags.HideInInspector), (ref HideFlags o, bool v) => SetBit(ref o, HideFlags.HideInInspector, v))
);
table.AddColumn(
new MetaColumn("DontSaveInEditor", "DontSaveInEditor", typeof(bool), false, Grouping.groupByDuplicate, null)
, DataArray.MakeColumn_Transform(m_Snapshot.nativeObjects.hideFlags, (a) => HasBit(a, HideFlags.DontSaveInEditor), (ref HideFlags o, bool v) => SetBit(ref o, HideFlags.DontSaveInEditor, v))
);
table.AddColumn(
new MetaColumn("NotEditable", "NotEditable", typeof(bool), false, Grouping.groupByDuplicate, null)
, DataArray.MakeColumn_Transform(m_Snapshot.nativeObjects.hideFlags, (a) => HasBit(a, HideFlags.NotEditable), (ref HideFlags o, bool v) => SetBit(ref o, HideFlags.NotEditable, v))
);
table.AddColumn(
new MetaColumn("DontSaveInBuild", "DontSaveInBuild", typeof(bool), false, Grouping.groupByDuplicate, null)
, DataArray.MakeColumn_Transform(m_Snapshot.nativeObjects.hideFlags, (a) => HasBit(a, HideFlags.DontSaveInBuild), (ref HideFlags o, bool v) => SetBit(ref o, HideFlags.DontSaveInBuild, v))
);
table.AddColumn(
new MetaColumn("DontUnloadUnusedAsset", "DontUnloadUnusedAsset", typeof(bool), false, Grouping.groupByDuplicate, null)
, DataArray.MakeColumn_Transform(m_Snapshot.nativeObjects.hideFlags, (a) => HasBit(a, HideFlags.DontUnloadUnusedAsset), (ref HideFlags o, bool v) => SetBit(ref o, HideFlags.DontUnloadUnusedAsset, v))
);
table.CreateTable(kPrefixTableName + "NativeObject", kPrefixTableDisplayName + "Native Object");
AddTable(table, tables);
}
private static DataArray<double> PerformRelationalOperation(DataArray<double> data1, DataArray<double> data2,
RelationalOperation operation)
{
if (data1 == null)
{
throw new ArgumentNullException("data1", "DataArray<double> must not be null.");
}
if (data2 == null)
{
throw new ArgumentNullException("data2", "DataArray<double> must not be null.");
}
if (data1.Count != data2.Count)
{
throw new ArgumentException("Array sizes do not match.", "data1");
}
var array = new DataArray<double>(data1.Count);
DataArray<double> array2 = data2;
if (data1.StartIndex > data2.StartIndex)
{
array2 = data1;
}
for (int i = 0; i < array2.StartIndex; i++)
{
array.Add(0.0);
}
switch (operation)
{
case RelationalOperation.Equal:
for (int j = array2.StartIndex; j < array2.Count; j++)
{
array.Add(Convert.ToDouble(data1[j] == data2[j]));
}
break;
case RelationalOperation.NotEqual:
for (int k = array2.StartIndex; k < array2.Count; k++)
{
array.Add(Convert.ToDouble(data1[k] != data2[k]));
}
break;
case RelationalOperation.Greater:
for (int m = array2.StartIndex; m < array2.Count; m++)
{
array.Add(Convert.ToDouble(data1[m] > data2[m]));
}
break;
case RelationalOperation.GreaterEqual:
for (int n = array2.StartIndex; n < array2.Count; n++)
{
array.Add(Convert.ToDouble(data1[n] >= data2[n]));
}
break;
case RelationalOperation.Less:
for (int num6 = array2.StartIndex; num6 < array2.Count; num6++)
{
array.Add(Convert.ToDouble(data1[num6] < data2[num6]));
}
break;
case RelationalOperation.LessEqual:
for (int num7 = array2.StartIndex; num7 < array2.Count; num7++)
{
array.Add(Convert.ToDouble(data1[num7] <= data2[num7]));
}
break;
}
array.StartIndex = array2.StartIndex;
return array;
}
private static DataArray<double> PerformLogicalOperation(DataArray<double> data, double value, LogicalOperation operation)
{
if (data == null)
{
throw new ArgumentNullException("data", "DataArray<double> must not be null.");
}
var array = new DataArray<double>(data.Count);
for (int i = 0; i < data.StartIndex; i++)
{
array.Add(0.0);
}
switch (operation)
{
case LogicalOperation.Not:
for (int j = data.StartIndex; j < data.Count; j++)
{
array.Add(Convert.ToDouble(data[j] == 0.0));
}
break;
case LogicalOperation.And:
for (int k = data.StartIndex; k < data.Count; k++)
{
array.Add(Convert.ToDouble((data[k] != 0.0) && (value != 0.0)));
}
break;
case LogicalOperation.Or:
for (int m = data.StartIndex; m < data.Count; m++)
{
array.Add(Convert.ToDouble((data[m] != 0.0) || (value != 0.0)));
}
break;
case LogicalOperation.Xor:
for (int n = data.StartIndex; n < data.Count; n++)
{
array.Add(Convert.ToDouble((data[n] != 0.0) ^ (value != 0.0)));
}
break;
}
array.StartIndex = data.StartIndex;
return array;
}
private static DataArray<double> PerformArithmeticOperation(DataArray<double> data, double value, ArithmeticOperation operation)
{
if (data == null)
{
throw new ArgumentNullException("data", "DataArray<double> must not be null.");
}
var array = new DataArray<double>(data.Count);
for (int i = 0; i < data.StartIndex; i++)
{
array.Add(0.0);
}
switch (operation)
{
case ArithmeticOperation.Negation:
for (int j = data.StartIndex; j < data.Count; j++)
{
array.Add(-data[j]);
}
break;
case ArithmeticOperation.Addition:
for (int k = data.StartIndex; k < data.Count; k++)
{
array.Add(data[k] + value);
}
break;
case ArithmeticOperation.Subtraction:
for (int m = data.StartIndex; m < data.Count; m++)
{
array.Add(data[m] - value);
}
break;
case ArithmeticOperation.Multiplication:
for (int n = data.StartIndex; n < data.Count; n++)
{
array.Add(data[n] * value);
}
break;
case ArithmeticOperation.Division:
for (int num6 = data.StartIndex; num6 < data.Count; num6++)
{
array.Add(data[num6] / value);
}
break;
case ArithmeticOperation.Modulus:
for (int num7 = data.StartIndex; num7 < data.Count; num7++)
{
array.Add(data[num7] % value);
}
break;
case ArithmeticOperation.Power:
for (int num8 = data.StartIndex; num8 < data.Count; num8++)
{
array.Add(Math.Pow(data[num8], value));
}
break;
}
array.StartIndex = data.StartIndex;
return array;
}
public static DataArray<double> Multiply(DataArray<double> data1, DataArray<double> data2)
{
return PerformArithmeticOperation(data1, data2, ArithmeticOperation.Multiplication);
}
public static DataArray<double> Mod(DataArray<double> data, double value)
{
return PerformArithmeticOperation(data, value, ArithmeticOperation.Modulus);
}
public static DataArray<double> Mod(DataArray<double> data1, DataArray<double> data2)
{
return PerformArithmeticOperation(data1, data2, ArithmeticOperation.Modulus);
}
private static DataArray<double> PerformArithmeticOperation(DataArray<double> data1, DataArray<double> data2,
ArithmeticOperation operation)
{
if (data1 == null)
{
throw new ArgumentNullException("data1", "DataArray<double> must not be null.");
}
if (data2 == null)
{
throw new ArgumentNullException("data2", "DataArray<double> must not be null.");
}
if (data1.Count != data2.Count)
{
throw new ArgumentException("Array sizes do not match.", "data1");
}
var array = new DataArray<double>(data1.Count);
DataArray<double> array2 = data2;
if (data1.StartIndex > data2.StartIndex)
{
array2 = data1;
}
for (int i = 0; i < array2.StartIndex; i++)
{
array.Add(0.0);
}
switch (operation)
{
case ArithmeticOperation.Addition:
for (int j = array2.StartIndex; j < array2.Count; j++)
{
array.Add(data1[j] + data2[j]);
}
break;
case ArithmeticOperation.Subtraction:
for (int k = array2.StartIndex; k < array2.Count; k++)
{
array.Add(data1[k] - data2[k]);
}
break;
case ArithmeticOperation.Multiplication:
for (int m = array2.StartIndex; m < array2.Count; m++)
{
array.Add(data1[m] * data2[m]);
}
break;
case ArithmeticOperation.Division:
for (int n = array2.StartIndex; n < array2.Count; n++)
{
array.Add(data1[n] / data2[n]);
}
break;
case ArithmeticOperation.Modulus:
for (int num6 = array2.StartIndex; num6 < array2.Count; num6++)
{
array.Add(data1[num6] % data2[num6]);
}
break;
case ArithmeticOperation.Power:
for (int num7 = array2.StartIndex; num7 < array2.Count; num7++)
{
array.Add(Math.Pow(data1[num7], data2[num7]));
}
break;
}
array.StartIndex = array2.StartIndex;
return array;
}
private static DataArray<double> PerformRelationalOperation(DataArray<double> data, double value, RelationalOperation operation)
{
if (data == null)
{
throw new ArgumentNullException("data", "DataArray<double> must not be null.");
}
var array = new DataArray<double>(data.Count);
for (int i = 0; i < data.StartIndex; i++)
{
array.Add(0.0);
}
switch (operation)
{
case RelationalOperation.Equal:
for (int j = data.StartIndex; j < data.Count; j++)
{
array.Add(Convert.ToDouble(data[j] == value));
}
break;
case RelationalOperation.NotEqual:
for (int k = data.StartIndex; k < data.Count; k++)
{
array.Add(Convert.ToDouble(data[k] != value));
}
break;
case RelationalOperation.Greater:
for (int m = data.StartIndex; m < data.Count; m++)
{
array.Add(Convert.ToDouble(data[m] > value));
}
break;
case RelationalOperation.GreaterEqual:
for (int n = data.StartIndex; n < data.Count; n++)
{
array.Add(Convert.ToDouble(data[n] >= value));
}
break;
case RelationalOperation.Less:
for (int num6 = data.StartIndex; num6 < data.Count; num6++)
{
array.Add(Convert.ToDouble(data[num6] < value));
}
break;
case RelationalOperation.LessEqual:
for (int num7 = data.StartIndex; num7 < data.Count; num7++)
{
array.Add(Convert.ToDouble(data[num7] <= value));
}
break;
}
array.StartIndex = data.StartIndex;
return array;
}
public static DataArray<double> Multiply(DataArray<double> data, double value)
{
return PerformArithmeticOperation(data, value, ArithmeticOperation.Multiplication);
}
public ChunkSectionCompactStorage(DataArray data, NibbleArray blockLight, NibbleArray skyLight)
{
Data = data;
BlockLight = blockLight;
SkyLight = skyLight;
}
private static DataArray<double> PerformLogicalOperation(DataArray<double> data1, DataArray<double> data2, LogicalOperation operation)
{
if (data1 == null)
{
throw new ArgumentNullException("data1", "DataArray<double> must not be null.");
}
if (data2 == null)
{
throw new ArgumentNullException("data2", "DataArray<double> must not be null.");
}
if (data1.Count != data2.Count)
{
throw new ArgumentException("Array sizes do not match.", "data1");
}
var array = new DataArray<double>(data1.Count);
DataArray<double> array2 = data2;
if (data1.StartIndex > data2.StartIndex)
{
array2 = data1;
}
for (int i = 0; i < array2.StartIndex; i++)
{
array.Add(0.0);
}
switch (operation)
{
case LogicalOperation.And:
for (int j = array2.StartIndex; j < array2.Count; j++)
{
array.Add(Convert.ToDouble((data1[j] != 0.0) && (data2[j] != 0.0)));
}
break;
case LogicalOperation.Or:
for (int k = array2.StartIndex; k < array2.Count; k++)
{
array.Add(Convert.ToDouble((data1[k] != 0.0) || (data2[k] != 0.0)));
}
break;
case LogicalOperation.Xor:
for (int m = array2.StartIndex; m < array2.Count; m++)
{
array.Add(Convert.ToDouble((data1[m] != 0.0) ^ (data2[m] != 0.0)));
}
break;
}
array.StartIndex = array2.StartIndex;
return array;
}
public static DataArray<double> Neg(DataArray<double> data)
{
return PerformArithmeticOperation(data, 0.0, ArithmeticOperation.Negation);
}
public static DataArray<double> Not(DataArray<double> data)
{
return PerformLogicalOperation(data, 0.0, LogicalOperation.Not);
}
public static DataArray<double> Pow(DataArray<double> data1, DataArray<double> data2)
{
return PerformArithmeticOperation(data1, data2, ArithmeticOperation.Power);
}
public static DataArray<double> Divide(DataArray<double> data1, DataArray<double> data2)
{
return PerformArithmeticOperation(data1, data2, ArithmeticOperation.Division);
}
public static DataArray<double> Pow(DataArray<double> data, double value)
{
return PerformArithmeticOperation(data, value, ArithmeticOperation.Power);
}
public static DataArray<double> Divide(DataArray<double> data, double value)
{
return PerformArithmeticOperation(data, value, ArithmeticOperation.Division);
}
public static DataArray<double> Subtract(DataArray<double> data1, DataArray<double> data2)
{
return PerformArithmeticOperation(data1, data2, ArithmeticOperation.Subtraction);
}
public override void Reset()
{
base.Reset();
DynamicTagGroups = new DataArray();
Strings = new Util.StringPool(true, CalculateStringPoolBaseAddress());
}
public static DataArray<double> Subtract(DataArray<double> data, double value)
{
return PerformArithmeticOperation(data, value, ArithmeticOperation.Subtraction);
}
public BarArray()
{
BarSeries = new DataArray();
}
private VisualizerBase GetVisualyzerColumn(DataArray dataArray, RectTransform containerRect, Settings settings)
{
ColumnVisualizer visualizer = new ColumnVisualizer(columnSettings, dataArray, containerRect, settings);
return(visualizer);
}
