} // _Ordered_Comparer_impl_ class
public static DataSet getOrdered(DataSet dataSet, params OrderByItem[] orderByItems)
{
List <Row> values = new List <Row>();
IComparer <Row> valueComparator = null;
if (orderByItems != null && orderByItems.Length != 0)
{
int[] sortIndexes = new int[orderByItems.Length];
for (int i = 0; i < orderByItems.Length; i++)
{
OrderByItem item = orderByItems[i];
int index_of = dataSet.indexOf(item.getSelectItem());
sortIndexes[i] = index_of;
}
values = readDataSetFull(dataSet);
if (values.IsEmpty())
{
return(new EmptyDataSet(dataSet.getSelectItems()));
}
valueComparator = ObjectComparator.getComparator();
// create a comparator for doing the actual sorting/ordering
IComparer <Row> comparator = new _Ordered_Comparer_impl_(valueComparator, orderByItems);
}
values.Sort(valueComparator); // Collections.sort(data, comparator);
dataSet = new InMemoryDataSet(values);
return(dataSet);
} // getOrdered()
public static IDataSet <T, double> MapTwoFeaturesDataSetToDegree <T>(IDataSet <T, double> dataSet, int degree)
where T : IEquatable <T>
{
return(InMemoryDataSet.Create((from data in dataSet.GetData()
let x1 = data.Attributes[0]
let x2 = data.Attributes[1]
select TrainingSample.Create(data.Category, MapTwoFeaturesToDegrees(x1, x2, degree), data.Count))
.ToArray()));
}
private static IDataSet <bool, double> GetDataSet(string resourceName)
{
var dataLines = GetResourceLines(resourceName);
var parsedDataLines = ParseDoublesLines(dataLines, new[] { ',' });
var dataSet1 = InMemoryDataSet.Create(parsedDataLines
.Select(pl => TrainingSample.Create(pl[2] != 0, new[] { pl[0], pl[1] }))
.ToArray());
return(dataSet1);
}
public void CorrectlyClassifiesTestDataSetFromExample13Dot1()
{
var trainingData = InMemoryDataSet.Create(new[]
{
TrainingSample.Create("China", new[] { "Chinese", "Beijing", "Chinese" }),
TrainingSample.Create("China", new[] { "Chinese", "Chinese", "Shanghai" }),
TrainingSample.Create("China", new[] { "Chinese", "Makao" }),
TrainingSample.Create("Not China", new[] { "Tokio", "Japan", "Chinese" }),
});
var classifier = MultinomialNaiveBayesClassifier.Create(trainingData);
Assert.AreEqual("China", classifier.Classify(new[] { "Chinese", "Chinese", "Chinese", "Tokio", "Japan" }));
Assert.AreEqual("Not China", classifier.Classify(new[] { "Tokio" }));
Assert.AreEqual("China", classifier.Classify(new[] { "Chinese", "Tokio" }));
Assert.AreEqual("China", classifier.Classify(new[] { "Unknown", "Chinese", "Tokio" }));
Assert.AreEqual("Not China", classifier.Classify(new[] { "Chinese", "Tokio", "Japan" }));
}
} // getInformationSchema()
public virtual DataSet materializeInformationSchemaTable(Table table, List <SelectItem> selectItems)
{
String tableName = table.getName();
SelectItem[] columnSelectItems = MetaModelHelper.createSelectItems(table.getColumns());
SimpleDataSetHeader header = new SimpleDataSetHeader(columnSelectItems);
Table[] tables = getDefaultSchema().getTables(false);
List <Row> data = new List <Row>();
if ("tables".Equals(tableName))
{
// "tables" columns: name, type, num_columns, remarks
foreach (Table t in tables)
{
String typeString = null;
if (t.GetType() != null)
{
typeString = t.getType().ToString();
}
data.Add(new DefaultRow(header,
new Object[] { t.getName(), typeString, t.getColumnCount(), t.getRemarks() }));
}
}
else if ("columns".Equals(tableName))
{
// "columns" columns: name, type, native_type, size, nullable,
// indexed, table, remarks
foreach (Table t in tables)
{
foreach (Column c in t.getColumns())
{
String typeString = null;
if (t.GetType() != null)
{
typeString = c.getType().ToString();
}
data.Add(new DefaultRow(header, new Object[] { c.getName(), typeString, c.getNativeType(),
c.getColumnSize(), c.isNullable(), c.isIndexed(), t.getName(), c.getRemarks() }));
}
}
}
else if ("relationships".Equals(tableName))
{
// "relationships" columns: primary_table, primary_column,
// foreign_table, foreign_column
foreach (Relationship r in getDefaultSchema().getRelationships())
{
Column[] primaryColumns = r.getPrimaryColumns();
Column[] foreignColumns = r.getForeignColumns();
Table pTable = r.getPrimaryTable();
Table fTable = r.getForeignTable();
for (int i = 0; i < primaryColumns.Length; i++)
{
Column pColumn = primaryColumns[i];
Column fColumn = foreignColumns[i];
data.Add(new DefaultRow(header,
new Object[] { pTable.getName(), pColumn.getName(), fTable.getName(), fColumn.getName() }));
}
}
}
else
{
throw new ArgumentException("Cannot materialize non information_schema table: " + table);
}
DataSet dataSet;
if (data.IsEmpty())
{
dataSet = new EmptyDataSet(selectItems);
}
else
{
dataSet = new InMemoryDataSet(header, data);
}
// Handle column subset
DataSet selectionDataSet = MetaModelHelper.getSelection(selectItems, dataSet);
dataSet = selectionDataSet;
return(dataSet);
} // materializeInformationSchemaTable()
} // getGrouped()
public static DataSet getGrouped(List <SelectItem> selectItems, DataSet dataSet, GroupByItem[] groupByItems)
{
DataSet result = dataSet;
if (groupByItems != null && groupByItems.Length > 0)
{
Dictionary <Row, Dictionary <SelectItem, List <Object> > > uniqueRows = new Dictionary <Row, Dictionary <SelectItem, List <Object> > >();
SelectItem[] groupBySelects = new SelectItem[groupByItems.Length];
for (int i = 0; i < groupBySelects.Length; i++)
{
groupBySelects[i] = groupByItems[i].getSelectItem();
}
DataSetHeader groupByHeader = new CachingDataSetHeader(groupBySelects);
// Creates a list of SelectItems that have aggregate functions
List <SelectItem> functionItems = getAggregateFunctionSelectItems(selectItems);
// Loop through the dataset and identify groups
while (dataSet.next())
{
Row row = dataSet.getRow();
// Subselect a row prototype with only the unique values that
// define the group
Row uniqueRow = row.getSubSelection(groupByHeader);
// function input is the values used for calculating aggregate
// functions in the group
Dictionary <SelectItem, List <Object> > functionInput;
if (!uniqueRows.ContainsKey(uniqueRow))
{
// If this group already exist, use an existing function
// input
functionInput = new Dictionary <SelectItem, List <Object> >();
foreach (SelectItem item in functionItems)
{
functionInput.Add(item, new List <Object>());
}
uniqueRows.Add(uniqueRow, functionInput);
}
else
{
// If this is a new group, create a new function input
functionInput = uniqueRows[uniqueRow];
}
// Loop through aggregate functions to check for validity
foreach (SelectItem item in functionItems)
{
List <Object> objects = functionInput[item];
Column column = item.getColumn();
if (column != null)
{
Object value = row.getValue(new SelectItem(column));
objects.Add(value);
}
else if (SelectItem.isCountAllItem(item))
{
// Just use the empty string, since COUNT(*) don't
// evaluate values (but null values should be prevented)
objects.Add("");
}
else
{
throw new ArgumentException("Expression function not supported: " + item);
}
}
}
dataSet.close();
List <Row> resultData = new List <Row>();
DataSetHeader resultHeader = new CachingDataSetHeader(selectItems);
int count = uniqueRows.Count;
// Loop through the groups to generate aggregates
foreach (KeyValuePair <Row, Dictionary <SelectItem, List <Object> > > key_value in uniqueRows)
{
Row row = key_value.Key;
Dictionary <SelectItem, List <Object> > functionInput = key_value.Value;
Object[] resultRow = new Object[selectItems.Count];
// Loop through select items to generate a row
int i = 0;
foreach (SelectItem item in selectItems)
{
int uniqueRowIndex = row.indexOf(item);
if (uniqueRowIndex != -1)
{
// If there's already a value for the select item in the
// row, keep it (it's one of the grouped by columns)
resultRow[i] = row.getValue(uniqueRowIndex);
}
else
{
// Use the function input to calculate the aggregate
// value
List <Object> objects = functionInput[item];
if (objects != null)
{
Object functionResult = item.getAggregateFunction().evaluate(objects.ToArray());
resultRow[i] = functionResult;
}
else
{
if (item.getAggregateFunction() != null)
{
logger.error("No function input found for SelectItem: {}", item);
}
}
}
i++;
}
resultData.Add(new DefaultRow(resultHeader, resultRow, null));
}
if (resultData.IsEmpty())
{
result = new EmptyDataSet(selectItems);
}
else
{
result = new InMemoryDataSet(resultHeader, resultData);
}
}
result = getSelection(selectItems, result);
return(result);
} // getGrouped()
