public Set RandomSample(Set InputSet, int k)
{
int n = InputSet.Tuples.Count;
if (k >= n)
{
return(InputSet);
}
System.Random r = new System.Random();
SetBuilder sb = new SetBuilder();
int i = n;
foreach (Tuple t in InputSet.Tuples)
{
int rnd = r.Next(i);
if (rnd < k)
{
k--;
sb.Add(t);
}
i--;
}
return(sb.ToSet());
}
public Set GetFunctionalDepartmentSetByUser()
{
SetBuilder sb = new SetBuilder();
try
{
DataSet dsUsersFunctionalDepartments = GetGACSFunctionDepartmentsByUser();
if (dsUsersFunctionalDepartments.Tables.Count == 1) // if the dataset is populated with one datatable (which should be the case)
{
DataTable dtUsersFunctionalDepartments = dsUsersFunctionalDepartments.Tables[0];
foreach (DataRow row in dtUsersFunctionalDepartments.Rows) // loop through each functional department returned by GACS
{
MemberCollection members = Context.CurrentCube.Dimensions["Functional Department"].Hierarchies["Functional Department"].Levels[1].GetMembers(); // Context.CurrentCube.Dimensions["Functional Department"].AttributeHierarchies["FunctionalDepartmentHierarchy"].Levels["FunctionalDepartment"].GetMembers();
foreach (Member m in members) // foreach functional department returned by the cube
{
if (String.Compare(row[0].ToString(), m.Name, true) == 0) // if CUBE.FunctionalDepartmentName = GACS.FunctionalDepartmentName
{
TupleBuilder tb = new TupleBuilder();
tb.Add(new Expression(string.Format(m.UniqueName)).CalculateMdxObject(null).ToMember());
sb.Add(tb.ToTuple());
}
}
}
}
}
catch (Exception e)
{
// because sb is outside the scope of the try statement, in the event of an exception an empty set should be returned, i.e.: no access to any functional departments
}
return(sb.ToSet());
}
//</snippetGetNodeDescription>
//<snippetRandomSample>
public Set RandomSample(Set set, int returnCount)
{
//Return the original set if there are fewer tuples
//in the set than the number requested.
if (set.Tuples.Count <= returnCount)
{
return(set);
}
System.Random r = new System.Random();
SetBuilder returnSet = new SetBuilder();
//Retrieve random tuples until the return set is filled.
int i = set.Tuples.Count;
foreach (Tuple t in set.Tuples)
{
if (r.Next(i) < returnCount)
{
returnCount--;
returnSet.Add(t);
}
i--;
//Stop the loop if we have enough tuples.
if (returnCount == 0)
{
break;
}
}
return(returnSet.ToSet());
}
public Set GetFunctionalDepartmentSetByUser()
{
SetBuilder sb = new SetBuilder();
try
{
DataSet dsUsersFunctionalDepartments = GetGACSFunctionDepartmentsByUser();
if (dsUsersFunctionalDepartments.Tables.Count == 1) // if the dataset is populated with one datatable (which should be the case)
{
DataTable dtUsersFunctionalDepartments = dsUsersFunctionalDepartments.Tables[0];
foreach (DataRow row in dtUsersFunctionalDepartments.Rows) // loop through each functional department returned by GACS
{
MemberCollection members = Context.CurrentCube.Dimensions["Functional Department"].Hierarchies["Functional Department"].Levels[1].GetMembers(); // Context.CurrentCube.Dimensions["Functional Department"].AttributeHierarchies["FunctionalDepartmentHierarchy"].Levels["FunctionalDepartment"].GetMembers();
foreach (Member m in members) // foreach functional department returned by the cube
{
if (String.Compare(row[0].ToString(), m.Name, true) == 0) // if CUBE.FunctionalDepartmentName = GACS.FunctionalDepartmentName
{
TupleBuilder tb = new TupleBuilder();
tb.Add(new Expression(string.Format(m.UniqueName)).CalculateMdxObject(null).ToMember());
sb.Add(tb.ToTuple());
}
}
}
}
}
catch (Exception e)
{
// because sb is outside the scope of the try statement, in the event of an exception an empty set should be returned, i.e.: no access to any functional departments
}
return sb.ToSet();
}
/// <summary>
/// Filter a set of members by an expression
/// </summary>
/// <param name="set"></param>
/// <param name="filterExpression"></param>
/// <returns></returns>
//<snippetFilterSet>
public static Set FilterSet(Set set, String filterExpression)
{
Expression expr = new Expression(filterExpression);
SetBuilder resultSetBuilder = new SetBuilder();
foreach (Tuple tuple in set)
{
if ((bool)(expr.Calculate(tuple)))
{
resultSetBuilder.Add(tuple);
}
}
return(resultSetBuilder.ToSet());
}
public Set ReverseSet(Set InputSet)
{
SetBuilder sb = new SetBuilder();
List <Tuple> l = new List <Tuple>();
int c = 0;
foreach (Tuple t in InputSet.Tuples) //use enumerator, not indexes as specified at http://sqljunkies.com/WebLog/mosha/archive/2007/04/19/stored_procs_best_practices.aspx
{
l.Add(t);
c++;
Context.CheckCancelled();
}
for (int i = c - 1; i >= 0; i--)
{
sb.Add(l[i]);
}
return(sb.ToSet());
}
public static Set Order(Set InputSet, Expression SortExpression, bool SortDescending)
{
List <TupleValue> TupleValues = new List <TupleValue>();
Context.TraceEvent(100, 0, "Order: Start getting data");
int i = 0;
foreach (Tuple t in InputSet.Tuples)
{
TupleValues.Add(new TupleValue(t, (double)SortExpression.Calculate(t)));
i++;
//no need to call Context.CheckCancelled() because Calculate already checks it
}
int cTuples = i;
Context.TraceEvent(100, cTuples, "Order: Finish getting data for " + cTuples.ToString() + " tuples");
Context.TraceEvent(200, cTuples, "Order: Start sorting");
TupleValues.Sort();
Context.TraceEvent(200, cTuples, "Order: Finish sorting");
SetBuilder sb = new SetBuilder();
if (SortDescending)
{
for (i = 0; i < cTuples; i++)
{
sb.Add(TupleValues[i].Tuple);
}
}
else
{
for (i = cTuples - 1; i >= 0; i--)
{
sb.Add(TupleValues[i].Tuple);
}
}
return(sb.ToSet());
}
public Set AsymmetricDrillDown(Set InputSet, int TupleIndex, int HierarchyIndex)
{
int cHier = InputSet.Hierarchies.Count;
if (HierarchyIndex >= cHier)
{
throw new System.ArgumentOutOfRangeException("Specified hierarchy index is out of range");
}
SetBuilder sb = new SetBuilder();
int i = 0;
foreach (Tuple t in InputSet.Tuples)
{
sb.Add(t);
if (i == TupleIndex)
{
Member m = t.Members[HierarchyIndex];
foreach (Member child in m.GetChildren())
{
TupleBuilder tb = new TupleBuilder();
for (int iHier = 0; iHier < cHier; iHier++)
{
if (iHier != HierarchyIndex)
{
tb.Add(t.Members[iHier]);
}
else
{
tb.Add(child);
}
}
sb.Add(tb.ToTuple());
}
}
i++;
}
return(sb.ToSet());
}
public static Set RegExFilter(Set setToFilter, String pattern, Expression exp, Boolean caseSensitive)
{
Context.TraceEvent(100, 0, "RegExFilter: Starting");
// If there is no startsWith string, just return the whole set
if (pattern.Length == 0)
{
Context.TraceEvent(100, 0, "RegExFilter: Finished (No pattern parameter)");
return(setToFilter);
}
if (setToFilter == null)
{
throw new ArgumentNullException("setToFilter");
}
else
{
using (SetBuilder sb = new SetBuilder())
{
RegexOptions optRegex = RegexOptions.Compiled;
if (!caseSensitive)
{
optRegex = optRegex | RegexOptions.IgnoreCase;
}
Regex r = getCachedRegEx(pattern, optRegex);
foreach (Tuple t in setToFilter.Tuples)
{
string val = (string)exp.Calculate(t);
if (r.Match(val).Success)
{
sb.Add(t);
}
}
Context.TraceEvent(100, sb.Count, "RegExFilter: Finished (returning " + sb.Count.ToString() + " tuples");
return(sb.ToSet());
}
}
} // End Like
public Set InverseHierarchility(Set InputSet)
{
int c = InputSet.Hierarchies.Count;
if (c < 2)
{
return(InputSet);
}
SetBuilder sb = new SetBuilder();
foreach (Tuple t in InputSet.Tuples)
{
TupleBuilder tb = new TupleBuilder();
for (int i = c - 1; i >= 0; i--)
{
tb.Add(t.Members[i]);
}
sb.Add(tb.ToTuple());
}
return(sb.ToSet());
}
private static Set buildAsymmetricSet(params Member[] memberList)
{
Context.TraceEvent(100, 0, "AsymmetricSet: Starting");
// build a list of all the unique Hierarchies from the members in memberList.
List <Hierarchy> hierList = new List <Hierarchy>();
foreach (Member m in memberList)
{
// Check that the member variable is correctly populated. If the user passes
// in a non-existant member we get a member object whose properties are all
// null or empty strings.
if (m.UniqueName.Length > 0)
{
if (!hierList.Exists(delegate(Hierarchy h) { if (h.UniqueName == m.ParentLevel.ParentHierarchy.UniqueName)
{
return(true);
}
else
{
return(false);
} }))
{
hierList.Add(m.ParentLevel.ParentHierarchy);
}
}
}
// SetBuilder & TupleBuilder are IDisposeable so we ensure they
// are disposed by utilizing a using block.
using (SetBuilder asymSet = new SetBuilder())
{
foreach (Member paramMbr in memberList)
{
if (paramMbr.UniqueName.Length > 0)
{
// create a tuple for each member that was passed in,
// combined with the default member from the other hierarchies.
using (TupleBuilder tb = new TupleBuilder())
{
foreach (Hierarchy h in hierList) // for each unique hierarchy
{
Hierarchy paramHier = paramMbr.ParentLevel.ParentHierarchy;
if (paramHier.UniqueName == h.UniqueName)
{
//System.Diagnostics.Trace.WriteLine("Adding member " + paramMbr.UniqueName);
tb.Add(paramMbr);
}
else
{
Member defMbr = MDX.StrToSet(h.DefaultMember).Tuples[0].Members[0];
//System.Diagnostics.Trace.WriteLine("Adding default member " + defMbr.UniqueName);
tb.Add(defMbr);
}
}
Tuple t = tb.ToTuple();
// if the members added to the TupleBuilder will result in a non-existant tuple
// (eg. [Calendar Quarter 1] and [December]) the ToTuple method returns a Tuple
// containing 0 members. If such a tuple is added to the SetBuilder, the
// SetBuilder.ToSet will throw an exception
if (t.Members.Count > 0)
{
asymSet.Add(tb.ToTuple());
}
} // using tb
}
} //foreach paramMbr
Context.TraceEvent(100, asymSet.Count, "AsymmetricSet: Finished (" + asymSet.Count.ToString() + " tuples generated)");
return(asymSet.ToSet());
} //using SetBuilder
}
public void GenerateSet()
{
Instances = SetBuilder.GetSet().ToList();
}
private static Set buildAsymmetricSet(params Member[] memberList)
{
Context.TraceEvent(100, 0, "AsymmetricSet: Starting");
// build a list of all the unique Hierarchies from the members in memberList.
List<Hierarchy> hierList = new List<Hierarchy>();
foreach (Member m in memberList)
{
// Check that the member variable is correctly populated. If the user passes
// in a non-existant member we get a member object whose properties are all
// null or empty strings.
if (m.UniqueName.Length > 0)
{
if (!hierList.Exists(delegate(Hierarchy h) { if (h.UniqueName == m.ParentLevel.ParentHierarchy.UniqueName) return true; else return false; }))
hierList.Add(m.ParentLevel.ParentHierarchy);
}
}
// SetBuilder & TupleBuilder are IDisposeable so we ensure they
// are disposed by utilizing a using block.
using (SetBuilder asymSet = new SetBuilder())
{
foreach (Member paramMbr in memberList)
{
if (paramMbr.UniqueName.Length > 0)
{
// create a tuple for each member that was passed in,
// combined with the default member from the other hierarchies.
using (TupleBuilder tb = new TupleBuilder())
{
foreach (Hierarchy h in hierList) // for each unique hierarchy
{
Hierarchy paramHier = paramMbr.ParentLevel.ParentHierarchy;
if (paramHier.UniqueName == h.UniqueName)
{
//System.Diagnostics.Trace.WriteLine("Adding member " + paramMbr.UniqueName);
tb.Add(paramMbr);
}
else
{
Member defMbr = MDX.StrToSet(h.DefaultMember).Tuples[0].Members[0];
//System.Diagnostics.Trace.WriteLine("Adding default member " + defMbr.UniqueName);
tb.Add(defMbr);
}
}
Tuple t = tb.ToTuple();
// if the members added to the TupleBuilder will result in a non-existant tuple
// (eg. [Calendar Quarter 1] and [December]) the ToTuple method returns a Tuple
// containing 0 members. If such a tuple is added to the SetBuilder, the
// SetBuilder.ToSet will throw an exception
if (t.Members.Count > 0) { asymSet.Add(tb.ToTuple()); }
}// using tb
}
} //foreach paramMbr
Context.TraceEvent(100, asymSet.Count, "AsymmetricSet: Finished (" + asymSet.Count.ToString() + " tuples generated)");
return asymSet.ToSet();
} //using SetBuilder
}
private static Set TopCountWithTiesInternal(Set InputSet, int NCount, Expression SortExpression, bool Desc)
{
List <TupleValue> TupleValues = new List <TupleValue>();
PriorityQueue queue = new PriorityQueue();
foreach (Tuple t in InputSet.Tuples)
{
double dblValue = (double)SortExpression.Calculate(t);
if (!Desc)
{
dblValue = -dblValue;
}
TupleValue tv = new TupleValue(t, dblValue);
bool bInsertTuple = false;
if (queue.Count < NCount || queue.CountWithoutTies < NCount) //short circuit on simple count... only hit CountWithTies when needed
{
bInsertTuple = true;
}
else
{
TupleValue r = (TupleValue)queue.Peek();
int cmp = tv.CompareTo(r);
if (cmp > 0)
{
//a new lower value is being added which bumps off the highest value
//if there's a tie for the highest value, bump all the ties off
while (r.CompareTo((TupleValue)queue.Peek()) == 0)
{
queue.Pop();
}
bInsertTuple = true;
}
else if (cmp == 0)
{
bInsertTuple = true;
}
}
if (bInsertTuple)
{
queue.Push(tv);
}
}
System.Collections.Generic.Stack <TupleValue> stack = new System.Collections.Generic.Stack <TupleValue>(queue.Count);
while (queue.Count > 0)
{
TupleValue tv = (TupleValue)queue.Pop();
stack.Push(tv);
}
SetBuilder sb = new SetBuilder();
while (stack.Count > 0)
{
TupleValue tv = stack.Pop();
sb.Add(tv.Tuple);
}
return(sb.ToSet());
}
public string RecentBuildsJson(string SummonerName)
{
return(new JavaScriptSerializer().Serialize(SetBuilder.GetRecentGameBuilds(SummonerName)));
}
public static Set RegExFilter(Set setToFilter, String pattern, Expression exp, Boolean caseSensitive)
{
Context.TraceEvent(100, 0, "RegExFilter: Starting");
// If there is no startsWith string, just return the whole set
if (pattern.Length == 0)
{
Context.TraceEvent(100, 0, "RegExFilter: Finished (No pattern parameter)");
return setToFilter;
}
if (setToFilter == null)
{
throw new ArgumentNullException("setToFilter");
}
else
{
using(SetBuilder sb = new SetBuilder())
{
RegexOptions optRegex = RegexOptions.Compiled;
if (!caseSensitive)
{
optRegex = optRegex | RegexOptions.IgnoreCase;
}
Regex r = getCachedRegEx(pattern, optRegex);
foreach (Tuple t in setToFilter.Tuples)
{
string val = (string)exp.Calculate(t);
if (r.Match(val).Success)
{
sb.Add(t);
}
}
Context.TraceEvent(100, sb.Count, "RegExFilter: Finished (returning " + sb.Count.ToString() + " tuples");
return sb.ToSet();
}
}
}
public ActionResult Index()
{
return(View(SetBuilder.GetUpsetModel()));
}
public string GetMatchJson(long MatchId, long SummonerId, int Damage)
{
return(new JavaScriptSerializer().Serialize(SetBuilder.GetMatchBuild(MatchId, SummonerId, Damage)));
}
