private IEnumerable <CLRSafeHashSet <int> > DetermineSubsets()
{
CheckValidityOfCountAndDimension(SubsetCount, SubsetDimension, AllPreferencesCount);
IList <CLRSafeHashSet <int> > subsetsReturn = SubsetsProducer.GetSubsets().ToList();
if (subsetsReturn.Count != SubsetCount)
{
throw new Exception("Not produced the correct number of subsets.");
}
if (subsetsReturn.Any(subset => subset.Count != SubsetDimension))
{
throw new Exception("Produced subset of incorrect dimension.");
}
if (!AreAllPreferencesAtLeastOnceContainedInSubset(subsetsReturn))
{
throw new Exception("Not all preferences at least once contained in produced subsets.");
}
foreach (CLRSafeHashSet <int> subsetReturn in subsetsReturn)
{
CLRSafeHashSet <int> subsetReturnLocal = subsetReturn;
if (
subsetsReturn.Where(element => element != subsetReturnLocal)
.Any(element => element.SetEquals(subsetReturnLocal)))
{
throw new Exception("Same subset contained multiple times.");
}
}
return(subsetsReturn);
}
private IEnumerable <CLRSafeHashSet <int> > UseSubsets(PrefSQLModel prefSqlModelSkylineSample)
{
var preferencesInSubsetExpected = new List <CLRSafeHashSet <int> >();
DataRow[] subsetsExpected =
TestContext.DataRow.GetChildRows("TestDataRow_useSubsets")[0].GetChildRows("useSubsets_subset");
foreach (DataRow subsetExpected in subsetsExpected)
{
DataRow[] subsetExpectedDimensions = subsetExpected.GetChildRows("subset_dimension");
var preferencesInSingleSubsetExpected = new CLRSafeHashSet <int>();
foreach (DataRow singleSubsetExpectedDimension in subsetExpectedDimensions)
{
for (var i = 0; i < prefSqlModelSkylineSample.Skyline.Count; i++)
{
AttributeModel attributeModel = prefSqlModelSkylineSample.Skyline[i];
if (attributeModel.FullColumnName == singleSubsetExpectedDimension[0].ToString())
{
preferencesInSingleSubsetExpected.Add(i);
break;
}
}
}
preferencesInSubsetExpected.Add(preferencesInSingleSubsetExpected);
}
return(preferencesInSubsetExpected);
}
/// <summary>
/// TODO: comment
/// </summary>
/// <param name="subset"></param>
/// <returns></returns>
public CLRSafeHashSet <int> GetSubsetComplement(CLRSafeHashSet <int> subset)
{
var subsetComplement = new CLRSafeHashSet <int>();
for (var i = 0; i < AllPreferencesCount; i++)
{
if (!subset.Contains(i))
{
subsetComplement.Add(i);
}
}
return(subsetComplement);
}
private void AddOneRandomSubsetNotYetContained(ICollection <CLRSafeHashSet <int> > subsetQueries)
{
CLRSafeHashSet <int> subsetQueryCandidate;
do
{
subsetQueryCandidate = new CLRSafeHashSet <int>();
while (subsetQueryCandidate.Count < SubsetDimension)
{
subsetQueryCandidate.Add(MyRandom.Next(AllPreferencesCount));
}
} while (IsSubsetQueryCandidateContainedWithinSubsetQueries(subsetQueryCandidate, subsetQueries));
subsetQueries.Add(subsetQueryCandidate);
}
private bool AreAllPreferencesAtLeastContainedOnceInSubsets(
IEnumerable <CLRSafeHashSet <int> > subsetQueries)
{
var containedPreferences = new CLRSafeHashSet <int>();
foreach (CLRSafeHashSet <int> subsetQueryPreferences in subsetQueries)
{
foreach (int subsetQueryPreference in subsetQueryPreferences)
{
containedPreferences.Add(subsetQueryPreference);
}
if (containedPreferences.Count == AllPreferencesCount)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Calculate the necessary subset skylines and merge them into the skyline sample which will finally be reported by
/// the skyline sampling algorithm.
/// </summary>
/// <remarks>
/// Calculate subsets of preferences. For each subset, calculate a skyline via the selected skyline algorithm. Determine the
/// objects for which the calculation of a subset skyline with respect to the subset's complement is necessary; if
/// so, calculate this subset complement skyline via the selected skyline algorithm and remove dominated objects from
/// the subset skyline. Finally, merge the subset skyline into the skyline sample which will be reported by the
/// skyline sampling algorithm.
/// </remarks>
/// <param name="database">
/// A Collection by which a row can be accessed via its unique ID. The values represent the database
/// rows including the preceding SkylineAttribute columns.
/// </param>
/// <param name="dataTableTemplate">
/// An empty DataTable with all columns to return to which the column
/// InternalArtificialUniqueRowIdentifierColumnName has already been added.
/// </param>
/// <param name="sw">
/// To measture the time spent to perform this whole algorithm. Has to be started before calling this
/// method, will be running after this method.
/// </param>
private IReadOnlyDictionary <long, object[]> CalculateSkylineSampleFinalDatabase(
IReadOnlyDictionary <long, object[]> database, DataTable dataTableTemplate, Stopwatch sw)
{
var skylineSampleFinalDatabase = new Dictionary <long, object[]>();
foreach (CLRSafeHashSet <int> subset in Utility.Subsets)
{
IEnumerable <object[]> useDatabase = database.Values;
string subpaceOperators = GetOperatorsWithIgnoredEntriesString(subset);
SelectedStrategy.HasIncomparablePreferences = subpaceOperators.Contains("INCOMPARABLE");
SelectedStrategy.PrepareDatabaseForAlgorithm(ref useDatabase, subset.ToList(),
Utility.PreferenceColumnIndex, Utility.IsPreferenceIncomparable);
sw.Stop();
TimeMilliseconds += sw.ElapsedMilliseconds;
DataTable subsetDataTable = SelectedStrategy.GetSkylineTable(useDatabase,
dataTableTemplate.Clone(), DataRecordTemplate, subpaceOperators);
TimeMilliseconds += SelectedStrategy.TimeMilliseconds;
NumberOfOperations += SelectedStrategy.NumberOfComparisons;
sw.Restart();
IDictionary <long, object[]> subsetDatabase = GetDatabaseFromDataTable(database, subsetDataTable);
IEnumerable <Tuple <long[], string[]> > databaseForPairwiseComparison =
GetDatabaseForPairwiseComparison(subsetDatabase.Values, subset.ToList());
IEnumerable <CLRSafeHashSet <long> > rowsWithEqualValuesWithRespectToSubsetColumns =
CompareEachRowWithRespectToSubsetColumnsPairwise(databaseForPairwiseComparison);
CLRSafeHashSet <int> subsetComplement = Utility.GetSubsetComplement(subset);
string subsetComplementOperators =
GetOperatorsWithIgnoredEntriesString(Utility.GetSubsetComplement(subset));
SelectedStrategy.HasIncomparablePreferences = subsetComplementOperators.Contains("INCOMPARABLE");
List <int> subsetComplementList = subsetComplement.ToList();
foreach (CLRSafeHashSet <long> rowsWithEqualValues in rowsWithEqualValuesWithRespectToSubsetColumns)
{
IReadOnlyDictionary <long, object[]> rowsWithEqualValuesDatabase = GetSubsetOfDatabase(database,
rowsWithEqualValues);
useDatabase = rowsWithEqualValuesDatabase.Values;
SelectedStrategy.PrepareDatabaseForAlgorithm(ref useDatabase, subsetComplementList,
Utility.PreferenceColumnIndex, Utility.IsPreferenceIncomparable);
sw.Stop();
TimeMilliseconds += sw.ElapsedMilliseconds;
DataTable subsetComplementDataTable =
SelectedStrategy.GetSkylineTable(useDatabase,
dataTableTemplate.Clone(), DataRecordTemplate, subsetComplementOperators);
TimeMilliseconds += SelectedStrategy.TimeMilliseconds;
NumberOfOperations += SelectedStrategy.NumberOfComparisons;
sw.Restart();
IReadOnlyDictionary <long, object[]> subsetComplementDatabase =
new ReadOnlyDictionary <long, object[]>(GetDatabaseFromDataTable(database,
subsetComplementDataTable));
RemoveDominatedObjects(rowsWithEqualValues, subsetComplementDatabase, subsetDatabase);
}
MergeSubsetSkylineIntoFinalSkylineSample(new ReadOnlyDictionary <long, object[]>(subsetDatabase),
skylineSampleFinalDatabase);
}
return(skylineSampleFinalDatabase);
}
private void AddOneRandomSubsetNotYetContained(ICollection<CLRSafeHashSet<int>> subsetQueries)
{
CLRSafeHashSet<int> subsetQueryCandidate;
do
{
subsetQueryCandidate = new CLRSafeHashSet<int>();
while (subsetQueryCandidate.Count < SubsetDimension)
{
subsetQueryCandidate.Add(MyRandom.Next(AllPreferencesCount));
}
} while (IsSubsetQueryCandidateContainedWithinSubsetQueries(subsetQueryCandidate, subsetQueries));
subsetQueries.Add(subsetQueryCandidate);
}
private bool AreAllPreferencesAtLeastContainedOnceInSubsets(
IEnumerable<CLRSafeHashSet<int>> subsetQueries)
{
var containedPreferences = new CLRSafeHashSet<int>();
foreach (CLRSafeHashSet<int> subsetQueryPreferences in subsetQueries)
{
foreach (int subsetQueryPreference in subsetQueryPreferences)
{
containedPreferences.Add(subsetQueryPreference);
}
if (containedPreferences.Count == AllPreferencesCount)
{
return true;
}
}
return false;
}
/// <summary>
/// TODO: comment
/// </summary>
/// <param name="subset"></param>
/// <returns></returns>
public CLRSafeHashSet<int> GetSubsetComplement(CLRSafeHashSet<int> subset)
{
var subsetComplement = new CLRSafeHashSet<int>();
for (var i = 0; i < AllPreferencesCount; i++)
{
if (!subset.Contains(i))
{
subsetComplement.Add(i);
}
}
return subsetComplement;
}
private IEnumerable<CLRSafeHashSet<int>> UseSubsets(PrefSQLModel prefSqlModelSkylineSample)
{
var preferencesInSubsetExpected = new List<CLRSafeHashSet<int>>();
DataRow[] subsetsExpected =
TestContext.DataRow.GetChildRows("TestDataRow_useSubsets")[0].GetChildRows("useSubsets_subset");
foreach (DataRow subsetExpected in subsetsExpected)
{
DataRow[] subsetExpectedDimensions = subsetExpected.GetChildRows("subset_dimension");
var preferencesInSingleSubsetExpected = new CLRSafeHashSet<int>();
foreach (DataRow singleSubsetExpectedDimension in subsetExpectedDimensions)
{
for (var i = 0; i < prefSqlModelSkylineSample.Skyline.Count; i++)
{
AttributeModel attributeModel = prefSqlModelSkylineSample.Skyline[i];
if (attributeModel.FullColumnName == singleSubsetExpectedDimension[0].ToString())
{
preferencesInSingleSubsetExpected.Add(i);
break;
}
}
}
preferencesInSubsetExpected.Add(preferencesInSingleSubsetExpected);
}
return preferencesInSubsetExpected;
}
