static void Main(string[] args) { SortedSet <int> n = new SortedSet <int>(); SortedSet <int> m = new SortedSet <int>(); int[] lengths = Console.ReadLine().Split().Select(s => Int32.Parse(s)).ToArray(); for (int i = 0; i < lengths[0]; i++) { int temp = Int32.Parse(Console.ReadLine()); if (!n.Any(k => k == temp)) { n.Add(temp); } } for (int i = 0; i < lengths[1]; i++) { int temp = Int32.Parse(Console.ReadLine()); if (!m.Any(k => k == temp)) { m.Add(temp); } } StringBuilder sb = new StringBuilder(); foreach (var el in n) { if (m.Any(e => e == el)) { sb.Append(el + " "); } } Console.WriteLine(sb.ToString().Trim()); Console.ReadLine(); }
public void TestSortedSet() { var set = new SortedSet <int>(); var r1 = set.Add(1); var r1Again = set.Add(1); set.Add(2); set.Add(3); set.Add(4); set.Add(6); set.Add(7); set.Add(8); //重复加返回false Assert.IsTrue(r1); Assert.IsFalse(r1Again); //where 后toList还是保持本来的顺序 var where = set.Where(a => a < 6).ToList(); Assert.AreEqual(where[0], 1); if (set.Any(s => s < -1)) { //不会执行到 var small = set.Where(s => s < -1).Max(); } if (set.Any(s => s < 6)) { //where后取max min还能取到的 var small = set.Where(s => s < 6).Max(); Assert.AreEqual(small, 4); } }
public void DataIntegrity_AllCharacterIdsAndDefaultCharactersHaveCharacterDetail() { CharacterDetailData.TabDelimitedCharacterDetailData = Resources.CharacterDetail; //resets cache var charactersHavingDetail = CharacterDetailData.Singleton.GetAll().Select(d => d.CharacterId).ToList(); ISet <string> missingCharacters = new SortedSet <string>(); ISet <string> missingDefaultCharacters = new SortedSet <string>(); foreach (CharacterVerse cv in ControlCharacterVerseData.Singleton.GetAllQuoteInfo()) { if (!charactersHavingDetail.Contains(cv.Character)) { if (CharacterVerseData.IsCharacterStandard(cv.Character) || cv.Character == CharacterVerseData.kNeedsReview) { continue; } // For interruptions, we actually never pay any attention to the character ID. They are always narrator. // But in some verses we have both a normal narrator Quotation and an interruption, so to avoid a problem // in other data integrity checks, we just use the dummy character id "interruption-XXX" (where XXX is the // 3-letter book code. if (cv.QuoteType == QuoteType.Interruption || cv.Character.StartsWith("interruption-")) { continue; } var characters = cv.Character.Split('/'); if (characters.Length > 1) { foreach (var character in characters.Where(character => !charactersHavingDetail.Contains(character))) { missingCharacters.Add(character); } } else { missingCharacters.Add(cv.Character); } } if (!(string.IsNullOrEmpty(cv.DefaultCharacter) || charactersHavingDetail.Contains(cv.DefaultCharacter))) { if (CharacterVerseData.IsCharacterStandard(cv.DefaultCharacter) || cv.DefaultCharacter == CharacterVerseData.kNeedsReview) { continue; } missingDefaultCharacters.Add(cv.DefaultCharacter); } } Assert.False(missingCharacters.Any() || missingDefaultCharacters.Any(), (missingCharacters.Any() ? "Characters in Character-Verse data but not in Character-Detail:" + Environment.NewLine + missingCharacters.OnePerLineWithIndent() : "") + (missingDefaultCharacters.Any() ? Environment.NewLine + "Default characters in Character-Verse data but not in Character-Detail:" + Environment.NewLine + missingDefaultCharacters.OnePerLineWithIndent() : "")); }
public void ComputePreconditions() { var NameToImpl = new Func <string, Implementation>(name => BoogieUtil.findProcedureImpl(program.TopLevelDeclarations, name)); var main = id2Graph[program.mainProcName]; main.UpdatePrecondition(main.precondition.Top(NameToImpl(main.Id))); IntraGraph.TopDown = true; var worklist = new SortedSet <IntraGraph>(main); worklist.Add(main); var SetPrecondition = new Action <string, IWeight>((name, weight) => { var g = id2Graph[name]; var changed = g.UpdatePrecondition(weight); if (changed) { worklist.Add(g); } }); while (worklist.Any()) { var proc = worklist.First(); worklist.Remove(proc); proc.PropagatePrecondition(NameToImpl, SetPrecondition); } IntraGraph.TopDown = false; }
private static bool promoRights() { bool ret = false; // assume failure try { foreach (AcUser user in _users.OrderBy(n => n)) { SortedSet <string> groups = user.Principal.Members; // the list of groups this user is a member of IEnumerable <string> query = from ef in _locks.Select(lk => lk.ExceptFor) // locks applied to all except this group where groups.Any(g => g == ef) // any group in groups list that matches an ExceptFor group select ef; string found = query.FirstOrDefault(); // not null indicates the user has promote privileges somewhere Console.WriteLine($"{user}\t{((found == null) ? "None" : "ExceptFor")}"); } ret = true; } catch (Exception ecx) { AcDebug.Log($"Exception caught and logged in Program.promoRights{Environment.NewLine}{ecx.Message}"); } return(ret); }
public IList <int[]> KSmallestPairs(int[] nums1, int[] nums2, int k) { var ans = new List <int[]>(); if (nums1.Length == 0 || nums2.Length == 0 || k == 0) { return(ans); } var heap = new SortedSet <int[]>(Comparer <int[]> .Create((a, b) => { var result = a[0] + a[1] - b[0] - b[1]; if (result == 0) { return(a[3] - b[3]); } return(result); })); for (int i = 0; i < nums1.Length && i < k; i++) { heap.Add(new int[] { nums1[i], nums2[0], 0, i }); } while (k-- > 0 && heap.Any()) { int[] cur = heap.Min; ans.Add(new int[] { cur[0], cur[1] }); heap.Remove(cur); if (cur[2] == nums2.Length - 1) { continue; } heap.Add(new int[] { cur[0], nums2[cur[2] + 1], cur[2] + 1, cur[3] }); } return(ans); }
private static void Main() { var start = new Position(Console.ReadLine() .Split(' ') .Select(int.Parse) .ToArray()); var size = new Position(Console.ReadLine() .Split(' ') .Select(int.Parse) .ToArray()); matrix = new int[size.Row, size.Col]; Position.RowsLenght = size.Row; Position.ColsLenght = size.Col; visited.Add(start); FillMattrix(); GetTotalTeleportationPower(start, 0); if (powers.Any()) { Console.WriteLine(powers.Max()); } else { Console.WriteLine(0); } }
public static void Main() { var reservationsList = new SortedSet <string>(); var input = Console.ReadLine(); while (input != "PARTY") { reservationsList.Add(input); input = Console.ReadLine(); } while (input != "END") { reservationsList.Remove(input); input = Console.ReadLine(); } if (reservationsList.Any()) { Console.WriteLine(reservationsList.Count); foreach (var guestNumber in reservationsList) { Console.WriteLine(guestNumber); } } else { Console.WriteLine(reservationsList.Count); } }
public static void Main() { var input = Console.ReadLine(); var parking = new SortedSet <string>(); while (input != "END") { var inputParams = Regex.Split(input, ", "); if (inputParams[0] == "IN") { parking.Add(inputParams[1]); } else if (inputParams[0] == "OUT") { parking.Remove(inputParams[1]); } input = Console.ReadLine(); } if (parking.Any()) { foreach (var car in parking) { Console.WriteLine(car); } } else { Console.WriteLine("Parking Lot is Empty"); } }
static void Minimization() { _minimizedFinalStates = new SortedSet <string>(); _minimizedNonFinalStates = new SortedSet <string>(); foreach (string state in _reachableStates) { if (_finalStates.Contains(state)) { _minimizedFinalStates.Add(state); } else { _minimizedNonFinalStates.Add(state); } } if (_minimizedNonFinalStates.Any()) { _statePartitions.Add(_minimizedNonFinalStates); } if (_minimizedFinalStates.Any()) { _statePartitions.Add(_minimizedFinalStates); } PartitionRefinement(ref _statePartitions); UpdateData(); }
public static int LastStoneWeight(int[] stones) { var len = stones.Length; var set = new SortedSet <Tuple <int, int> >(new WeightComparer()); for (var i = 0; i < stones.Length; i++) { set.Add(new Tuple <int, int>(stones[i], i)); } while (set.Count > 1) { var y = set.First(); set.Remove(y); var x = set.First(); set.Remove(x); if (x.Item1 != y.Item1) { len++; set.Add(new Tuple <int, int>(y.Item1 - x.Item1, len)); } } return(set.Any() ? set.First().Item1 : 0); }
private Or(SortedSet <Regex <T> > regexes) : base( regexes.Any(r => r.AcceptsEmptyString), regexes.Aggregate(RegexType.Or.GetHashCode(), (hash, rex) => hash * 7 + rex.GetHashCode())) { _regexes = regexes; }
private void SetMedianDay() { if (visibleDays.Any()) { MedianDay = visibleDays.First() + (visibleDays.Last() - visibleDays.First()).Divide(2); } }
public LookupResult LookupWord(string word) { if (word.Length <= 2) { return(LookupResult.PartialMatch); } string prefix = word.Substring(0, 2); if (!_words.ContainsKey(prefix)) { return(LookupResult.NoMatch); } SortedSet <String> bucket = _words[prefix]; if (!bucket.Any(a => a.StartsWith(word))) { return(LookupResult.NoMatch); } if (bucket.Contains(word)) { return(LookupResult.Match); } return(LookupResult.PartialMatch); }
private string AssertAllBaseTextCharacters(HuffmanNode root) { bool[] characters = new bool[char.MaxValue]; foreach (char character in baseText) { characters[character] = true; } var huffmanTreeCharacters = new SortedSet <char>(); var baseTextCharacters = new SortedSet <char>(characters .Select((wasEncountered, index) => new { WasEncountered = wasEncountered, Character = (char)index }) .Where(x => x.WasEncountered) .Select(x => x.Character)); NodeVisitor(root, node => { if (node.Character > 0) { huffmanTreeCharacters.Add(node.Character); } return(null); }); baseTextCharacters.ExceptWith(huffmanTreeCharacters); return(baseTextCharacters.Any() ? $"Huffman tree does not contain '{baseTextCharacters.First()}' that was in base text" : null); }
public void PropagatePrecondition(Func <string, Implementation> NameToImpl, Action <string, IWeight> SetPrecondition) { foreach (var node in Nodes) { node.weight = iw.Zero(impl); } entryNode.weight = precondition; var worklist = new SortedSet <Node>(entryNode); worklist.Add(entryNode); while (worklist.Any()) { var node = worklist.First(); worklist.Remove(node); foreach (var edge in node.Successors) { var c = edge.PropagatePrecondition(ProcSummary, NameToImpl, SetPrecondition); if (c) { worklist.Add(edge.tgt); } } } }
/// <summary> /// Finds the related table names of the current query. /// </summary> public SortedSet <string> GetCacheDependencies(EFCachePolicy cachePolicy, SortedSet <string> tableNames, string commandText) { if (cachePolicy == null) { throw new ArgumentNullException(nameof(cachePolicy)); } var textsInsideSquareBrackets = _sqlCommandsProcessor.GetSqlCommandTableNames(commandText); var cacheDependencies = new SortedSet <string>( tableNames.Intersect(textsInsideSquareBrackets, StringComparer.OrdinalIgnoreCase), StringComparer.OrdinalIgnoreCase); if (cacheDependencies.Any()) { logProcess(tableNames, textsInsideSquareBrackets, cacheDependencies); return(cacheDependencies); } cacheDependencies = cachePolicy.CacheItemsDependencies as SortedSet <string>; if (cacheDependencies?.Any() != true) { _logger.LogDebug($"It's not possible to calculate the related table names of the current query[{commandText}]. Please use EFCachePolicy.Configure(options => options.CacheDependencies(\"real_table_name_1\", \"real_table_name_2\")) to specify them explicitly."); cacheDependencies = new SortedSet <string>(StringComparer.OrdinalIgnoreCase) { EFCachePolicy.EFUnknownsCacheDependency }; } logProcess(tableNames, textsInsideSquareBrackets, cacheDependencies); return(cacheDependencies); }
public Dictionary <string, SortedSet <string> > CalculateDependencies() { // for each node list nodes it depends on (i.e. reverse traverse) var processors = Nodes.ToDictionary(n => n.ID, n => RFGraphDefinition.GetFullName(n.GraphName, n.Label)); var dependencies = new Dictionary <string, SortedSet <string> >(); foreach (var node in Nodes) { var visited = new SortedSet <int>(); var toVisit = new SortedSet <int>(Edges.Where(e => e.DestinationNode == node.ID).Select(e => e.SourceNode)); while (toVisit.Any()) { var next = toVisit.First(); toVisit.Remove(next); if (!visited.Contains(next)) { visited.Add(next); foreach (var source in Edges.Where(e => e.DestinationNode == next).Select(e => e.SourceNode)) { if (!visited.Contains(source)) { toVisit.Add(source); } } } } dependencies.Add(processors[node.ID], new SortedSet <string>(visited.Where(v => processors.ContainsKey(v)).Select(v => processors[v]))); } return(dependencies); }
static void Main() { var findedAreas = new SortedSet<Area>(); for (int row = 0; row < matrix.GetLength(0); row++) { for (int col = 0; col < matrix.GetLength(1); col++) { if (matrix[row, col] == ' ') { GetConnectedAreaSize(row, col); var area = new Area(row, col, areaSize); findedAreas.Add(area); areaSize = 0; } } } if (findedAreas.Any()) { Console.WriteLine("Total areas found: {0}", findedAreas.Count); int number = 0; foreach (var area in findedAreas) { ++number; Console.WriteLine("Area #{0} at {1}", number, area.ToString()); } } }
static void Main(string[] args) { SortedSet <string> uniqueElements = new SortedSet <string>(); int numberOfLines = int.Parse(Console.ReadLine()); for (int i = 0; i < numberOfLines; i++) { string[] elements = Console.ReadLine() .Split(" ", StringSplitOptions.RemoveEmptyEntries) .ToArray(); foreach (string element in elements) { uniqueElements.Add(element); } } bool areAny = uniqueElements.Any(); if (areAny) { Console.WriteLine(string.Join(" ", uniqueElements)); } }
static void Main(string[] args) { SortedSet <string> invited = new SortedSet <string>(); string input = Console.ReadLine(); while (input != "PARTY") { invited.Add(input); input = Console.ReadLine(); } input = Console.ReadLine(); while (input != "END") { if (invited.Any(i => i == input)) { invited.Remove(input); } input = Console.ReadLine(); } Console.WriteLine(invited.Count); foreach (var person in invited) { Console.WriteLine(person); } Console.ReadLine(); }
protected override List <TestResult> GetTestResults() { var testResults = new List <TestResult>(); testResults.Add(new TestResult(ResultType.Success, new Location(""), string.Format(Noark5Messages.DatesFirstAndLastRegistrationMessage_NumberOfRegistrations, _registrationCount))); if (_registrationCreationDates.Any()) { testResults.Add(new TestResult(ResultType.Success, new Location(""), string.Format(Noark5Messages.DatesFirstAndLastRegistrationMessage_CreationDateFirstRegistration, _registrationCreationDates.First().ToShortDateString()))); testResults.Add(new TestResult(ResultType.Success, new Location(""), string.Format(Noark5Messages.DatesFirstAndLastRegistrationMessage_CreationDateLastRegistration, _registrationCreationDates.Last().ToShortDateString()))); } else { testResults.Add(new TestResult(ResultType.Error, new Location(""), Noark5Messages.DatesFirstAndLastRegistrationMessage_NoValidRegistrationCreationDates)); } if (_invalidRegistrationCreationDateCount > 0) { testResults.Add(new TestResult(ResultType.Error, new Location(""), string.Format(Noark5Messages.DatesFirstAndLastRegistrationMessage_NumberOfInvalidRegistrationCreationDates, _invalidRegistrationCreationDateCount))); } return(testResults); }
/// <summary> /// my solution /// </summary> /// <param name="lists"></param> /// <returns></returns> public static ListNode MergeKLists(ListNode[] lists) { var dummy = new ListNode(0); //dummy head; var tail = dummy; var heap = new SortedSet <int>(); // SortedSet +Dictionary 来模拟 PQ var dict = new Dictionary <int, List <ListNode> >(); foreach (var node in lists) // 将节点装入 PQ { if (node == null) { continue; } AddToPQ(heap, node, dict); } while (heap.Any()) { var node = RemoveMin(heap, dict); //取出,并删除最小的 tail.next = node; tail = tail.next; // my bug 需要移动 if (node.next != null) { AddToPQ(heap, node.next, dict); // 如果最小的 的 next不空,则装入PQ } } return(dummy.next); }
/// <summary> /// Writes the paths to the output files to a text file. /// </summary> /// <param name="path">Path to write file.</param> /// <param name="fileTransfers">Collection of files that were transferred to the output directory.</param> private void CreateOutputsFile(string path, IEnumerable <ITrackedFile> trackedFiles) { var uniqueOutputPaths = new SortedSet <string>(trackedFiles.Where(t => t.Clean).Select(t => t.Path), StringComparer.OrdinalIgnoreCase); if (!uniqueOutputPaths.Any()) { return; } var directory = Path.GetDirectoryName(path); Directory.CreateDirectory(directory); using (var outputs = new StreamWriter(path, false)) { //// Don't list files where the source is the same as the destination since //// that might be the only place the file exists. The outputs file is often //// used to delete stuff and losing the original source would be bad. //var uniqueOutputPaths = new SortedSet<string>(fileTransfers.Where(ft => !ft.Redundant).Select(ft => ft.Destination), StringComparer.OrdinalIgnoreCase); foreach (var outputPath in uniqueOutputPaths) { outputs.WriteLine(outputPath); } } }
public ListNode MergeKLists(ListNode[] lists) { var heap = new SortedSet <Tuple <ListNode, int> >(new Comparer()); for (var i = 0; i < lists.Length; ++i) { if (lists[i] != null) { heap.Add(Tuple.Create(lists[i], i)); } } ListNode head = null; ListNode current = null; while (heap.Any()) { var min = heap.Min; heap.Remove(min); if (min.Item1.next != null) { heap.Add(Tuple.Create(min.Item1.next, min.Item2)); } if (head == null) { head = min.Item1; current = head; } else { current.next = min.Item1; current = current.next; } } return(head); }
private static int[] ClimbingLeaderboard(int[] scores, int[] alice) { int[] ret = new int[alice.Length]; var sortedSet = new SortedSet <int>(scores); int last = alice[0]; bool inserted = false; for (int i = 0; i < alice.Length; i++) { if (inserted) { sortedSet.Remove(last); inserted = false; } if (!sortedSet.Any(x => x == last)) { sortedSet.Add(alice[i]); last = alice[i]; inserted = true; } ret[i] = sortedSet.Count(x => x > alice[i]) + 1; } return(ret); }
public virtual bool IsBalanced() { if (!_dataStore.Any()) { return(true); } var assetAccounts = new List <IAccount <Identifier> >(); var liabilityAccounts = new List <IAccount <Identifier> >(); var equityAccounts = new List <IAccount <Identifier> >(); foreach (var acct in _dataStore) { switch (acct.AccountType) { case KindsOfAccounts.Asset: assetAccounts.Add(acct); continue; case KindsOfAccounts.Liability: liabilityAccounts.Add(acct); continue; case KindsOfAccounts.Equity: equityAccounts.Add(acct); continue; } } return(assetAccounts.Sum().GetRounded().GetAbs() == (liabilityAccounts.Sum() + equityAccounts.Sum()).GetRounded().GetAbs()); }
public bool SubSearch(SortedSet <int> nums, int k, int currentSum, int targetSum) { if (k == 0) { return(!nums.Any()); } if (currentSum > targetSum) { return(false); } if (currentSum == targetSum) { return(SubSearch(nums, k - 1, 0, targetSum)); } tempList.Clear(); tempList.AddRange(nums); foreach (var elem in tempList) { nums.Remove(elem); if (SubSearch(nums, k, currentSum + elem, targetSum)) { return(true); } nums.Add(elem); } return(false); }
static EventQueue() { var worker = new Thread(() => { for (; ;) { EventQueueEvent minEvent; lock (events) minEvent = events.Any() ? events.Min : null; if (minEvent != null && minEvent.CallTime <= DateTime.Now) { lock (events) if (!events.Remove(minEvent)) { logger.Fatal("EventQueue failed removing element"); } eventById.TryRemove(minEvent.Guid, out var _); minEvent.Action.BeginInvoke(minEvent.State, ActionInvokeCallback, new InvokeStateObject { TimerCallback = minEvent.Action }); } Thread.Sleep(1); } // ReSharper disable once FunctionNeverReturns }); worker.Start(); }
// topologically sort the graph to work out calculation order public Dictionary <string, int> CalculateWeights() { var remainingNodes = new SortedSet <int>(Nodes.Select(n => n.ID).Union(KeyNodes.Select(k => k.Value.ID))); var markedNodes = new SortedSet <int>(); var processors = Nodes.ToDictionary(n => n.ID, n => RFGraphDefinition.GetFullName(n.GraphName, n.Label)); var visitOrder = new List <int>(); while (remainingNodes.Any()) { var remainingNode = remainingNodes.First(); Visit(remainingNode, markedNodes, remainingNodes, visitOrder); } var weights = new Dictionary <string, int>(); int idx = 1; visitOrder.Reverse(); foreach (var node in visitOrder) { if (processors.ContainsKey(node)) { weights.Add(processors[node], idx++); } } return(weights); }
private IEnumerable <DateTime> OccurenceGeneratorMethod() { DateTime init = DateTime.Now; int year = init.Year; DateTime output = init; while (true) { foreach (int month in Months) { // Initial test if (year == init.Year && month < init.Month) { continue; } int maxDays = DateTime.DaysInMonth(year, month); foreach (int day in Days) { if (year == init.Year && month == init.Month && day < init.Day) { continue; } if (day > maxDays) { continue; } output = new DateTime(year, month, day); if (DaysOfWeek.Any(dow => dow - 1 == (int)output.DayOfWeek)) { foreach (int hour in Hours) { if (year == init.Year && month == init.Month && day == init.Day && hour < init.Hour) { continue; } foreach (int minute in Minutes) { if (year == init.Year && month == init.Month && day == init.Day && hour == init.Hour && minute < init.Minute) { continue; } yield return(new DateTime(year, month, day, hour, minute, 0));; } } } } } year += 1; if (year > init.Year + 10) { yield break; } } }
private static List<Step> CalculatePath(IMovable movable, Zone destination) { List<Step> steps = new List<Step>(); if (movable.Location == destination || !movable.CanCross(destination)) return steps; //Calculate path using A* algorithm SortedSet<PathfindingNode> openList = new SortedSet<PathfindingNode>( Comparer<PathfindingNode>.Create((a, b) => a.CompareTo(b))); HashSet<Zone> closedList = new HashSet<Zone>(); openList.Add(new PathfindingNode(movable.Location, destination.DistanceWith(movable.Location))); bool pathFound = destination == movable.Location; while (!pathFound) { if (openList.Count == 0) break; PathfindingNode currentNode = openList.First(); foreach (Zone neighbourg in currentNode.Zone.Adjacencies.Select(a => a.Neighbourg).Where(s => movable.CanCross(s))) { if (closedList.Contains(neighbourg) || openList.Any(n => n.Zone == neighbourg)) continue; openList.Add(new PathfindingNode(neighbourg, destination.DistanceWith(neighbourg), currentNode)); if (neighbourg == destination) // Path found ! { pathFound = true; steps.Add(new Step(currentNode.Zone, destination)); while (currentNode.Parent != null) { steps.Add(new Step(currentNode.Parent.Zone, currentNode.Zone)); currentNode = currentNode.Parent; } steps.Reverse(); break; } } openList.Remove(currentNode); closedList.Add(currentNode.Zone); } if (steps.Count == 0) return steps; return steps; }
private ICEOutcome LearnInvFromTemplate(Dictionary<string, int> impl2Priority, Template t, int range, out VCGenOutcome overallOutcome) { overallOutcome = null; // create a new z3 context if (z3Context != null) { z3Context.context.Dispose(); z3Context.config.Dispose(); } z3Context = new Z3Context(); foreach (var func in existentialFunctions.Values) { // initialize function to an "Octagons" instance with the given template "t". function2Value[func.Name] = ICEDomainFactory.GetInstance("Octagons", t, ref z3Context, func.Name, range); } // add counterexamples into the z3Context. These are obtained from the earlier iterations of the template. foreach (var cex in counterExamples) { AddCounterExampleToZ3Context(cex); } var worklist = new SortedSet<Tuple<int, string>>(); name2Impl.Keys.Iter(k => worklist.Add(Tuple.Create(impl2Priority[k], k))); while (worklist.Any()) { var impl = worklist.First().Item2; worklist.Remove(worklist.First()); #region vcgen var gen = prover.VCExprGen; var terms = new List<Expr>(); foreach (var tup in impl2FuncCalls[impl]) { var controlVar = tup.Item2; var exprVars = tup.Item3; var varList = new List<Expr>(); exprVars.Args.OfType<Expr>().Iter(v => varList.Add(v)); var args = new List<Expr>(); controlVar.InParams.Iter(v => args.Add(Expr.Ident(v))); Expr term = Expr.Eq(new NAryExpr(Token.NoToken, new FunctionCall(controlVar), args), function2Value[tup.Item1].Gamma(varList)); if (controlVar.InParams.Count != 0) { term = new ForallExpr(Token.NoToken, new List<Variable>(controlVar.InParams.ToArray()), new Trigger(Token.NoToken, true, new List<Expr> { new NAryExpr(Token.NoToken, new FunctionCall(controlVar), args) }), term); } terms.Add(term); } var env = BinaryTreeAnd(terms, 0, terms.Count - 1); env.Typecheck(new TypecheckingContext((IErrorSink)null)); var envVC = prover.Context.BoogieExprTranslator.Translate(env); var vc = gen.Implies(envVC, impl2VC[impl]); if (CommandLineOptions.Clo.Trace) { Console.WriteLine("Verifying {0}: ", impl); //Console.WriteLine("env: {0}", envVC); var envFuncs = new HashSet<string>(); impl2FuncCalls[impl].Iter(tup => envFuncs.Add(tup.Item1)); envFuncs.Iter(f => PrintFunction(existentialFunctions[f])); } #endregion vcgen VCExpr finalVC; #region bound_value_of_cexs #if false finalVC = vc; #else int bound = 1000000; terms.Clear(); foreach (var tup in impl2FuncCalls[impl]) { var exprVars = tup.Item3; var varList = new List<Expr>(); exprVars.Args.OfType<Expr>().Where(v => v.Type.IsInt).Iter(v => varList.Add(v)); foreach (var variable in varList) { terms.Add(Expr.Le(variable, Expr.Literal(bound))); terms.Add(Expr.Ge(variable, Expr.Literal(-1 * bound))); //terms.Add(Expr.Ge(variable, Expr.Literal(0))); } } var boundcex = BinaryTreeAnd(terms, 0, terms.Count - 1); boundcex.Typecheck(new TypecheckingContext((IErrorSink)null)); var boundcexVC = prover.Context.BoogieExprTranslator.Translate(boundcex); finalVC = gen.Implies(boundcexVC, vc); #endif #endregion bound_value_of_cexs var handler = impl2ErrorHandler[impl].Item1; var collector = impl2ErrorHandler[impl].Item2; collector.Reset(impl); VCisValid = true; // set to false if control reaches HandleCounterExample realErrorEncountered = false; newSamplesAdded = false; var start = DateTime.Now; prover.Push(); prover.Assert(gen.Not(finalVC), true); prover.FlushAxiomsToTheoremProver(); prover.Check(); ProverInterface.Outcome proverOutcome = prover.CheckOutcomeCore(handler); //prover.BeginCheck(impl, vc, handler); //ProverInterface.Outcome proverOutcome = prover.CheckOutcomeCore(handler); var inc = (DateTime.Now - start); proverTime += inc; numProverQueries++; if (CommandLineOptions.Clo.Trace) Console.WriteLine("Prover Time taken = " + inc.TotalSeconds.ToString()); if (proverOutcome == ProverInterface.Outcome.TimeOut || proverOutcome == ProverInterface.Outcome.OutOfMemory) { Console.WriteLine("Z3 Prover for implementation {0} times out or runs out of memory !", impl); z3Context.context.Dispose(); z3Context.config.Dispose(); overallOutcome = new VCGenOutcome(proverOutcome, new List<Counterexample>()); return ICEOutcome.Timeout; } if (CommandLineOptions.Clo.Trace) Console.WriteLine(!VCisValid ? "SAT" : "UNSAT"); if (!VCisValid) { if (realErrorEncountered) { overallOutcome = new VCGenOutcome(ProverInterface.Outcome.Invalid, collector.real_errors); return ICEOutcome.ErrorFound; } Debug.Assert(newSamplesAdded); HashSet<string> funcsChanged; if (!learn(out funcsChanged)) { // learner timed out or there is no valid conjecture in the current given template overallOutcome = new VCGenOutcome(ProverInterface.Outcome.Invalid, collector.conjecture_errors); prover.Pop(); return ICEOutcome.InvariantNotFound; } // propagate dependent guys back into the worklist, including self var deps = new HashSet<string>(); deps.Add(impl); funcsChanged.Iter(f => deps.UnionWith(function2implAssumed[f])); funcsChanged.Iter(f => deps.UnionWith(function2implAsserted[f])); deps.Iter(s => worklist.Add(Tuple.Create(impl2Priority[s], s))); } prover.Pop(); } // The program was verified with the current template! overallOutcome = new VCGenOutcome(ProverInterface.Outcome.Valid, new List<Counterexample>()); return ICEOutcome.InvariantFound; }
/// <summary> /// Sprawdza czy potrafimy wyświetlić dany tym MIME /// </summary> /// <returns></returns> private bool CheckMimeToDisplay() { if (!headers.ContainsKey("Content-Type")) return true; var mime = headers["Content-Type"]; var allowedMimes = new SortedSet<string> { "text/html", "text/plain" }; return allowedMimes.Any(allowedMime => mime.StartsWith(allowedMime)); }
private VCGenOutcome LearnInv(Dictionary<string, int> impl2Priority) { var worklist = new SortedSet<Tuple<int, string>>(); name2Impl.Keys.Iter(k => worklist.Add(Tuple.Create(impl2Priority[k], k))); while (worklist.Any()) { var impl = worklist.First().Item2; worklist.Remove(worklist.First()); #region vcgen var gen = prover.VCExprGen; var terms = new List<Expr>(); foreach (var tup in impl2FuncCalls[impl]) { var controlVar = tup.Item2; var exprVars = tup.Item3; var varList = new List<Expr>(); exprVars.Args.OfType<Expr>().Iter(v => varList.Add(v)); var args = new List<Expr>(); controlVar.InParams.Iter(v => args.Add(Expr.Ident(v))); Expr term = Expr.Eq(new NAryExpr(Token.NoToken, new FunctionCall(controlVar), args), function2Value[tup.Item1].Gamma(varList)); if (controlVar.InParams.Count != 0) { term = new ForallExpr(Token.NoToken, new List<Variable>(controlVar.InParams.ToArray()), new Trigger(Token.NoToken, true, new List<Expr> { new NAryExpr(Token.NoToken, new FunctionCall(controlVar), args) }), term); } terms.Add(term); /* foreach (var variable in varList) { terms.Add(Expr.Le(variable, Expr.Literal(10))); terms.Add(Expr.Ge(variable, Expr.Literal(-10))); } */ } var env = BinaryTreeAnd(terms, 0, terms.Count - 1); env.Typecheck(new TypecheckingContext((IErrorSink)null)); var envVC = prover.Context.BoogieExprTranslator.Translate(env); var vc = gen.Implies(envVC, impl2VC[impl]); if (CommandLineOptions.Clo.Trace) { Console.WriteLine("Verifying {0}: ", impl); //Console.WriteLine("env: {0}", envVC); var envFuncs = new HashSet<string>(); impl2FuncCalls[impl].Iter(tup => envFuncs.Add(tup.Item1)); envFuncs.Iter(f => PrintFunction(existentialFunctions[f])); } #endregion vcgen VCExpr finalVC; for (int i = 0; i <= bounds4cex.Count(); i++) { #region boundcexvalues /* Last iteration is when there are enforced no bounds on the cex values. */ if (i < bounds4cex.Count()) { int bound = bounds4cex.ElementAt(i); terms.Clear(); foreach (var tup in impl2FuncCalls[impl]) { var exprVars = tup.Item3; var varList = new List<Expr>(); exprVars.Args.OfType<Expr>().Where(v => v.Type.IsInt).Iter(v => varList.Add(v)); foreach (var variable in varList) { terms.Add(Expr.Le(variable, Expr.Literal(bound))); terms.Add(Expr.Ge(variable, Expr.Literal(-1 * bound))); //terms.Add(Expr.Ge(variable, Expr.Literal(0))); } } var boundcex = BinaryTreeAnd(terms, 0, terms.Count - 1); boundcex.Typecheck(new TypecheckingContext((IErrorSink)null)); var boundcexVC = prover.Context.BoogieExprTranslator.Translate(boundcex); finalVC = gen.Implies(boundcexVC, vc); } else { //finalVC = vc; int bound = 1000000; terms.Clear(); foreach (var tup in impl2FuncCalls[impl]) { var exprVars = tup.Item3; var varList = new List<Expr>(); exprVars.Args.OfType<Expr>().Where(v => v.Type.IsInt).Iter(v => varList.Add(v)); foreach (var variable in varList) { terms.Add(Expr.Le(variable, Expr.Literal(bound))); terms.Add(Expr.Ge(variable, Expr.Literal(-1 * bound))); //terms.Add(Expr.Ge(variable, Expr.Literal(0))); } } var boundcex = BinaryTreeAnd(terms, 0, terms.Count - 1); boundcex.Typecheck(new TypecheckingContext((IErrorSink)null)); var boundcexVC = prover.Context.BoogieExprTranslator.Translate(boundcex); finalVC = gen.Implies(boundcexVC, vc); } #endregion boundcexvalues var handler = impl2ErrorHandler[impl].Item1; var collector = impl2ErrorHandler[impl].Item2; collector.Reset(impl); implicationCounterExamples.Clear(); VCisValid = true; // set to false if control reaches HandleCounterExample //realErrorEncountered = false; //newSamplesAdded = false; //this.posNegCexAdded = false; var start = DateTime.Now; prover.Push(); prover.Assert(gen.Not(finalVC), true); prover.FlushAxiomsToTheoremProver(); prover.Check(); ProverInterface.Outcome proverOutcome = prover.CheckOutcomeCore(handler); var inc = (DateTime.Now - start); proverTime += inc; numProverQueries++; if (CommandLineOptions.Clo.Trace) Console.WriteLine("Prover Time taken = " + inc.TotalSeconds.ToString()); if (proverOutcome == ProverInterface.Outcome.TimeOut || proverOutcome == ProverInterface.Outcome.OutOfMemory) { Console.WriteLine("Z3 Prover for implementation {0} times out or runs out of memory !", impl); return new VCGenOutcome(proverOutcome, new List<Counterexample>()); } if (!VCisValid) { /* There was a counterexample found and acted upon while proving the method. */ if (collector.real_errors.Count > 0) { return new VCGenOutcome(ProverInterface.Outcome.Invalid, collector.real_errors); } if (collector.conjecture_errors.Count == 0) { // No positive or negative counter-example added. Need to add implication counter-examples Debug.Assert(collector.implication_errors.Count > 0); foreach (var cex in implicationCounterExamples) { AddCounterExample(cex); } } //Debug.Assert(newSamplesAdded); HashSet<string> funcsChanged; if (!learn(out funcsChanged)) { // learner timed out, ran into some errors, or if there is no consistent conjecture prover.Pop(); if(collector.conjecture_errors.Count > 0) return new VCGenOutcome(ProverInterface.Outcome.Invalid, collector.conjecture_errors); else return new VCGenOutcome(ProverInterface.Outcome.Invalid, collector.implication_errors); } // propagate dependent guys back into the worklist, including self var deps = new HashSet<string>(); deps.Add(impl); funcsChanged.Iter(f => deps.UnionWith(function2implAssumed[f])); funcsChanged.Iter(f => deps.UnionWith(function2implAsserted[f])); deps.Iter(s => worklist.Add(Tuple.Create(impl2Priority[s], s))); // break out of the loop that iterates over various bounds. prover.Pop(); break; } else { prover.Pop(); } } } // The program was verified return new VCGenOutcome(ProverInterface.Outcome.Valid, new List<Counterexample>()); }
private CTerm WithAttr(CTerm type, IDiaSymbol sym) { SortedSet<TypeAttr> attrs = new SortedSet<TypeAttr>(); if (sym.constType == 1) { attrs.Add(TypeAttrs.Const); } if (sym.volatileType == 1) { attrs.Add(TypeAttrs.Volatile); } if (sym.unalignedType == 1) { attrs.Add(TypeAttrs.Unaligned); } return attrs.Any() ? new CAttrTerm(type, attrs) : type; }