public override void AddCommands(List<ToolBarCommand> commands) { base.AddCommands(commands); commands.Insert(0, tbcAdd); commands.Insert(1, tbcModify); commands.Insert(2, tbcView); }
private void AddIgnoredExtension(object _params) { string extension = _params as string; Debug.Assert(extension != null); extension = extension.ToLowerInvariant(); var ignoredExtensions = new List<string>(Settings.Default.IgnoredExtensions); if (!ignoredExtensions.Contains(extension)) { ignoredExtensions.Insert(0, extension); ClearInput(null); } Settings.Default.IgnoredExtensions = ignoredExtensions; Settings.Default.Save(); }
public async Task AddMostRecentEvent() { ServiceCancellation cancelSource = new ServiceCancellation(CancellationToken.None); MockReliableStateManager stateManager = new MockReliableStateManager(); IReliableDictionary<string, DeviceEvent> store = await stateManager.GetOrAddAsync<IReliableDictionary<string, DeviceEvent>>(DataService.EventDictionaryName); IReliableQueue<DeviceEventSeries> queue = await stateManager.GetOrAddAsync<IReliableQueue<DeviceEventSeries>>(DataService.EventQueueName); string expectedDeviceId = "some-device"; List<DeviceEvent> expectedDeviceList = new List<DeviceEvent>(); DeviceEvent expectedDeviceEvent = new DeviceEvent(new DateTimeOffset(100, TimeSpan.Zero)); for (int i = 0; i < 10; ++i) { expectedDeviceList.Add(new DeviceEvent(new DateTimeOffset(i, TimeSpan.Zero))); } expectedDeviceList.Insert(4, expectedDeviceEvent); EventsController target = new EventsController(stateManager, statefulServiceContext, cancelSource); IActionResult result = await target.Post(expectedDeviceId, expectedDeviceList); Assert.True(result is OkResult); using (ITransaction tx = stateManager.CreateTransaction()) { ConditionalValue<DeviceEvent> actualStoredEvent = await store.TryGetValueAsync(tx, expectedDeviceId); ConditionalValue<DeviceEventSeries> actualQueuedEvent = await queue.TryDequeueAsync(tx); Assert.True(actualStoredEvent.HasValue); Assert.Equal(expectedDeviceEvent.Timestamp, actualStoredEvent.Value.Timestamp); Assert.True(actualQueuedEvent.HasValue); Assert.True(actualQueuedEvent.Value.Events.Select(x => x.Timestamp).SequenceEqual(expectedDeviceList.Select(x => x.Timestamp))); await tx.CommitAsync(); } }
public override void AddCommands(List<ToolBarCommand> commands) { base.AddCommands(commands); commands.Insert(0, tbcCancel); commands.Insert(1, tbcUpdate); }
private List<OrganisationBaseObjectInfo<Department>> GetParents(DataProvider dataProvider, OrganisationBaseObjectInfo<Department> department) { var parents = new List<OrganisationBaseObjectInfo<Department>>(); for (OrganisationBaseObjectInfo<Department> current = department; current.Item.ParentDepartmentUID != Guid.Empty;) { current = dataProvider.Departments[current.Item.ParentDepartmentUID]; parents.Insert(0, current); } parents.Add(department); return parents; }
//Shunting yard algorithm public static double ProcessEquation(string equation, AttributeProperty property, int level, int previousLevel, float previousAnswer) { if (equation.Equals("")) { throw new ArgumentException("Equation is empty."); } List<string> result = new List<string>(Regex.Split(equation.ToLower().Trim())); for (int i = result.Count - 1; i >= 0; i--) { if (result[i].Equals("") || result[i].Equals(" ")) { result.RemoveAt(i); } } Queue<string> queue = new Queue<string>(); Stack<string> stack = new Stack<string>(); for (int i = 0; i < result.Count; i++) { if (result[i].Equals("x") || result[i].Equals("X")) { result[i] = level.ToString(); } else if (result[i].Equals("k") || result[i].Equals("K")) { if (previousLevel > 0) { result[i] = previousLevel.ToString(); } else { result[i] = "0"; } } else if (result[i].Equals("p") || result[i].Equals("P")) { result[i] = previousAnswer.ToString(); } else if (result[i].Equals("r") || result[i].Equals("R")) { float value = UnityEngine.Random.Range(1f, 1000f); value /= 1000f; result[i] = value.ToString(); } } TokenClass previousTokenClass = TokenClass.Value; for (int i = 0; i < result.Count; i++) { string element = result[i]; if (element.Equals("y") || element.Equals("=")) { continue; } TokenClass tokenClass = GetTokenClass(element); switch (tokenClass) { case TokenClass.Value: queue.Enqueue(element); break; case TokenClass.LeftParentheses: stack.Push(element); break; case TokenClass.RightParentheses: while (!stack.Peek().Equals("(")) { queue.Enqueue(stack.Pop()); } stack.Pop(); break; case TokenClass.Operator: if (element.Equals("-") && (previousTokenClass == TokenClass.Operator || previousTokenClass == TokenClass.LeftParentheses) && (stack.Count == 0 || result[i - 1].Equals("("))) { //Push unary operator "Negative" to stack. stack.Push("NEG"); break; } if (element.Equals("-") && (i + 1 < result.Count) && GetTokenClass(result[i + 1]) == TokenClass.Value) { if (previousTokenClass == TokenClass.Value) { stack.Push(element); } else { stack.Push("NEG"); } break; } if (stack.Count > 0) { string stackTopToken = stack.Peek(); if (GetTokenClass(stackTopToken) == TokenClass.Operator) { Associativity tokenAssociativity = GetAssociativity(stackTopToken); int tokenPrecedence = GetPrecedence(element); int stackTopPrecedence = GetPrecedence(stackTopToken); if ((tokenAssociativity == Associativity.Left && tokenPrecedence <= stackTopPrecedence) || (tokenAssociativity == Associativity.Right && tokenPrecedence < stackTopPrecedence)) { queue.Enqueue(stack.Pop()); } } } stack.Push(element); break; } if (tokenClass == TokenClass.Value || tokenClass == TokenClass.RightParentheses) { if (i < result.Count - 1) { string nextToken = result[i + 1]; TokenClass nextTokenClass = GetTokenClass(nextToken); if (nextTokenClass != TokenClass.Operator && nextTokenClass != TokenClass.RightParentheses) { result.Insert(i + 1, "*"); } } } previousTokenClass = tokenClass; } while (stack.Count > 0) { string operand = stack.Pop(); if (operand.Equals("(") || operand.Equals(")")) { throw new ArgumentException("Mismatched parentheses."); } queue.Enqueue(operand); } Stack<string> expressionStack = new Stack<string>(); while (queue.Count > 0) { string token = queue.Dequeue(); TokenClass tokenClass = GetTokenClass(token); if (tokenClass == TokenClass.Value) { expressionStack.Push(token); } else { double answer = 0f; if (tokenClass == TokenClass.Operator) { string rightOperand = expressionStack.Pop(); string leftOperand = expressionStack.Pop(); if (token.Equals("+")) { answer = double.Parse(leftOperand); answer += double.Parse(rightOperand); } else if (token.Equals("-")) { answer = double.Parse(leftOperand); answer -= double.Parse(rightOperand); } else if (token.Equals("*")) { answer = double.Parse(leftOperand); answer *= double.Parse(rightOperand); } else if (token.Equals("/")) { answer = double.Parse(leftOperand); answer /= double.Parse(rightOperand); } else if (token.Equals("^")) { double baseValue = double.Parse(leftOperand); double exponent = double.Parse(rightOperand); answer = Math.Pow(baseValue, exponent); } } else if (tokenClass == TokenClass.Negative) { string operand = expressionStack.Pop(); answer = double.Parse(operand) * -1f; } expressionStack.Push(answer.ToString()); } } if (expressionStack.Count != 1) { throw new ArgumentException("Invalid equation."); } double finalAnswer = double.Parse(expressionStack.Pop()); return finalAnswer; }
public ActionResult RetrievePersonList(string value) { var personType = (Persontype)Enum.Parse(typeof(Persontype), value); if (personType == Persontype.StakeHolder) { var list = this.projectStakeHolderService.RetrieveStackHolderList(SessionData.Instance.UserInfo.Developer.DeveloperID); var stakeHolderList = new List<StackHolderInfo>(); foreach (var item in list) { var stakeHolder = new StackHolderInfo(); stakeHolder.DeveloperID = item.StakeHolderID; stakeHolder.DeveloperName = item.FirstName; stakeHolderList.Add(stakeHolder); } ////StackHolderInfo defaultValue = AddDefaultStackHolder(); stakeHolderList.Insert(0, AddDefaultStackHolder()); return new JsonResult { Data = stakeHolderList, MaxJsonLength = int.MaxValue }; } else if (personType == Persontype.OnSiteTeam) { var list = this.developerService.RetrieveList(null, null, SessionData.Instance.UserInfo.Developer.DeveloperID); ////DeveloperListItem defaultValue = AddDefaultDeveloper(); list.Insert(0, AddDefaultDeveloper()); return new JsonResult { Data = list, MaxJsonLength = int.MaxValue }; } return this.Json(string.Empty); }
public Vector MF1(double t, Vector v, TaskParameters p) { var res = new Vector(1); if (p.Gamma is List<double>) { var pp = new List<double>(); (p.Gamma as List<double>).ForEach(x => pp.Add(x)); pp.Insert(0, double.MinValue); pp.Add(double.MaxValue); //double a = double.MinValue; double b = pp[0]; for (int i = 0; i < pp.Count - 1; i++) { if (v[0] > pp[i] && v[0] <= pp[i + 1]) { res[0] = CallSecFunc(SecFuncName, t, v, p[i]); } else continue; } } else if (p.Gamma is Dictionary<double, int>) { try { var tt = p.Gamma as Dictionary<double, int>; //int i = -1; double index = tt.Keys.ToList().Find(x => Math.Abs(x - t) < 0.01); res[0] = CallSecFunc(SecFuncName, t, v, p[tt[index]]); } catch (Exception) { res[0] = 1; } } else throw new NotImplementedException("not impl yet"); return res; }
public static IEnumerable<Candidate> GetCandidates( ExplorationSpace space, ExplorationNode start, ExplorationNode lastGoal, HashSet<uint> busyObjects, Scorer scorer, int numRecommendations, bool descending) { if (busyObjects == null) busyObjects = new HashSet<uint>(); List<Candidate> candidates = new List<Candidate>(); foreach (ExplorationNode node in space.Nodes) { if (start == node) continue; // Make sure it's reachable ExplorationEdge[] path = start.GetPathOut(node.Id); if (path != null) { // Add it as a candidate if the score is high enough double score = scorer(start, node); ExplorationEdge edge = path[0]; ExplorationNode goal = path.Last().Target; double sentimentScore = SentimentScore(score, path); candidates.Add(new Candidate(path, goal, sentimentScore)); } } // Sort the candidates by score candidates.Sort((c1, c2) => c1.Score.CompareTo(c2.Score)); if (descending == true) candidates.Reverse(); // Add the previous goal to the front if we still have a path to it if (lastGoal != null) { ExplorationEdge[] oldPath = start.GetPathOut(lastGoal.Id); if (oldPath != null) candidates.Insert(0, new Candidate(oldPath, lastGoal, 0.0)); } HashSet<ExplorationNode> seenGoals = new HashSet<ExplorationNode>(); HashSet<ExplorationEdge> seenEdges = new HashSet<ExplorationEdge>(); // Pick the top N int count = 0; foreach (Candidate candidate in candidates) { ExplorationNode goal = candidate.Goal; if (candidate.Path.Length == 0) continue; ExplorationEdge edge = candidate.Path[0]; // Nix this event if it uses an object that's currently in use // TODO: Assumes only one event per edge TransitionEvent evt = edge.Events[0]; foreach (uint id in evt.Participants) if (busyObjects.Contains(id) == true) goto skipCandidate; // If this is a novel direction to go, add it bool seenGoal = seenGoals.Contains(goal); bool seenEdge = seenEdges.Contains(edge); if (seenGoal == false && seenEdge == false) { seenGoals.Add(goal); seenEdges.Add(edge); count++; yield return candidate; } if (count >= numRecommendations) break; skipCandidate : continue; } }
public void InsertItem(ListItem item, int index) { items.Insert(index, item); }
public static IEnumerable<SelectListItem> ToSelectList(this IDictionary<string, string> items, bool blank = false, params string[] selected) { var list = new List<SelectListItem>(); if (items == null) return list; list.AddRange(items.Select(item => new SelectListItem { Value = item.Key, Text = item.Value, Selected = selected.Contains(item.Key), })); if (blank) list.Insert(0, new SelectListItem()); return list; }
public static IEnumerable<SelectListItem> ToSelectList(this IEnumerable<string> items, bool blank = false, params string[] selected) { var list = new List<SelectListItem>(); if (items == null) return list; list.AddRange(items.Where(i => i != null).Select(item => new SelectListItem { Value = item, Text = item, Selected = selected.Contains(item) })); if (blank) list.Insert(0, new SelectListItem()); return list; }