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); }