/// <summary>
/// Gets aggregated version of the objects
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source">The source.</param>
/// <param name="type">The type.</param>
/// <returns></returns>
public static collectionAggregationResult <T> GetAggregates <T>(this IEnumerable <T> source, dataPointAggregationType type = dataPointAggregationType.avg, bool stringKeepLastEntry = true) where T : class, new()
{
//if (type == dataPointAggregationType.none)
//{
//}
var aggList = type.getEnumListFromFlags <dataPointAggregationType>();
collectionAggregationResult <T> output = new collectionAggregationResult <T>();
output.aspect = dataPointAggregationAspect.subSetOfRows;
aceDictionary2D <dataPointAggregationType, PropertyInfo, double> outputData = new aceDictionary2D <dataPointAggregationType, PropertyInfo, double>();
aceDictionary2D <dataPointAggregationType, PropertyInfo, List <double> > datatCollections = new aceDictionary2D <dataPointAggregationType, PropertyInfo, List <double> >();
Type t = typeof(T);
List <PropertyInfo> nominalList = new List <PropertyInfo>();
List <PropertyInfo> piList = new List <PropertyInfo>();
Dictionary <PropertyInfo, settingsPropertyEntry> sPEDict = new Dictionary <PropertyInfo, settingsPropertyEntry>();
foreach (PropertyInfo pi in t.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.SetProperty | BindingFlags.GetProperty))
{
settingsPropertyEntry sPE = new settingsPropertyEntry(pi);
bool ok = true;
if (!pi.CanWrite)
{
ok = false;
}
if (ok && pi.PropertyType == typeof(string))
{
nominalList.Add(pi);
ok = false;
}
else if (ok && pi.PropertyType == typeof(Enum))
{
ok = false;
}
if (ok && sPE.aggregation[dataPointAggregationAspect.subSetOfRows].HasFlag(dataPointAggregationType.hidden))
{
ok = false;
}
if (ok && sPE.attributes.ContainsKey(imbAttributeName.reporting_hide))
{
ok = false;
}
if (ok)
{
sPEDict.Add(pi, sPE);
piList.Add(pi);
}
}
if (aggList.Contains(dataPointAggregationType.avg))
{
aggList.AddUnique(dataPointAggregationType.sum);
}
if (aggList.Contains(dataPointAggregationType.range))
{
aggList.AddUnique(dataPointAggregationType.min);
aggList.AddUnique(dataPointAggregationType.max);
}
foreach (dataPointAggregationType aggType in aggList)
{
output.Add(aggType, new T());
switch (aggType)
{
case dataPointAggregationType.var:
case dataPointAggregationType.stdev:
case dataPointAggregationType.entropy:
foreach (PropertyInfo pi in piList)
{
datatCollections[aggType, pi] = new List <double>(); //.Add(item.imbGetPropertySafe<Double>(pi));
}
break;
}
// outputData.Add(aggType, 0);
}
int count = 0;
// <------------ first pass
foreach (T item in source)
{
if (output.firstItem == null)
{
output.firstItem = item;
}
output.lastItem = item;
foreach (dataPointAggregationType aggType in aggList)
{
foreach (PropertyInfo pi in piList)
{
double vl = outputData[aggType, pi];
switch (aggType)
{
case dataPointAggregationType.sum:
vl = vl + item.imbGetPropertySafe <double>(pi);
break;
case dataPointAggregationType.min:
vl = Math.Min(item.imbGetPropertySafe <double>(pi), vl);
break;
case dataPointAggregationType.max:
vl = Math.Max(item.imbGetPropertySafe <double>(pi), vl);
break;
case dataPointAggregationType.var:
case dataPointAggregationType.stdev:
case dataPointAggregationType.entropy:
datatCollections[aggType, pi].Add(item.imbGetPropertySafe <double>(pi));
break;
}
outputData[aggType, pi] = vl;
}
}
count++;
}
foreach (dataPointAggregationType aggType in aggList)
{
foreach (PropertyInfo pi in piList)
{
switch (aggType)
{
case dataPointAggregationType.count:
outputData[aggType, pi] = count;
break;
case dataPointAggregationType.avg:
outputData[aggType, pi] = outputData[dataPointAggregationType.sum, pi] / (double)count;
break;
case dataPointAggregationType.range:
outputData[aggType, pi] = outputData[dataPointAggregationType.max, pi] - outputData[dataPointAggregationType.min, pi];
break;
case dataPointAggregationType.firstEntry:
outputData[aggType, pi] = output.firstItem.imbGetPropertySafe <double>(pi);
break;
case dataPointAggregationType.lastEntry:
outputData[aggType, pi] = output.lastItem.imbGetPropertySafe <double>(pi);
break;
case dataPointAggregationType.var:
outputData[aggType, pi] = datatCollections[aggType, pi].GetVariance();
break;
case dataPointAggregationType.stdev:
outputData[aggType, pi] = datatCollections[aggType, pi].GetStdDeviation();
break;
case dataPointAggregationType.entropy:
outputData[aggType, pi] = datatCollections[aggType, pi].GetEntropy();
break;
}
}
}
foreach (dataPointAggregationType aggType in aggList)
{
foreach (PropertyInfo pi in piList)
{
output[aggType].imbSetPropertyConvertSafe(pi, outputData[aggType, pi]);
}
if (stringKeepLastEntry)
{
foreach (PropertyInfo pi in nominalList)
{
output[aggType].imbSetPropertyConvertSafe(pi, output.lastItem.imbGetPropertySafe(pi));
}
}
}
output.Count = count;
return(output);
}
public static DataTable GetParallelAggregates <T>(this List <IEnumerable <T> > sources, string column_snap, string column_prefix, dataPointAggregationType column_sideAggregates, params string[] column_toInclude)
{
settingsEntriesForObject sEO = new settingsEntriesForObject(typeof(T));
settingsPropertyEntry sPE_snap = sEO.spes[column_snap];
settingsPropertyEntry sPE_prefix = sEO.spes[column_prefix];
List <settingsPropertyEntry> sPE_toInclude = new List <settingsPropertyEntry>();
foreach (string toInclude in column_toInclude)
{
sPE_toInclude.Add(sEO.spes[toInclude]);
}
List <dataPointAggregationType> side_aggregates = column_sideAggregates.getEnumListFromFlags <dataPointAggregationType>();
Dictionary <dataPointAggregationType, settingsPropertyEntry> sPE_sideAggregates = new Dictionary <dataPointAggregationType, settingsPropertyEntry>();
Dictionary <settingsPropertyEntry, dataPointAggregationType> sPE_sideAggregatesContra = new Dictionary <settingsPropertyEntry, dataPointAggregationType>();
foreach (settingsPropertyEntry toInclude in sPE_toInclude)
{
foreach (dataPointAggregationType sideType in side_aggregates)
{
settingsPropertyEntry sPE = new settingsPropertyEntry(toInclude.pi);
sPE.type = typeof(double);
sPE.name = sPE.name + "_" + sideType.ToString();
sPE_sideAggregates.Add(sideType, sPE);
sPE_sideAggregatesContra.Add(sPE, sideType);
}
}
// <---------------------------- preparing data
Dictionary <string, IEnumerable <T> > dataByPrefix = new Dictionary <string, IEnumerable <T> >();
int c = 0;
foreach (IEnumerable <T> s in sources)
{
T firstItem = s.FirstOrDefault <T>();
if (firstItem != null)
{
string prefix = firstItem.imbGetPropertySafe(sPE_prefix.pi).toStringSafe(c.ToString("D3"));
dataByPrefix.Add(prefix, s);
}
c++;
}
// <----- DataColumn Index
aceDictionarySet <string, DataColumn> columnsByPrefix = new aceDictionarySet <string, DataColumn>();
aceDictionarySet <string, DataColumn> columnsSideAggregationByPrefix = new aceDictionarySet <string, DataColumn>();
// <------------------------- building Shema
DataTable output = new DataTable();
output.TableName = "ParallelAggregate_by_" + column_snap;
DataColumn col_recordID = output.Add("ID", "Row ordinal number", "ID", typeof(int), dataPointImportance.normal, "D3").SetUnit("#");
settingsPropertyEntry sPE_recID = col_recordID.GetSPE();
DataColumn col_snap = output.Add(sPE_snap);
aceDictionary2D <settingsPropertyEntry, dataPointAggregationType, DataColumn> columnsByAggregationType = new aceDictionary2D <settingsPropertyEntry, dataPointAggregationType, DataColumn>();
aceDictionarySet <settingsPropertyEntry, DataColumn> columnsBySource = new aceDictionarySet <settingsPropertyEntry, DataColumn>();
foreach (settingsPropertyEntry toInclude in sPE_toInclude)
{
foreach (var pair in dataByPrefix)
{
DataColumn nColumn = output.Add(toInclude);
nColumn.ColumnName = pair.Key + "_" + nColumn.ColumnName;
nColumn.SetGroup(pair.Key);
columnsByPrefix.Add(pair.Key, nColumn);
columnsBySource.Add(toInclude, nColumn);
}
foreach (var pair2 in sPE_sideAggregatesContra)
{
DataColumn nColumn2 = output.Add(toInclude);
nColumn2.SetGroup("Aggregate");
// columnsSideAggregationByPrefix.Add(pair.Key, nColumn);
}
}
// <----------------------------------------------------------- collecting rows
aceDictionary2D <string, settingsPropertyEntry, object> dataRowBySnapValue = new aceDictionary2D <string, settingsPropertyEntry, object>();
int riMax = 0;
foreach (string prefix in dataByPrefix.Keys)
{
IEnumerable <T> s = dataByPrefix[prefix];
int ri = 0;
foreach (T si in s)
{
ri++;
string snapValue = si.imbGetPropertySafe(sPE_snap.pi).toStringSafe();
dataRowBySnapValue[snapValue, sPE_snap] = snapValue;
dataRowBySnapValue[snapValue, sPE_recID] = ri;
foreach (settingsPropertyEntry toInclude in sPE_toInclude)
{
foreach (var pair in columnsByPrefix[prefix])
{
var spe = dataColumnRenderingSetup.GetSPE(pair);
dataRowBySnapValue[snapValue, spe] = si.imbGetPropertySafe(spe.pi);
}
}
riMax = Math.Max(ri, riMax);
}
}
foreach (string prefix in dataByPrefix.Keys)
{
}
//List<Double> data = new List<Double>();
//foreach (var pair2 in columnsSideAggregationByPrefix[prefix])
//{
// var spe2 = pair.GetSPE();
// dataRowBySnapValue[snapValue, spe2] = si.imbGetPropertySafe(spe2.pi);
//}
return(output);
}
/// <summary>
/// Adds the range rows into table.
/// </summary>
/// <param name="namePrefix">Row name prefix.</param>
/// <param name="targetTable">The target table.</param>
/// <param name="placeDataRowMarks">if set to <c>true</c> it will set styling conditioners to this table</param>
/// <param name="rowsToAdd">The rows.</param>
public void AddRangeRows(String namePrefix, DataTable targetTable, Boolean placeDataRowMarks, dataPointAggregationType rowsToAdd = dataPointAggregationType.sum | dataPointAggregationType.avg | dataPointAggregationType.count | dataPointAggregationType.min | dataPointAggregationType.max | dataPointAggregationType.range)
{
Int32 i = 0;
foreach (DataRow dr in targetTable.Rows)
{
if (i < rowsToSkipFromLearning)
{
}
else
{
foreach (var pair in finders)
{
Object vl = dr[pair.Value.id];
if (vl is Int32)
{
pair.Value.Learn(Convert.ToDouble((Int32)vl));
}
else if (vl is Double)
{
pair.Value.Learn((Double)vl);
}
else if (vl is Boolean)
{
pair.Value.Learn(Convert.ToDouble((Boolean)vl));
}
}
}
i++;
}
List <String> rownamesHMax = new List <string>();
List <String> rownamesHMin = new List <string>();
List <String> rownamesH3 = new List <string>();
foreach (dataPointAggregationType dt in rowsToAdd.getEnumListFromFlags())
{
DataRow dr = targetTable.NewRow();
String name = namePrefix + " " + dt.ToString();
if (keyColumn != null)
{
dr[keyColumn.ColumnName] = name;
}
if (columnsToSignIn.Any())
{
foreach (String cn in columnsToSignIn)
{
dr[cn] = name;
}
}
if (placeDataRowMarks && keyColumn != null)
{
foreach (DataRow dd in targetTable.Rows)
{
foreach (var pair in finders)
{
rangeFinderWithData rf = pair.Value;
//Double vl = Convert.ToDouble(dd[rf.id].imbConvertValueSafeTyped<Double>());
Double vl = dd[rf.id].imbConvertValueSafeTyped <Double>();
switch (dt)
{
case dataPointAggregationType.max:
if (vl == rf.Maximum)
{
rownamesHMax.Add(dd[keyColumnName].toStringSafe());
}
break;
case dataPointAggregationType.min:
if (vl == rf.Minimum)
{
rownamesHMin.Add(dd[keyColumnName].toStringSafe());
}
break;
}
}
}
}
foreach (var pair in finders)
{
rangeFinderWithData rf = pair.Value;
try
{
switch (dt)
{
case dataPointAggregationType.avg:
dr[rf.id] = rf.Average;
rownamesH3.Add(name);
targetTable.SetAdditionalInfoEntry("Prefix: " + dt.ToString(), "Arithmentic mean");
break;
case dataPointAggregationType.count:
dr[rf.id] = rf.Count;
targetTable.SetAdditionalInfoEntry("Prefix: " + dt.ToString(), "Number of rows");
break;
case dataPointAggregationType.max:
rownamesHMax.Add(name);
if (rf.Maximum > Double.MinValue)
{
dr[rf.id] = rf.Maximum;
}
targetTable.SetAdditionalInfoEntry("Prefix: " + dt.ToString(), "Highest value");
break;
case dataPointAggregationType.min:
rownamesHMin.Add(name);
if (rf.Minimum < Double.MaxValue)
{
dr[rf.id] = rf.Minimum;
}
targetTable.SetAdditionalInfoEntry("Prefix: " + dt.ToString(), "Smallest value");
break;
case dataPointAggregationType.range:
dr[rf.id] = rf.Range;
targetTable.SetAdditionalInfoEntry("Prefix: " + dt.ToString(), "Range of values");
break;
case dataPointAggregationType.sum:
dr[rf.id] = rf.Sum;
rownamesH3.Add(name);
targetTable.SetAdditionalInfoEntry("Prefix: " + dt.ToString(), "Sum");
break;
case dataPointAggregationType.entropy:
dr[rf.id] = rf.doubleEntries.GetEntropy(1E-06, true);
targetTable.SetAdditionalInfoEntry("Prefix: " + dt.ToString(), "Normalized Entropy");
rownamesH3.Add(name);
break;
case dataPointAggregationType.stdev:
dr[rf.id] = rf.doubleEntries.GetStdDeviation();
rownamesH3.Add(name);
targetTable.SetAdditionalInfoEntry("Prefix: " + dt.ToString(), "Standard Deviation");
break;
case dataPointAggregationType.var:
targetTable.SetAdditionalInfoEntry(dt.ToString(), "Variance");
dr[rf.id] = rf.doubleEntries.GetVariance();
rownamesH3.Add(name);
targetTable.SetAdditionalInfoEntry("Prefix: " + dt.ToString(), "Variance");
break;
}
}
catch (Exception ex)
{
targetTable.AddExtra("rangeFinder[" + rf.id + "] failed on [" + dt.ToString() + "] with exception: " + ex.Message);
targetTable.AddExtra("::: " + ex.StackTrace);
}
//if (!targetTable.GetAdditionalInfo().ContainsKey(dt)
}
targetTable.Rows.Add(dr);
}
targetTable.GetRowMetaSet().SetStyleForRowsWithValue <String>(DataRowInReportTypeEnum.dataHighlightA, keyColumnName, rownamesHMin);
targetTable.GetRowMetaSet().SetStyleForRowsWithValue <String>(DataRowInReportTypeEnum.dataHighlightB, keyColumnName, rownamesHMax);
targetTable.GetRowMetaSet().SetStyleForRowsWithValue <String>(DataRowInReportTypeEnum.dataHighlightC, keyColumnName, rownamesH3);
}
