/// <summary>
/// import CSV file into subset
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
public Subset GetDataTableFromCsv(string path)
{
if (string.IsNullOrWhiteSpace(path))
{
throw new ArgumentException();
}
Subset mySubset = new Subset();
TextFieldParser parser = new TextFieldParser(path);
parser.TextFieldType = FieldType.Delimited;
parser.SetDelimiters(",");
while (!parser.EndOfData)
{
Line myline = new Line();
//Processing row
string[] fields = parser.ReadFields();
foreach (string field in fields)
{
//TODO: Process field
string t = field;
myline.LineInformation.Add(field);
}
mySubset.Nomenclature.Add(myline);
}
parser.Close();
return(mySubset);
}
private void Init(IQueryable <T> superset, int pageNumber, int pageSize)
{
if (pageSize < 1)
{
throw new ArgumentOutOfRangeException(nameof(pageSize), pageSize, "PageSize cannot be less than 1.");
}
PageSize = pageSize;
PageNumber = 1;
PageCount = TotalItemCount > 0 ? (int)Math.Ceiling(TotalItemCount / (double)PageSize) : 0;
if (pageNumber > 0 && pageNumber <= PageCount)
{
PageNumber = pageNumber;
}
HasPreviousPage = PageNumber > 1;
HasNextPage = PageNumber < PageCount;
IsFirstPage = PageNumber == 1;
IsLastPage = PageNumber >= PageCount;
FirstItemOnPage = (PageNumber - 1) * PageSize + 1;
var num = FirstItemOnPage + PageSize - 1;
LastItemOnPage = num > TotalItemCount ? TotalItemCount : num;
if (superset == null || TotalItemCount <= 0)
{
return;
}
var skipCount = pageNumber == 1 ? 0 : (pageNumber - 1) * pageSize;
Subset.AddRange(superset.Skip(skipCount).Take(pageSize).ToList());
}
public void UpdateTreeView(Subset poigneegaz)
{
treeView1.BeginUpdate();
int i = 0;
foreach (Line li in poigneegaz.Nomenclature)
{
if (li.CompoCost == 0)
{
treeView1.Nodes.Add(li.Designation);
}
if (li.CompoCost != 0)
{
treeView1.Nodes[i].Nodes.Add(li.Designation);
i++;
}
}
//treeView1.Nodes.Add("Parent");
//treeView1.Nodes[0].Nodes.Add("Child 1");
//treeView1.Nodes[0].Nodes.Add("Child 2");
//treeView1.Nodes[0].Nodes[1].Nodes.Add("Grandchild");
//treeView1.Nodes[0].Nodes[1].Nodes[0].Nodes.Add("Great Grandchild");
treeView1.EndUpdate();
}
protected override Subset <DefinitionInstruction> Join(Subset <DefinitionInstruction> left, Subset <DefinitionInstruction> right)
{
var result = left.Clone();
result.Union(right);
return(result);
}
/// <summary>
/// Merge the subsets of two items if they are not in the same set by grouping their parents.
/// </summary>
/// <param name="x">The first item.</param>
/// <param name="y">The second item.</param>
public void Union([NotNull] T x, [NotNull] T y)
{
if (Comparer.Equals(x, y))
{
return;
}
T xroot = Find(x);
T yroot = Find(y);
if (Comparer.Equals(xroot, yroot))
{
return;
}
if (Items[xroot].Rank > Items[yroot].Rank)
{
Items[yroot].Parent = xroot;
}
else
{
Subset xsubset = Items[xroot];
Subset ysubset = Items[yroot];
xsubset.Parent = yroot;
if (xsubset.Rank < ysubset.Rank)
{
ysubset.Rank += xsubset.Rank;
}
}
}
public void CheckArrays(Subset aSubset = null)
{
if (aSubset == null)
{
aSubset = this;
}
if (aSubset.mNormals.Count > 0)
{
CheckFilled <Vector3>(ref mNormals, Vector3.zero, mPoints.Count);
}
if (aSubset.mUVs.Count > 0)
{
CheckFilled <Vector2>(ref mUVs, Vector2.zero, mPoints.Count);
}
if (aSubset.mLightUVs.Count > 0)
{
CheckFilled <Vector2>(ref mLightUVs, Vector2.zero, mPoints.Count);
}
if (aSubset.mTangents.Count > 0)
{
CheckFilled <Vector4>(ref mTangents, Vector4.zero, mPoints.Count);
}
if (aSubset.mColors.Count > 0)
{
CheckFilled <Color>(ref mColors, Color.white, mPoints.Count);
}
}
public SubsetList CreateSubsets(IEnumerable <SubResult> subResults)
{
var result = new SubsetList();
if (subResults == null)
{
return(result);
}
var metadata = MetadataHelper.GetInitializedMetadata(_domainService);
foreach (var subResult in subResults)
{
var dbSetInfo = metadata.dbSets[subResult.dbSetName];
if (result.Any(r => r.dbSetName == subResult.dbSetName))
{
throw new DomainServiceException(string.Format("The included results already have {0} entities", dbSetInfo.dbSetName));
}
var rowGenerator = new RowGenerator(dbSetInfo, subResult.Result, _dataHelper);
var current = new Subset
{
dbSetName = dbSetInfo.dbSetName,
rows = rowGenerator.CreateDistinctRows(),
names = dbSetInfo.GetNames()
};
result.Add(current);
}
return(result);
}
public void MakeSet([NotNull] T item)
{
Subset subset = Items[item];
subset.Parent = item;
subset.Rank = 0;
}
public static void FindMinimumSpaningTree(UnDirectedGraph g)
{
DisJointSets dj = new DisJointSets();
Subset[] subsets = new Subset[g.Vertices.Length];
List <Edge> edgeList = new List <Edge>();
dj.MakeSet(subsets);
for (int i = 0; i < g.Vertices.Length; i++)
{
edgeList.AddRange(g.Vertices[i].Edges);
}
edgeList = edgeList.OrderBy(o => o.Weight).ToList();
foreach (var edge in edgeList)
{
int x = dj.FindSet(subsets, edge.Source.Index);
int y = dj.FindSet(subsets, edge.Destination.Index);
if (x != y)
{
Console.Write($"({edge.Source.Index},{edge.Destination.Index}) ");
dj.Union(subsets, x, y);
}
}
}
public void Given_Generated_Subsets_SortSubsets_Change_Order_Descending_Subsets_By_Total_Items_Value()
{
var subset1 = new Subset();
subset1.Items.Add(new Item(1, 1, 1));
subset1.Items.Add(new Item(1, 1, 6));
var subset2 = new Subset();
subset2.Items.Add(new Item(1, 6, 2));
var subset3 = new Subset();
subset3.Items.Add(new Item(1, 1, 24));
_container.AddSubset(subset1);
_container.AddSubset(subset2);
_container.AddSubset(subset3);
_container.SortSubsets();
Assert.Multiple(() =>
{
Assert.AreEqual(subset3, _container.Subsets[0]);
Assert.AreEqual(subset1, _container.Subsets[1]);
Assert.AreEqual(subset2, _container.Subsets[2]);
});
}
public void Given_Subsets_Which_Items_Fits_Container_FindBestSubset_Returns_Subset_With_Highest_TotalValue()
{
var subset1 = new Subset();
subset1.Items.Add(new Item(1, 1, 1));
subset1.Items.Add(new Item(1, 1, 6));
var subset2 = new Subset();
subset2.Items.Add(new Item(1, 1, 2));
var subset3 = new Subset();
subset3.Items.Add(new Item(1, 1, 24));
var subset4 = new Subset();
subset4.Items.Add(new Item(1, 1, 4));
subset4.Items.Add(new Item(1, 1, 14));
subset4.Items.Add(new Item(1, 1, 8));
_container.AddSubset(subset1);
_container.AddSubset(subset2);
_container.AddSubset(subset3);
_container.SortSubsets();
var subset = _container.FindBestSubset();
Assert.AreEqual(subset3, subset);
}
protected override Subset <IVariable> Join(Subset <IVariable> left, Subset <IVariable> right)
{
var result = left.Clone();
result.Union(right);
return(result);
}
public TwisterAlgorithm(
Subset subset,
bool chunkPositivePMI = true,
bool chunkAveragePMI = true,
int compressTagOccurence = 0,
int compressCorpusOccurence = 0,
LogicalOperatorEnum op = LogicalOperatorEnum.AND,
bool useRxy = true
) : base(subset)
{
_chunkPositivePMI = chunkPositivePMI;
_chunkAveragePMI = chunkAveragePMI;
if (compressCorpusOccurence > 0 && compressTagOccurence > 0)
{
// tOcc <= _compressTagOccurence
// cOcc <= _compressCorpusOccurence
var tPe = Expression.Parameter(typeof(int));
var cPe = Expression.Parameter(typeof(int));
var tConst = Expression.Constant(compressTagOccurence);
var cConst = Expression.Constant(compressCorpusOccurence);
var left = Expression.LessThanOrEqual(tPe, tConst);
var right = Expression.LessThanOrEqual(cPe, cConst);
var exp = (op == LogicalOperatorEnum.AND) ? Expression.And(left, right) : Expression.Or(left, right);
Expression <Func <int, int, bool> > le = Expression.Lambda <Func <int, int, bool> >(exp, tPe, cPe);
_compiledExpression = le.Compile();
}
}
private static void subset_complement_test()
//****************************************************************************80
//
// Purpose:
//
// SUBSET_COMPLEMENT_TEST tests SUBSET_COMPLEMENT.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 06 January 2016
//
// Author:
//
// John Burkardt
//
{
Console.WriteLine("");
Console.WriteLine("SUBSET_COMPLEMENT_TEST");
Console.WriteLine(" SUBSET_COMPLEMENT returns the complement of a subset.");
Console.WriteLine("");
const int n = 5;
int seed = 123456789;
int[] s1 = Subset.subset_random(n, ref seed);
typeMethods.i4vec_transpose_print(n, s1, " Subset S1: ");
int[] s2 = Subset.subset_complement(n, s1);
typeMethods.i4vec_transpose_print(n, s2, " S2 = complement of S1:");
}
private async Task InitAsync(IQueryable <T> superset, int pageNumber, int pageSize)
{
if (pageNumber < 1)
{
throw new ArgumentOutOfRangeException("pageNumber: " + pageNumber, "PageNumber cannot be below 1.");
}
if (pageSize < 1)
{
throw new ArgumentOutOfRangeException("pageSize: " + pageSize, "PageSize cannot be less than 1.");
}
TotalItemCount = (superset == null) ? 0 : superset.Count <T>();
PageSize = pageSize;
PageNumber = pageNumber;
PageCount = (TotalItemCount > 0) ? ((int)Math.Ceiling(((double)TotalItemCount) / PageSize)) : 0;
HasPreviousPage = PageNumber > 1;
HasNextPage = PageNumber < PageCount;
IsFirstPage = PageNumber == 1;
IsLastPage = PageNumber >= PageCount;
FirstItemOnPage = ((PageNumber - 1) * PageSize) + 1;
var num = (FirstItemOnPage + PageSize) - 1;
LastItemOnPage = (num > TotalItemCount) ? TotalItemCount : num;
if ((superset != null) && (TotalItemCount > 0))
{
Subset.AddRange(
(pageNumber == 1)
? await superset.Skip <T>(0).Take <T>(pageSize).ToListAsync <T>().ConfigureAwait(false)
: await superset.Skip <T>(((pageNumber - 1) * pageSize)).Take <T>(pageSize).ToListAsync <T>().ConfigureAwait(false)
);
}
}
public PagedList(IMongoQueryable <T> superset, int pageNumber, int pageSize)
{
if (pageNumber < 1)
{
throw new ArgumentOutOfRangeException("pageNumber", pageNumber, "PageNumber cannot be below 1.");
}
if (pageSize < 1)
{
throw new ArgumentOutOfRangeException("pageSize", pageSize, "PageSize cannot be less than 1.");
}
TotalItemCount = superset == null ? 0 : superset.Count();
PageSize = pageSize;
PageNumber = pageNumber;
PageCount = TotalItemCount > 0 ? (int)Math.Ceiling(TotalItemCount / (double)PageSize) : 0;
HasPreviousPage = PageNumber > 1;
HasNextPage = PageNumber < PageCount;
IsFirstPage = PageNumber == 1;
IsLastPage = PageNumber >= PageCount;
FirstItemOnPage = (PageNumber - 1) * PageSize + 1;
var numberOfLastItemOnPage = FirstItemOnPage + PageSize - 1;
LastItemOnPage = numberOfLastItemOnPage > TotalItemCount
? TotalItemCount
: numberOfLastItemOnPage;
if (superset != null && TotalItemCount > 0)
{
Subset.AddRange(pageNumber == 1
? superset.Skip(0).Take(pageSize).ToList()
: superset.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList()
);
}
}
//Kruskals min span algorithm
//1. Take all edges from the tree and sort them based on weight. (or in our case Enemy)
//2. Loop through edges and find the subset of either end of the edge.
//3. If they aren't in the same subset unify them by rank.
//4. If they are it means this edge we want to add will make a cycle. We don't like cycles. So we destroy that edge.
//5. Update the edges
public void Kruskal()
{
if (Rooms == null || Halls == null || Rooms.Count < 1 || Halls.Count < 1)
GetEdgesAndRooms();
//sort edges(halls) by weight (enemy)
List<Hall> sorted_edges = Halls.OrderBy(o => o.Enemy).ToList();
Subset[] subsets = new Subset[_roomCount];
//If necessary?
Dictionary<int, int> ids = new Dictionary<int, int>();
//init subset and ids dictonary
for (int i = 0; i < _roomCount; ++i) {
subsets[i].parent = i;
subsets[i].rank = 0;
//map indices to roomid
ids.Add(Rooms[i].Id, i);
}
//loop through edges
for (int j = 0; j < _edgeCount; ++j) {
int ia = ids[sorted_edges[j].enda.Id];
int ib = ids[sorted_edges[j].endb.Id];
int x = Find(subsets, ia);
int y = Find(subsets, ib);
if (x != y) {
Union(subsets, x, y);
} else {
sorted_edges[j].IsDestroyed = true;
}
}
Halls = sorted_edges;
UpdateEdges();
}
public static bool IsCycle(UnDirectedGraph g)
{
DisJointSets dj = new DisJointSets();
Subset[] subsets = new Subset[g.Vertices.Length];
dj.MakeSet(subsets);
for (int i = 0; i < g.Vertices.Length; i++)
{
int u = i;
foreach (var edge in g.Vertices[i].Edges)
{
int v = edge.Destination.Index;
int x = dj.FindSet(subsets, u);
int y = dj.FindSet(subsets, v);
if (x == y)
{
return(true);
}
dj.Union(subsets, x, y);
}
}
return(false);
}
public SerializablePagedList(IEnumerable <T> superset, int pageNumber, int pageSize) : this(superset.AsQueryable <T>(), pageNumber, pageSize)
{
// set source to blank list if superset is null to prevent exceptions
TotalItemCount = superset == null ? 0 : superset.Count();
PageSize = pageSize;
PageNumber = pageNumber;
PageCount = TotalItemCount > 0
? (int)Math.Ceiling(TotalItemCount / (double)PageSize)
: 0;
HasPreviousPage = PageNumber > 1;
HasNextPage = PageNumber < PageCount;
IsFirstPage = PageNumber == 1;
IsLastPage = PageNumber >= PageCount;
FirstItemOnPage = (PageNumber - 1) * PageSize + 1;
var numberOfLastItemOnPage = FirstItemOnPage + PageSize - 1;
LastItemOnPage = numberOfLastItemOnPage > TotalItemCount
? TotalItemCount
: numberOfLastItemOnPage;
// add items to internal list
if (superset != null && TotalItemCount > 0)
{
Subset.AddRange(pageNumber == 1
? superset.Skip(0).Take(pageSize).ToList()
: superset.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList()
);
}
}
public static Graph.Edge[] SolvePar(Graph.Edge[] edges, int verticesCount)
{
var mst = new Graph.Edge[verticesCount - 1];
Sort.StartSortPar(edges);
int i = 0;
int e = 0;
var subsets = new Subset[verticesCount];
for (int v = 0; v < verticesCount; v++)
{
subsets[v].Parent = v;
subsets[v].Rank = 0;
}
while (e < verticesCount - 1)
{
Graph.Edge nextEdge = edges[i++];
int x = Find(subsets, nextEdge.src);
int y = Find(subsets, nextEdge.dest);
if (x != y)
{
mst[e++] = nextEdge;
Union(subsets, x, y);
}
}
return(mst);
}
public virtual void CalculateMetrics(FeatureSubsetModel <IPredictorProducing <TOutput> > model,
ISubsetSelector subsetSelector, Subset subset, Batch batch, bool needMetrics)
{
if (!needMetrics || model == null || model.Metrics != null)
{
return;
}
using (var ch = Host.Start("Calculate metrics"))
{
RoleMappedData testData = subsetSelector.GetTestData(subset, batch);
// Because the training and test datasets are drawn from the same base dataset, the test data role mappings
// are the same as for the train data.
IDataScorerTransform scorePipe = ScoreUtils.GetScorer(model.Predictor, testData, Host, testData.Schema);
// REVIEW: Should we somehow allow the user to customize the evaluator?
// By what mechanism should we allow that?
var evalComp = GetEvaluatorSubComponent();
RoleMappedData scoredTestData = RoleMappedData.Create(scorePipe,
GetColumnRoles(testData.Schema, scorePipe.Schema));
IEvaluator evaluator = evalComp.CreateInstance(Host);
// REVIEW: with the new evaluators, metrics of individual models are no longer
// printed to the Console. Consider adding an option on the combiner to print them.
// REVIEW: Consider adding an option to the combiner to save a data view
// containing all the results of the individual models.
var metricsDict = evaluator.Evaluate(scoredTestData);
if (!metricsDict.TryGetValue(MetricKinds.OverallMetrics, out IDataView metricsView))
{
throw Host.Except("Evaluator did not produce any overall metrics");
}
// REVIEW: We're assuming that the metrics of interest are always doubles here.
var metrics = EvaluateUtils.GetMetrics(metricsView, getVectorMetrics: false);
model.Metrics = metrics.ToArray();
ch.Done();
}
}
/// <summary>
/// Initializes a new instance of a type deriving from <see cref = "BasePagedList{T}" /> and sets properties needed to calculate position and size data on the subset and superset.
/// </summary>
/// <param name="subset">The single subset this collection should represent.</param>
/// <param name = "pageNumber">The one-based index of the subset of objects contained by this instance.</param>
/// <param name = "pageSize">The maximum size of any individual subset.</param>
/// <param name = "totalItemCount">The size of the superset.</param>
protected internal PagedList(IEnumerable <T> subset, int pageNumber, int pageSize, int totalItemCount)
{
if (pageNumber < 1)
{
throw new ArgumentOutOfRangeException($"pageNumber = {pageNumber}. PageNumber cannot be below 1.");
}
if (pageSize < 1)
{
throw new ArgumentOutOfRangeException($"pageSize = {pageSize}. PageSize cannot be less than 1.");
}
// set source to blank list if superset is null to prevent exceptions
TotalItemCount = totalItemCount;
PageNumber = pageNumber;
PageSize = pageSize;
PageCount = TotalItemCount > 0
? (int)Math.Ceiling(TotalItemCount / (double)PageSize)
: 0;
HasPreviousPage = PageNumber > 1;
HasNextPage = PageNumber < PageCount;
IsFirstPage = PageNumber == 1;
IsLastPage = PageNumber == PageCount;
FirstItemOnPage = (PageNumber - 1) * PageSize + 1;
var numberOfLastItemOnPage = FirstItemOnPage + PageSize - 1;
LastItemOnPage = numberOfLastItemOnPage > TotalItemCount
? TotalItemCount
: numberOfLastItemOnPage;
Subset.AddRange(subset);
}
public SubsetList CreateSubsets(IEnumerable <SubResult> subResults)
{
SubsetList result = new SubsetList();
if (subResults == null)
{
return(result);
}
foreach (SubResult subResult in subResults)
{
DbSetInfo dbSetInfo = _metadata.DbSets[subResult.dbSetName];
if (result.Any(r => r.dbSetName == subResult.dbSetName))
{
throw new DomainServiceException(string.Format("The included sub results already have DbSet {0} entities", dbSetInfo.dbSetName));
}
RowGenerator rowGenerator = new RowGenerator(dbSetInfo, subResult.Result, _dataHelper);
Subset current = new Subset
{
dbSetName = dbSetInfo.dbSetName,
rows = rowGenerator.CreateDistinctRows(),
names = dbSetInfo.GetNames()
};
result.Add(current);
}
return(result);
}
public override void CalculateMetrics(FeatureSubsetModel <IPredictorProducing <TOutput> > model,
ISubsetSelector subsetSelector, Subset subset, Batch batch, bool needMetrics)
{
base.CalculateMetrics(model, subsetSelector, subset, batch, needMetrics);
var vm = model.Predictor as IValueMapper;
Host.Check(vm != null, "Predictor doesn't implement the expected interface");
var map = vm.GetMapper <VBuffer <Single>, TOutput>();
TOutput[] preds = new TOutput[100];
int count = 0;
var data = subsetSelector.GetTestData(subset, batch);
using (var cursor = new FeatureFloatVectorCursor(data, CursOpt.AllFeatures))
{
while (cursor.MoveNext())
{
Utils.EnsureSize(ref preds, count + 1);
map(in cursor.Features, ref preds[count]);
count++;
}
}
Array.Resize(ref preds, count);
_predictions[model] = preds;
}
public SerializablePagedList(IEnumerable <T> superset, int pageNumber, int pageSize, int totalCount) : this(superset.AsQueryable <T>(), pageNumber, pageSize)
{
// set source to blank list if superset is null to prevent exceptions
TotalItemCount = totalCount;
PageSize = pageSize;
PageNumber = pageNumber;
PageCount = TotalItemCount > 0
? (int)Math.Ceiling(TotalItemCount / (double)PageSize)
: 0;
HasPreviousPage = PageNumber > 1;
HasNextPage = PageNumber < PageCount;
IsFirstPage = PageNumber == 1;
IsLastPage = PageNumber >= PageCount;
FirstItemOnPage = (PageNumber - 1) * PageSize + 1;
var numberOfLastItemOnPage = FirstItemOnPage + PageSize - 1;
LastItemOnPage = numberOfLastItemOnPage > TotalItemCount
? TotalItemCount
: numberOfLastItemOnPage;
// add items to internal list
if (superset == null || TotalItemCount <= 0 || Subset.Count > 0)
{
return;
}
var enumerable = superset as IList <T> ?? superset.ToList();
Subset.AddRange(enumerable.ToList());
}
private static void subset_enum_test()
//****************************************************************************80
//
// Purpose:
//
// SUBSET_ENUM_TEST tests SUBSET_ENUM.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 27 November 2015
//
// Author:
//
// John Burkardt
//
{
int n;
Console.WriteLine("");
Console.WriteLine("SUBSET_ENUM_TEST");
Console.WriteLine(" SUBSET_ENUM enumerates subsets of a set of N items.");
Console.WriteLine("");
for (n = 0; n <= 10; n++)
{
int subset_num = Subset.subset_enum(n);
Console.WriteLine(" " + n.ToString().PadLeft(2)
+ " " + subset_num.ToString().PadLeft(6) + "");
}
}
async Task Init(IQueryable <T> superset, int pageNumber, int pageSize)
{
if (pageNumber < 1)
{
throw new ArgumentOutOfRangeException("pageNumber", pageNumber, "PageNumber cannot be below 1.");
}
if (pageSize < 1)
{
throw new ArgumentOutOfRangeException("pageSize", pageSize, "PageSize cannot be less than 1.");
}
TotalItemCount = superset == null ? 0 : await superset.CountAsync();
PageSize = pageSize;
PageNumber = pageNumber;
PageCount = TotalItemCount > 0 ? (int)Math.Ceiling(TotalItemCount / (double)PageSize) : 0;
HasPreviousPage = PageNumber > 1;
HasNextPage = PageNumber < PageCount;
IsFirstPage = PageNumber == 1;
IsLastPage = PageNumber >= PageCount;
FirstItemOnPage = (PageNumber - 1) * PageSize + 1;
var num = FirstItemOnPage + PageSize - 1;
LastItemOnPage = num > TotalItemCount ? TotalItemCount : num;
if (superset == null || TotalItemCount <= 0)
{
return;
}
Subset.AddRange(pageNumber == 1 ? await superset.Skip(0).Take(pageSize).ToListAsync() : await superset.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToListAsync());
}
public PagedList(IQueryable <T> superset, Expression <Func <T> > keySelector, int pageNumber, int pageSize)
{
if (pageNumber < 1)
{
throw new ArgumentOutOfRangeException(nameof(pageNumber));
}
if (pageSize < 1)
{
throw new ArgumentOutOfRangeException(nameof(pageSize));
}
// set source to blank list if superset is null to prevent exceptions
TotalItemCount = superset == null ? 0 : superset.Count();
PageSize = pageSize;
PageNumber = pageNumber;
PageCount = TotalItemCount > 0 ? (int)Math.Ceiling(TotalItemCount / (double)PageSize) : 0;
HasPreviousPage = PageNumber > 1;
HasNextPage = PageNumber < PageCount;
IsFirstPage = PageNumber == 1;
IsLastPage = PageNumber >= PageCount;
FirstItemOnPage = (PageNumber - 1) * PageSize + 1;
var numberOfLastItemOnPage = FirstItemOnPage + PageSize - 1;
LastItemOnPage = numberOfLastItemOnPage > TotalItemCount ? TotalItemCount : numberOfLastItemOnPage;
// add items to internal list
if (superset != null && TotalItemCount > 0)
{
Subset.AddRange(pageNumber == 1 ? superset.Take(pageSize).ToList() : superset.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList());
}
}
private void RuleInfoGUI()
{
if (m_SelectionState.Rule == null)
{
return;
}
if (m_SelectionState.Rule.Conditions == null)
{
m_TargetState.UndoTarget.MarkDirty("Initialized Conditions");
m_SelectionState.Rule.Conditions = new RSConditionData[0];
}
if (m_SelectionState.Rule.Actions == null)
{
m_TargetState.UndoTarget.MarkDirty("Initialized Actions");
m_SelectionState.Rule.Actions = new RSActionData[0];
}
RuleGUILayout.RuleData(m_TargetState.UndoTarget, m_SelectionState.Rule, m_SelectionState.Table, GetBaseFlags(), m_Context);
EditorGUILayout.Separator();
m_ScrollState.RuleScroll = GUILayout.BeginScrollView(m_ScrollState.RuleScroll, false, false);
{
EditorGUILayout.LabelField(Content.RuleConditionListLabel, RSGUIStyles.SubHeaderStyle);
if (m_ConditionList == null)
{
ConfigureConditionList(m_SelectionState.Rule, ref m_ConditionList);
}
m_ConditionList.array = m_SelectionState.Rule.Conditions;
m_ConditionList.DoLayout();
using (new EditorGUI.DisabledScope(m_SelectionState.Rule.Conditions.Length == 0))
{
Subset currentSubset = m_SelectionState.Rule.ConditionSubset;
Subset nextSubset = (Subset)EditorGUILayout.EnumPopup(Content.RuleConditionSubsetLabel, currentSubset);
if (currentSubset != nextSubset)
{
m_TargetState.UndoTarget.MarkDirty("Changed Rule Conditions Subset");
m_SelectionState.Rule.ConditionSubset = nextSubset;
}
}
EditorGUILayout.Separator();
EditorGUILayout.LabelField(Content.RuleActionListLabel, EditorStyles.boldLabel);
if (m_ActionList == null)
{
ConfigureActionList(m_SelectionState.Rule, ref m_ActionList);
}
m_ActionList.array = m_SelectionState.Rule.Actions;
m_ActionList.DoLayout();
}
GUILayout.EndScrollView();
}
public void OverallTest()
{
var set = new Subset <int>(new[] { 0, 1, 2, 4 });
var subset = new Subset <int>(set, new[] { 3 });
Contract.Assert(subset.Count == 1);
Contract.Assert(subset[0] == 4);
}
public CLabelFeatureDataSubset(CLabelFeatureData labelFeatureData, Subset subset)
: base(labelFeatureData)
{
this.cSubSet = 0;
this.mapTbl = new int[labelFeatureData.NumDataPoint];
for (int i = 0; i < labelFeatureData.NumDataPoint; i++)
{
if (subset.Keep(i))
{
this.mapTbl[this.cSubSet++] = i;
}
}
}
void LoadFromOBJFile(string filename)
{
var file = new StreamReader(filename);
var directory = Path.GetDirectoryName(filename);
var positions = new List<Vector4>();
var textureCoords = new List<Vector2>();
var normals = new List<Vector3>();
Subset subset = null;
while (true)
{
string nextLine = file.ReadLine();
if (nextLine == null) // end of file
break;
var terms = nextLine.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
if (terms.Length == 0) // empty line
continue;
var command = terms[0];
if (command == "#" || command == "")
{
// comment
}
else if (command == "v") // position
{
float x = float.Parse(terms[1]);
float y = float.Parse(terms[2]);
float z = float.Parse(terms[3]);
positions.Add(new Vector4(x, y, z, 1));
}
else if (command == "vt") // texture coord
{
float u = float.Parse(terms[1]);
float v = float.Parse(terms[2]);
textureCoords.Add(new Vector2(u, v));
}
else if (command == "vn") // normal
{
float x = float.Parse(terms[1]);
float y = float.Parse(terms[2]);
float z = float.Parse(terms[3]);
normals.Add(new Vector3(x, y, z));
}
else if (command == "f") // face
{
for (int i = 0; i < 3; i++)
{
// TODO: suppoprt relative (negative) indices
var indices = terms[1 + i].Split('/');
var vertex = new VertexPositionNormalTexture();
vertex.position = positions[int.Parse(indices[0]) - 1]; // OBJ indices are 1-based
if (indices[1] != "") // optional texture coords
vertex.texture = textureCoords[int.Parse(indices[1]) - 1];
if (indices[2] != "") // optional normal
vertex.normal = normals[int.Parse(indices[2]) - 1];
vertices.Add(vertex);
subset.length++;
}
}
else if (command == "mtllib") // .mtl file reference
{
LoadMTLFile(directory + "/" + terms[1]);
}
else if (command == "usemtl") // material
{
var name = terms[1];
Material material = null;
if (materials.ContainsKey(name))
material = materials[name];
else
{
material = new Material();
materials.Add(name, material);
}
subset = new Subset();
subset.material = material;
subset.start = vertices.Count; // next vertex to be created
subsets.Add(subset);
}
else
{
// unimplemented or unrecognized command
}
}
file.Close();
}
public void GetSubsets()
{
int i = 0;
while(i < subsetCount) {
//Debug.Log("Subset [" + i + "]");
Subset sub = new Subset();
sub.offset = FTell();
sub.useFloat = useFloat;
subset.Add(sub);
sub.Start();
size += sub.size;
i++;
}
}
