public static NumericColumn Operation(NumericColumn c1, bool value) { if (c1.Kind.IsVector()) { throw new NotImplementedException(); } else { switch (c1.Kind.RawKind()) { case DataKind.BL: { bool[] a; DataColumn <bool> res; Operation(c1, out a, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, a[i] == value); } return(new NumericColumn(res)); } default: throw new DataTypeError(string.Format("{0} not implemented for column {1}.", OperationName, c1.Kind)); } } }
static void Operation <T1, T3>(NumericColumn c1, out T1[] a, out DataColumn <T3> res) where T1 : IEquatable <T1>, IComparable <T1> where T3 : IEquatable <T3>, IComparable <T3> { var c1o = c1.Column as DataColumn <T1>; if (c1o is null) { throw new DataTypeError(string.Format("{0} not implemented for type {1}.", OperationName, c1.GetType())); } res = new DataColumn <T3>(c1.Length); a = c1o.Data; }
public static NumericColumn Operation(NumericColumn c1, double value) { if (c1.Kind.IsVector()) { throw new NotImplementedException(); } else { switch (c1.Kind.RawKind()) { case DataKind.Int32: { int[] a; DataColumn <double> res; Operation(c1, out a, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, (int)a[i] - value); } return(new NumericColumn(res)); } case DataKind.Single: { float[] a; DataColumn <double> res; Operation(c1, out a, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, a[i] - value); } return(new NumericColumn(res)); } case DataKind.Double: { double[] a; DataColumn <double> res; Operation(c1, out a, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, a[i] - value); } return(new NumericColumn(res)); } default: throw new DataTypeError(string.Format("{0} not implemented for column {1}.", OperationName, c1.Kind)); } } }
static void Operation <T1, T2, T3>(NumericColumn c1, NumericColumn c2, out T1[] a, out T2[] b, out DataColumn <T3> res) where T1 : IEquatable <T1>, IComparable <T1> where T2 : IEquatable <T2>, IComparable <T2> where T3 : IEquatable <T3>, IComparable <T3> { var c1o = c1.Column as DataColumn <T1>; var c2o = c2.Column as DataColumn <T2>; if (c1o is null || c2o is null) { throw new DataTypeError(string.Format("{0} not implemented for {1}, {2}.", OperationName, c1.Kind, c2.Kind)); } res = new DataColumn <T3>(c1.Length); a = c1o.Data; b = c2o.Data; }
/// <summary> /// Returns a column. /// </summary> public DataFrameView this[NumericColumn rows, IEnumerable <string> colNames] { get { return(new DataFrameView(this, _data.EnumerateRowsIndex(rows), colNames.Select(c => _data.GetColumnIndex(c)))); } }
/// <summary> /// Returns a column. /// </summary> public DataFrameView this[NumericColumn rows, string colName] { get { return(new DataFrameView(this, _data.EnumerateRowsIndex(rows), new[] { _data.GetColumnIndex(colName) })); } }
/// <summary> /// Returns a subset of rows. /// </summary> public DataFrameView this[NumericColumn boolCol] { get { return(new DataFrameView(this, _data.EnumerateRowsIndex(boolCol), null)); } }
public static NumericColumn Operation(NumericColumn c1, NumericColumn c2) { if (c1.Kind.IsVector()) { throw new NotImplementedException(); } else { switch (c1.Kind.RawKind()) { case DataKind.Int32: if (c2.Kind.IsVector()) { throw new NotImplementedException(); } else { switch (c2.Kind.RawKind()) { case DataKind.Int32: { int[] a; int[] b; DataColumn <int> res; Operation(c1, c2, out a, out b, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, a[i] - b[i]); } return(new NumericColumn(res)); } case DataKind.Single: { int[] a; float[] b; DataColumn <float> res; Operation(c1, c2, out a, out b, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, (int)a[i] - b[i]); } return(new NumericColumn(res)); } default: throw new DataTypeError(string.Format("{0} not implemented for {1}, {2}.", OperationName, c1.Kind, c2.Kind)); } } case DataKind.Single: if (c2.Kind.IsVector()) { throw new NotImplementedException(); } else { switch (c2.Kind.RawKind()) { case DataKind.Int32: { float[] a; int[] b; DataColumn <float> res; Operation(c1, c2, out a, out b, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, a[i] - (int)b[i]); } return(new NumericColumn(res)); } case DataKind.Single: { float[] a; float[] b; DataColumn <float> res; Operation(c1, c2, out a, out b, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, a[i] - b[i]); } return(new NumericColumn(res)); } default: throw new DataTypeError(string.Format("{0} not implemented for {1}, {2}.", OperationName, c1.Kind, c2.Kind)); } } default: throw new DataTypeError(string.Format("{0} not implemented for {1} for left element.", OperationName, c1.Kind)); } } }
public static NumericColumn Operation(NumericColumn c1, NumericColumn c2) { if (c1.Kind.IsVector()) { throw new NotImplementedException(); } else { switch (c1.Kind.RawKind()) { case DataKind.BL: if (c2.Kind.IsVector()) { throw new NotImplementedException(); } else { switch (c2.Kind.RawKind()) { case DataKind.BL: { bool[] a; bool[] b; DataColumn <bool> res; Operation(c1, c2, out a, out b, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, a[i] == b[i]); } return(new NumericColumn(res)); } default: throw new DataTypeError(string.Format("{0} not implemented for {1}, {2}.", OperationName, c1.Kind, c2.Kind)); } } case DataKind.I4: if (c2.Kind.IsVector()) { throw new NotImplementedException(); } else { switch (c2.Kind.RawKind()) { case DataKind.I4: { int[] a; int[] b; DataColumn <bool> res; Operation(c1, c2, out a, out b, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, a[i] == b[i]); } return(new NumericColumn(res)); } case DataKind.R4: { int[] a; float[] b; DataColumn <bool> res; Operation(c1, c2, out a, out b, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, (int)a[i] == b[i]); } return(new NumericColumn(res)); } default: throw new DataTypeError(string.Format("{0} not implemented for {1}, {2}.", OperationName, c1.Kind, c2.Kind)); } } case DataKind.R4: if (c2.Kind.IsVector()) { throw new NotImplementedException(); } else { switch (c2.Kind.RawKind()) { case DataKind.I4: { float[] a; int[] b; DataColumn <bool> res; Operation(c1, c2, out a, out b, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, a[i] == (int)b[i]); } return(new NumericColumn(res)); } case DataKind.R4: { float[] a; float[] b; DataColumn <bool> res; Operation(c1, c2, out a, out b, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, a[i] == b[i]); } return(new NumericColumn(res)); } default: throw new DataTypeError(string.Format("{0} not implemented for {1}, {2}.", OperationName, c1.Kind, c2.Kind)); } } case DataKind.TX: if (c2.Kind.IsVector()) { throw new NotImplementedException(); } else { switch (c2.Kind.RawKind()) { case DataKind.TX: { DvText[] a; DvText[] b; DataColumn <bool> res; Operation(c1, c2, out a, out b, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, a[i].CompareTo(b[i]) == 0); } return(new NumericColumn(res)); } default: throw new DataTypeError(string.Format("{0} not implemented for {1}, {2}.", OperationName, c1.Kind, c2.Kind)); } } default: throw new DataTypeError(string.Format("{0} not implemented for {1} for left element.", OperationName, c1.Kind)); } } }
public static NumericColumn Operation(NumericColumn c1, ReadOnlyMemory <char> value) { return(Operation(c1, new DvText(value))); }
public static NumericColumn Operation(NumericColumn c1, string value) { return(Operation(c1, new DvText(value))); }
public static NumericColumn Operation(NumericColumn c1, int value) { if (c1.Kind.IsVector()) { throw new NotImplementedException(); } else { switch (c1.Kind.RawKind()) { case DataKind.I4: { int[] a; DataColumn <bool> res; Operation(c1, out a, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, a[i] /**/ < value); } return(new NumericColumn(res)); } case DataKind.I8: { long[] a; DataColumn <bool> res; Operation(c1, out a, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, a[i] /**/ < value); } return(new NumericColumn(res)); } case DataKind.R4: { float[] a; DataColumn <bool> res; Operation(c1, out a, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, a[i] /**/ < (float)value); } return(new NumericColumn(res)); } case DataKind.R8: { double[] a; DataColumn <bool> res; Operation(c1, out a, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, a[i] /**/ < (double)value); } return(new NumericColumn(res)); } default: throw new DataTypeError(string.Format("{0} not implemented for column {1}.", OperationName, c1.Kind)); } } }
public static NumericColumn Operation(NumericColumn c1, double value) { if (c1.Kind.IsVector()) { throw new NotImplementedException(); } else { switch (c1.Kind.RawKind()) { case DataKind.I4: { int[] a; DataColumn <bool> res; Operation(c1, out a, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, (int)a[i] /**/ < value); } return(new NumericColumn(res)); } case DataKind.R4: { float[] a; DataColumn <bool> res; Operation(c1, out a, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, a[i] /**/ < value); } return(new NumericColumn(res)); } case DataKind.R8: { double[] a; DataColumn <bool> res; Operation(c1, out a, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, a[i] /**/ < value); } return(new NumericColumn(res)); } default: throw new DataTypeError(string.Format("{0} not implemented for column {1}.", OperationName, c1.Kind)); } } } public static NumericColumn Operation(NumericColumn c1, string value) { return(Operation(c1, new DvText(value))); } public static NumericColumn Operation(NumericColumn c1, ReadOnlyMemory <char> value) { return(Operation(c1, new DvText(value))); } public static NumericColumn Operation(NumericColumn c1, DvText value) { if (c1.Kind.IsVector()) { throw new NotImplementedException(); } else { switch (c1.Kind.RawKind()) { case DataKind.TX: { DvText[] a; DataColumn <bool> res; Operation(c1, out a, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, string.Compare(a[i].ToString(), value.ToString()) /**/ < 0); } return(new NumericColumn(res)); } default: throw new DataTypeError(string.Format("{0} not implemented for column {1}.", OperationName, c1.Kind)); } } }
public static NumericColumn Operation(NumericColumn c1, bool value) { if (c1.Kind.IsVector()) { throw new NotImplementedException(); } else { switch (c1.Kind.RawKind()) { case DataKind.Boolean: { bool[] a; DataColumn <bool> res; Operation(c1, out a, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, a[i] /**/ & value); } return(new NumericColumn(res)); } default: throw new DataTypeError(string.Format("{0} not implemented for column {1}.", OperationName, c1.Kind)); } } } #endregion #region Operation between two columns. static void Operation <T1, T2, T3>(NumericColumn c1, NumericColumn c2, out T1[] a, out T2[] b, out DataColumn <T3> res) where T1 : IEquatable <T1>, IComparable <T1> where T2 : IEquatable <T2>, IComparable <T2> where T3 : IEquatable <T3>, IComparable <T3> { var c1o = c1.Column as DataColumn <T1>; var c2o = c2.Column as DataColumn <T2>; if (c1o is null || c2o is null) { throw new DataTypeError(string.Format("{0} not implemented for {1}, {2}.", OperationName, c1.Kind, c2.Kind)); } res = new DataColumn <T3>(c1.Length); a = c1o.Data; b = c2o.Data; } public static NumericColumn Operation(NumericColumn c1, NumericColumn c2) { if (c1.Kind.IsVector()) { throw new NotImplementedException(); } else { switch (c1.Kind.RawKind()) { case DataKind.Boolean: if (c2.Kind.IsVector()) { throw new NotImplementedException(); } else { switch (c2.Kind.RawKind()) { case DataKind.Boolean: { bool[] a; bool[] b; DataColumn <bool> res; Operation(c1, c2, out a, out b, out res); for (int i = 0; i < res.Length; ++i) { res.Set(i, a[i] /**/ & b[i]); } return(new NumericColumn(res)); } default: throw new DataTypeError(string.Format("{0} not implemented for {1}, {2}.", OperationName, c1.Kind, c2.Kind)); } }