public IDataColumn Aggregate(AggregatedFunction func, int[] rows = null)
{
if (typeof(DType) == typeof(DvBool))
{
return(new DataColumn <DvBool>(new[] { Aggregate(DataFrameAggFunctions.GetAggFunction(func, default(DvBool)), rows) }));
}
if (typeof(DType) == typeof(DvInt4))
{
return(new DataColumn <DvInt4>(new[] { Aggregate(DataFrameAggFunctions.GetAggFunction(func, default(DvInt4)), rows) }));
}
if (typeof(DType) == typeof(uint))
{
return(new DataColumn <uint>(new[] { Aggregate(DataFrameAggFunctions.GetAggFunction(func, default(uint)), rows) }));
}
if (typeof(DType) == typeof(DvInt8))
{
return(new DataColumn <DvInt8>(new[] { Aggregate(DataFrameAggFunctions.GetAggFunction(func, default(DvInt8)), rows) }));
}
if (typeof(DType) == typeof(float))
{
return(new DataColumn <float>(new[] { Aggregate(DataFrameAggFunctions.GetAggFunction(func, default(float)), rows) }));
}
if (typeof(DType) == typeof(double))
{
return(new DataColumn <double>(new[] { Aggregate(DataFrameAggFunctions.GetAggFunction(func, default(double)), rows) }));
}
if (typeof(DType) == typeof(DvText))
{
return(new DataColumn <DvText>(new[] { Aggregate(DataFrameAggFunctions.GetAggFunction(func, default(DvText)), rows) }));
}
throw new NotImplementedException($"Unkown type '{typeof(DType)}'.");
}
/// <summary>
/// Aggregates over all rows.
/// </summary>
public DataFrame Aggregate(AggregatedFunction func)
{
var dfs = new List <DataFrame>();
int nbkeys = 0;
foreach (var view in EnumerateGroups())
{
var df = view.Drop(view.ColumnsKey);
var agg = df.Aggregate(func);
nbkeys = view.Keys.Length;
foreach (var pair in view.Keys)
{
agg.AddColumn(pair.Key, pair.Kind, 1);
agg.loc[0, pair.Key] = pair.Value;
}
dfs.Add(agg);
}
var res = DataFrame.Concat(dfs);
var columns = res.Columns;
int nbnotkeys = columns.Length - nbkeys;
columns = columns.Skip(nbnotkeys).Concat(columns.Take(nbnotkeys)).ToArray();
res.OrderColumns(columns);
return(res);
}
public static Func <DvBool[], DvBool> GetAggFunction(AggregatedFunction func, DvBool defaultValue)
{
switch (func)
{
case AggregatedFunction.Mean:
case AggregatedFunction.Count:
return((DvBool[] arr) => { return DvBool.NA; });
case AggregatedFunction.Max:
case AggregatedFunction.Sum:
return((DvBool[] arr) => { return arr.Aggregate((a, b) => a | b); });
case AggregatedFunction.Min:
return((DvBool[] arr) => { return arr.Aggregate((a, b) => a & b); });
default:
throw new NotImplementedException($"Unkown aggregated function ${func}.");
}
}
/// <summary>
/// Aggregates over all rows.
/// </summary>
public DataFrame Aggregate(AggregatedFunction agg, int[] rows = null, int[] columns = null)
{
if (rows == null)
{
rows = _rows;
}
else
{
rows = rows.Select(c => _rows[c]).ToArray();
}
if (columns == null)
{
columns = _columns;
}
else
{
columns = columns.Select(c => _columns[c]).ToArray();
}
return(_src.Aggregate(agg, rows, columns));
}
public IDataColumn Aggregate(AggregatedFunction func, int[] rows = null)
{
if (typeof(DType) == typeof(bool))
return new DataColumn<bool>(new[] { Aggregate(DataFrameAggFunctions.GetAggFunction(func, default(bool)), rows) });
if (typeof(DType) == typeof(int))
return new DataColumn<int>(new[] { Aggregate(DataFrameAggFunctions.GetAggFunction(func, default(int)), rows) });
if (typeof(DType) == typeof(uint))
return new DataColumn<uint>(new[] { Aggregate(DataFrameAggFunctions.GetAggFunction(func, default(uint)), rows) });
if (typeof(DType) == typeof(long))
return new DataColumn<long>(new[] { Aggregate(DataFrameAggFunctions.GetAggFunction(func, default(long)), rows) });
if (typeof(DType) == typeof(float))
return new DataColumn<float>(new[] { Aggregate(DataFrameAggFunctions.GetAggFunction(func, default(float)), rows) });
if (typeof(DType) == typeof(double))
return new DataColumn<double>(new[] { Aggregate(DataFrameAggFunctions.GetAggFunction(func, default(double)), rows) });
if (typeof(DType) == typeof(ReadOnlyMemory<char>))
return new DataColumn<DvText>(new[] { Aggregate(DataFrameAggFunctions.GetAggFunction(func, default(DvText)), rows) });
if (typeof(DType) == typeof(DvText))
return new DataColumn<DvText>(new[] { Aggregate(DataFrameAggFunctions.GetAggFunction(func, default(DvText)), rows) });
throw new NotImplementedException($"Unkown type '{typeof(DType)}'.");
}
public static Func <DvText[], DvText> GetAggFunction(AggregatedFunction func, DvText defaultValue)
{
switch (func)
{
case AggregatedFunction.Mean:
case AggregatedFunction.Count:
return((DvText[] arr) => { return DvText.NA; });
case AggregatedFunction.Sum:
return((DvText[] arr) => { return arr.Aggregate((a, b) => new DvText(a.ToString() + b.ToString())); });
case AggregatedFunction.Min:
return((DvText[] arr) => { return arr.Aggregate((a, b) => a.CompareTo(b) <= 0 ? a : b); });
case AggregatedFunction.Max:
return((DvText[] arr) => { return arr.Aggregate((a, b) => a.CompareTo(b) >= 0 ? a : b); });
default:
throw new NotImplementedException($"Unkown aggregated function ${func}.");
}
}
public static Func <DvInt8[], DvInt8> GetAggFunction(AggregatedFunction func, DvInt8 defaultValue)
{
switch (func)
{
case AggregatedFunction.Count:
return((DvInt8[] arr) => { return (DvInt8)arr.Length; });
case AggregatedFunction.Sum:
return((DvInt8[] arr) => { return arr.Aggregate((a, b) => a + b); });
case AggregatedFunction.Min:
return((DvInt8[] arr) => { return arr.Aggregate((a, b) => DvInt8.Min(a, b)); });
case AggregatedFunction.Max:
return((DvInt8[] arr) => { return arr.Aggregate((a, b) => DvInt8.Max(a, b)); });
case AggregatedFunction.Mean:
return((DvInt8[] arr) => { return arr.Aggregate((a, b) => a + b) / arr.Length; });
default:
throw new NotImplementedException($"Unkown aggregated function ${func}.");
}
}
public static Func <uint[], uint> GetAggFunction(AggregatedFunction func, uint defaultValue)
{
switch (func)
{
case AggregatedFunction.Count:
return((uint[] arr) => { return (uint)arr.Length; });
case AggregatedFunction.Sum:
return((uint[] arr) => { return arr.Aggregate((a, b) => a + b); });
case AggregatedFunction.Min:
return((uint[] arr) => { return arr.Min(); });
case AggregatedFunction.Max:
return((uint[] arr) => { return arr.Max(); });
case AggregatedFunction.Mean:
return((uint[] arr) => { return arr.Aggregate((a, b) => a + b) / (uint)arr.Length; });
default:
throw new NotImplementedException($"Unkown aggregated function ${func}.");
}
}
public static Func <double[], double> GetAggFunction(AggregatedFunction func, double defaultValue)
{
switch (func)
{
case AggregatedFunction.Count:
return((double[] arr) => { return (double)arr.Length; });
case AggregatedFunction.Sum:
return((double[] arr) => { return arr.Sum(); });
case AggregatedFunction.Min:
return((double[] arr) => { return arr.Min(); });
case AggregatedFunction.Max:
return((double[] arr) => { return arr.Max(); });
case AggregatedFunction.Mean:
return((double[] arr) => { return arr.Sum() / (uint)arr.Length; });
default:
throw new NotImplementedException($"Unkown aggregated function ${func}.");
}
}
public static Func <Int64[], Int64> GetAggFunction(AggregatedFunction func, Int64 defaultValue)
{
switch (func)
{
case AggregatedFunction.Count:
return((Int64[] arr) => { return (Int64)arr.Length; });
case AggregatedFunction.Sum:
return((Int64[] arr) => { return arr.Aggregate((a, b) => a + b); });
case AggregatedFunction.Min:
return((Int64[] arr) => { return arr.Aggregate((a, b) => Math.Min(a, b)); });
case AggregatedFunction.Max:
return((Int64[] arr) => { return arr.Aggregate((a, b) => Math.Max(a, b)); });
case AggregatedFunction.Mean:
return((Int64[] arr) => { return arr.Aggregate((a, b) => a + b) / arr.Length; });
default:
throw new NotImplementedException($"Unkown aggregated function '{func}'.");
}
}
/// <summary>
/// Aggregates over all rows.
/// </summary>
public DataFrame Aggregate(AggregatedFunction func, int[] rows = null, int[] columns = null)
{
return(new DataFrame(_data.Aggregate(func, rows, columns), _shuffle));
}
public IDataColumn Aggregate(AggregatedFunction func, int[] rows = null)
{
return(Column.Aggregate(func, rows));
}
