private Expression AggregateAndReduce(Expression expr) { var aggregator = new Aggregator(); aggregator.Visit(expr); if (aggregator.Source is DomainExpression) { return ProjectionFromAggregation(aggregator); } else { var source = Visit(aggregator.Source); var projector = aggregator.Projector; if (projector != null) { return Expression.Call( typeof(Enumerable).GetMethod("Select", new []{ typeof(IEnumerable<>), typeof(Func<,>) }).MakeGenericMethod(source.Type, projector.Type), source, projector); } else { return source; } } }
public static IList<NArray> Evaluate(Func<NArray> function, IList<NArray> independentVariables, StringBuilder expressionsOut = null, Aggregator aggregator = Aggregator.ElementwiseAdd, IList<NArray> existingStorage = null, VectorExecutionOptions vectorOptions = null) { if (existingStorage != null && existingStorage.Count != independentVariables.Count + 1) throw new ArgumentException(string.Format("storage provided does not match requirement for 1 result and {0} derivatives", independentVariables.Count)); var timer = new ExecutionTimer(); timer.Start(); NArray[] outputs = new NArray[independentVariables.Count + 1]; var context = new DeferredExecutionContext(new VectorExecutionOptions(), independentVariables); NArray dependentVariable; try { // execute function as deferred operations and obtain reference to the dependentVariable dependentVariable = function(); } finally { context.Finish(); } timer.MarkFunctionComplete(); for (int i = 0; i < outputs.Length; ++i) { // if new storage is required, we create scalars in the first instance outputs[i] = (existingStorage == null) ? NArray.CreateScalar(0) : existingStorage[i]; } context._executor.Evaluate(context._options, outputs, dependentVariable, independentVariables, timer, expressionsOut, aggregator); //Console.WriteLine(timer.Report()); return outputs; }
public void produces_the_view_type() { var aggregator = new Aggregator<QuestParty>(); var projection = new AggregationProjection<QuestParty>(null, aggregator); projection.Produces.ShouldBe(typeof(QuestParty)); }
public void consumes_delegates_to_internal_aggregation() { var aggregator = new Aggregator<QuestParty>(); var projection = new AggregationProjection<QuestParty>(null, aggregator); projection.Consumes.ShouldHaveTheSameElementsAs(aggregator.EventTypes); }
public SystemtapRunner(Log log) : base() { parser = new SystemtapParser (); aggregator = new Aggregator (log, parser); modulename = String.Format("mortadelo{0}", UnixProcess.GetCurrentProcessId()); }
public void AddAllMultiplesOf3Or5ThatAreLessThan1000AddsUpTo233168() { var iterator = new Iterator(0, 1000, i => i % 3 == 0 || i % 5 == 0); var aggregator = new Aggregator(iterator); int result = aggregator.GetSum(); Assert.That(result, Is.EqualTo(233168)); // see Verification.xls for confirmation of this result. }
public void AddingAllMultiplesOf3Or5ThatAreLessThan10AddsUpTo23() { var iterator = new Iterator(0, 10, i => i % 3 == 0 || i % 5 == 0); var aggregator = new Aggregator(iterator); int result = aggregator.GetSum(); Assert.That(result, Is.EqualTo(23)); }
public HashTree(Aggregator aggregator) { this.Tree = new Dictionary<int, Node>(); this.Height = 0; this.LatestLeafNode = new Node(); this.LatestLeafNode.Index = 0; this.Aggregator = aggregator; }
public void AggregatorCanSumAllValuesReturnedFromIterator() { var iterator = MockRepository.GenerateStub<IIterator>(); iterator.Stub(it => it.GetValues()).Return(new[] { 3, 5, 6, 9 }); var aggregator = new Aggregator(iterator); int result = aggregator.GetSum(); Assert.That(result, Is.EqualTo(23)); }
public AggregateHandler() { _agg = new Aggregator(); _agg.ProgressChanged += () => { if (_agg.InProgress == 0) { NotificationHandler.Instance.AddNotification("Поиск сообщений завершен."); } }; }
public void MoqStubsTest() { // Arrange var depend = Mock.Of<IDepend>(); var another = Mock.Of<IAnother>(t => t.Calabanga("WAKAWAKA") == 100500); var aggr = new Aggregator(depend, another); // Act var result1 = aggr.Aggregate("WAKAWAKA"); var result2 = aggr.Aggregate("WAKAWAKA"); // Assert Assert.AreEqual(result1, result2); Assert.AreEqual(result1, 100500); }
public void VariablesWithInitializersTest() { // Arrange var service = Mock.Of<IService>(t => t.Details == new List<Detail>()); var aggregator = new Aggregator(Mock.Of<IDepend>(), Mock.Of<IAnother>()) { Service = service, Serial = 1 }; // Act var details = aggregator.Aggregate(); // Assert Assert.NotNull(details); }
public void Setup() { connection = Substitute.For<IReliableConnection>(); model = Substitute.For<IModelWithConnection>(); connection.CreateModel().Returns(model); publishModule = Substitute.For<IPublishModule>(); aggregator = new Aggregator(); sut = new QueueingPublishingProcess(Substitute.For<IIdGenerator>(), Substitute.For<ISequenceGenerator>(), Substitute.For<IExchangeResolver>(), Substitute.For<IMessageSerializer>(), Substitute.For<IMessageTypeResolver>(), publishModule, aggregator); sut.Start(); }
private Expression ProjectionFromAggregation(Aggregator aggregator) { var domain = aggregator.Source; var where = aggregator.AggregatedWhere; var order = aggregator.AggregatedOrderBy; var select = aggregator.AggregatedSelect; var projector = aggregator.Projector; var limit = aggregator.Limit; var useConsistency = aggregator.UseConsistency; return SimpleDbExpression.Project( SimpleDbExpression.Query( select, domain, where, order, limit, useConsistency), projector); }
public void Setup() { connection = Substitute.For<IReliableConnection>(); model = Substitute.For<IModelWithConnection>(); connection.CreateModel().Returns(model); queueFactory = Substitute.For<IQueueFactory>(); aggregator = new Aggregator(); sut = new DefaultConsumingProcess(Substitute.For<IIdGenerator>(), Substitute.For<IExchangeResolver>(), Substitute.For<IMessageSerializer>(), Substitute.For<IMessageTypeResolver>(), Substitute.For<IConsumerContainer>(), Substitute.For<IMessageFilter>(), queueFactory, Substitute.For<IConsumerInvoker>(), new RogerOptions(), aggregator); }
public void FirstAggTest() { CustomerFactory factory = new CustomerFactory(new ObjectContext(CreateDataStore())); Customer customer = factory.FindFirst("Name = {0}", "Joe Blow"); IList<WME> factlist = customer.GenerateFactsForRootObject(); Assert.IsTrue(factlist.Count == 11, "Wrong count."); Agenda agenda = new Agenda(); agenda.LoadRulesFromAssemblies = false; Variable customer_var = new Variable("Customer"); Variable orders = new Variable("Orders"); Variable order = new Variable("Order"); Variable val = new Variable("?Value"); Aggregator ag = new Aggregator("Count of customer orders."); ag.GroupBy = customer_var; ag.AggregatorFunction = new Count("$Customer.Orders.Order", "$Customer.Orders.Count"); ag.AddConditionToLHS(new AND(customer_var, "$Customer.Orders", orders)); ag.AddConditionToLHS(new AND(orders, "$Customer.Orders.Order", order)); agenda.AddAggregator(ag); Production mostSimple = new Production("If Big Spender"); mostSimple.AddConditionToLHS(new AND(customer_var, "$Customer.Orders.Count", val)); mostSimple.AddConditionToRHS(new INVOKE("shout", customer_var, "Shout", val)); agenda.AddProduction(mostSimple); agenda.AddFacts(factlist); agenda.Run(); agenda.VisualizeNetworkToFile(@"C:\Temp\FirstAggTest.log", false); Assert.IsTrue(agenda.TotalFacts == 11, "Bad"); Assert.IsTrue(agenda.ActionsTaken.Count == 1, "Bad"); Assert.IsTrue(agenda.ActionsSkipped.Count == 0, "Bad"); Assert.IsTrue(agenda.ActivatedRuleCount == 1, "Bad"); Assert.IsTrue(customer.Result != null && customer.Result.StartsWith("Shout"), "Did not invoke method."); }
public void SecondAggTest() { CustomerFactory factory = new CustomerFactory(new ObjectContext(CreateDataStore())); ObjectList<Customer> customers = factory.FindAllObjects(); Agenda agenda = new Agenda(); agenda.LoadRulesFromAssemblies = false; agenda.AddObjects(customers); Variable customer_var = new Variable("Customer"); Variable orders = new Variable("Orders"); Variable order = new Variable("Order"); Variable count = new Variable("OrderCount"); Aggregator ag = new Aggregator("Count of customer orders."); ag.GroupBy = customer_var; ag.AggregatorFunction = new Count("$Customer.Orders.Order", "Customer.Orders.Count"); ag.AddConditionToLHS(new AND(customer_var, "$Customer.Orders", orders)); ag.AddConditionToLHS(new AND(orders, "$Customer.Orders.Order", order)); agenda.AddAggregator(ag); Production mostSimple = new Production("If Big Spender"); mostSimple.AddConditionToLHS(new AND(customer_var, "Customer.Orders.Count", count)); mostSimple.AddConditionToRHS(new INVOKE("shout", customer_var, "Shout", count)); agenda.AddProduction(mostSimple); agenda.Run(); agenda.VisualizeNetworkToFile(@"C:\Temp\SecondAggTest.log", false); Assert.IsTrue(agenda.TotalFacts == 22, "Bad"); Assert.IsTrue(agenda.ActionsTaken.Count == 2, "Bad"); Assert.IsTrue(agenda.ActionsSkipped.Count == 0, "Bad"); Assert.IsTrue(agenda.ActivatedRuleCount == 1, "Bad"); foreach (Customer customer in customers) { Assert.IsTrue(customer.Result != null && customer.Result.StartsWith("Shout"), "Did not invoke method."); } }
public override Task OnNavigatingFromAsync(NavigatingEventArgs args) { Aggregator.Unsubscribe(this); return(Task.CompletedTask); }
/// <summary> /// Here we execute the expression, but without attempting to compile it. /// The performance gain comes only from reducing the amount of memory allocation required, not /// from compiling an optimised kernel. /// </summary> /// <param name="block"></param> /// <param name="provider"></param> /// <param name="vectorOptions"></param> public static void RunNonCompiling(BlockExpressionBuilder _builder, LinearAlgebraProvider provider, VectorExecutionOptions vectorOptions, NArray[] outputs, int[] outputsIndices, Aggregator aggregator, ExecutionTimer timer) { var block = _builder.ToBlock(); if (block.Operations.Count == 0) { return; } // we will cycle through arrays in order of increasing index var getter = new OutputGetter <double>(outputs, outputsIndices); int chunksLength = _builder.VectorLength; //5000; var arrayPoolStack = ExecutionContext.ArrayPool.GetStack(chunksLength); int length = (block.ArgumentParameters.First() as ReferencingVectorParameterExpression <double>) .Array.Length; int chunkCount = length / chunksLength; if (length % chunksLength != 0) { chunkCount++; } List <NArray <double> >[] localsToFree; // the storage that can be freed up after each operation is complete AssignNArrayStorage <double>(block, chunkCount, chunksLength, length, out localsToFree); // for integer support, add here var options = new ParallelOptions(); if (!vectorOptions.MultipleThreads) { options.MaxDegreeOfParallelism = 1; } timer.MarkExecutionTemporaryStorageAllocationComplete(); // can multi-thread here, but better to do so at higher level //Parallel.For(0, chunkCount, options, (i) => for (int i = 0; i < chunkCount; ++i) { int startIndex = i * chunksLength; int vectorLength = Math.Min(chunksLength, length - startIndex); for (int j = 0; j < block.Operations.Count; ++j) { var operation = block.Operations[j]; if (operation.Type == typeof(NArray)) { var newOperation = _builder.SimplifyOperation(operation); // deal with any expressions containing scalars that can be simplified ExecuteSingleVectorOperation <double>(newOperation, provider, arrayPoolStack, localsToFree[j], getter, aggregator, vectorLength, i, startIndex, timer); } } } ; if (!arrayPoolStack.StackCountEqualsCreated) { throw new Exception("not all storage arrays created returned to stack"); } }
void CreateFixture(Type fixtureGenericInterfaceType) { var fixtureType = fixtureGenericInterfaceType.GetGenericArguments().Single(); Aggregator.Run(() => collectionFixtureMappings[fixtureType] = Activator.CreateInstance(fixtureType)); }
/// <inheritdoc/> protected override Task BeforeTestCaseFinishedAsync() { Aggregator.Aggregate(cleanupAggregator); return(base.BeforeTestCaseFinishedAsync()); }
private protected override void GetAggregatorConsolidationFuncs(Aggregator aggregator, AggregatorDictionaryBase[] dictionaries, out Action <uint, ReadOnlyMemory <char>, Aggregator> addAgg, out Func <Dictionary <string, IDataView> > consolidate) { var stratCol = new List <uint>(); var stratVal = new List <ReadOnlyMemory <char> >(); var isWeighted = new List <bool>(); var nmi = new List <Double>(); var avgMinScores = new List <Double>(); var dbi = new List <Double>(); bool hasStrats = Utils.Size(dictionaries) > 0; bool hasWeight = aggregator.Weighted; addAgg = (stratColKey, stratColVal, agg) => { Host.Check(agg.Weighted == hasWeight, "All aggregators must either be weighted or unweighted"); Host.Check(agg.UnweightedCounters.CalculateDbi == aggregator.UnweightedCounters.CalculateDbi, "All aggregators must either compute DBI or not compute DBI"); stratCol.Add(stratColKey); stratVal.Add(stratColVal); isWeighted.Add(false); nmi.Add(agg.UnweightedCounters.Nmi); avgMinScores.Add(agg.UnweightedCounters.AvgMinScores); if (agg.UnweightedCounters.CalculateDbi) { dbi.Add(agg.UnweightedCounters.Dbi); } if (agg.Weighted) { stratCol.Add(stratColKey); stratVal.Add(stratColVal); isWeighted.Add(true); nmi.Add(agg.WeightedCounters.Nmi); avgMinScores.Add(agg.WeightedCounters.AvgMinScores); if (agg.WeightedCounters.CalculateDbi) { dbi.Add(agg.WeightedCounters.Dbi); } } }; consolidate = () => { var overallDvBldr = new ArrayDataViewBuilder(Host); if (hasStrats) { overallDvBldr.AddColumn(MetricKinds.ColumnNames.StratCol, GetKeyValueGetter(dictionaries), (ulong)dictionaries.Length, stratCol.ToArray()); overallDvBldr.AddColumn(MetricKinds.ColumnNames.StratVal, TextDataViewType.Instance, stratVal.ToArray()); } if (hasWeight) { overallDvBldr.AddColumn(MetricKinds.ColumnNames.IsWeighted, BooleanDataViewType.Instance, isWeighted.ToArray()); } overallDvBldr.AddColumn(Nmi, NumberDataViewType.Double, nmi.ToArray()); overallDvBldr.AddColumn(AvgMinScore, NumberDataViewType.Double, avgMinScores.ToArray()); if (aggregator.UnweightedCounters.CalculateDbi) { overallDvBldr.AddColumn(Dbi, NumberDataViewType.Double, dbi.ToArray()); } var result = new Dictionary <string, IDataView> { { MetricKinds.OverallMetrics, overallDvBldr.GetDataView() } }; return(result); }; }
private RunSummary FailEntireClass(IEnumerable <ObservationTestCase> testCases, ExecutionTimer timer) { foreach (var testCase in testCases) { MessageBus.QueueMessage(new TestFailed(new ObservationTest(testCase, testCase.DisplayName), timer.Total, "Exception was thrown in class constructor", Aggregator.ToException())); } int count = testCases.Count(); return(new RunSummary { Failed = count, Total = count }); }
public override void Subscribe() { Aggregator.Subscribe <UpdateGroupCall>(this, Handle) .Subscribe <UpdateGroupCallParticipant>(Handle); }
private protected override void GetAggregatorConsolidationFuncs(Aggregator aggregator, AggregatorDictionaryBase[] dictionaries, out Action <uint, ReadOnlyMemory <char>, Aggregator> addAgg, out Func <Dictionary <string, IDataView> > consolidate) { var stratCol = new List <uint>(); var stratVal = new List <ReadOnlyMemory <char> >(); var isWeighted = new List <bool>(); var l1 = new List <Double>(); var l2 = new List <Double>(); var dist = new List <Double>(); var perLabelL1 = new List <Double[]>(); var perLabelL2 = new List <Double[]>(); var perLabelRms = new List <Double[]>(); var perLabelLoss = new List <Double[]>(); bool hasStrats = Utils.Size(dictionaries) > 0; bool hasWeight = aggregator.Weighted; addAgg = (stratColKey, stratColVal, agg) => { Host.Check(agg.Weighted == hasWeight, "All aggregators must either be weighted or unweighted"); stratCol.Add(stratColKey); stratVal.Add(stratColVal); isWeighted.Add(false); l1.Add(agg.UnweightedCounters.L1); l2.Add(agg.UnweightedCounters.L2); dist.Add(agg.UnweightedCounters.Dist); perLabelL1.Add(agg.UnweightedCounters.PerLabelL1); perLabelL2.Add(agg.UnweightedCounters.PerLabelL2); perLabelRms.Add(agg.UnweightedCounters.PerLabelRms); perLabelLoss.Add(agg.UnweightedCounters.PerLabelLoss); if (agg.Weighted) { stratCol.Add(stratColKey); stratVal.Add(stratColVal); isWeighted.Add(true); l1.Add(agg.WeightedCounters.L1); l2.Add(agg.WeightedCounters.L2); dist.Add(agg.WeightedCounters.Dist); perLabelL1.Add(agg.WeightedCounters.PerLabelL1); perLabelL2.Add(agg.WeightedCounters.PerLabelL2); perLabelRms.Add(agg.WeightedCounters.PerLabelRms); perLabelLoss.Add(agg.WeightedCounters.PerLabelLoss); } }; consolidate = () => { var overallDvBldr = new ArrayDataViewBuilder(Host); if (hasStrats) { overallDvBldr.AddColumn(MetricKinds.ColumnNames.StratCol, GetKeyValueGetter(dictionaries), (ulong)dictionaries.Length, stratCol.ToArray()); overallDvBldr.AddColumn(MetricKinds.ColumnNames.StratVal, TextType.Instance, stratVal.ToArray()); } if (hasWeight) { overallDvBldr.AddColumn(MetricKinds.ColumnNames.IsWeighted, BoolType.Instance, isWeighted.ToArray()); } overallDvBldr.AddColumn(PerLabelL1, aggregator.GetSlotNames, NumberType.R8, perLabelL1.ToArray()); overallDvBldr.AddColumn(PerLabelL2, aggregator.GetSlotNames, NumberType.R8, perLabelL2.ToArray()); overallDvBldr.AddColumn(PerLabelRms, aggregator.GetSlotNames, NumberType.R8, perLabelRms.ToArray()); overallDvBldr.AddColumn(PerLabelLoss, aggregator.GetSlotNames, NumberType.R8, perLabelLoss.ToArray()); overallDvBldr.AddColumn(L1, NumberType.R8, l1.ToArray()); overallDvBldr.AddColumn(L2, NumberType.R8, l2.ToArray()); overallDvBldr.AddColumn(Dist, NumberType.R8, dist.ToArray()); var result = new Dictionary <string, IDataView>(); result.Add(MetricKinds.OverallMetrics, overallDvBldr.GetDataView()); return(result); }; }
protected override async void SendExecute() { var user = SelectedItems.FirstOrDefault(); if (user == null) { return; } Task <MTProtoResponse <TLUpdatesBase> > task = null; if (_item is TLChannel channel) { task = ProtoService.InviteToChannelAsync(channel.ToInputChannel(), new TLVector <TLInputUserBase> { user.ToInputUser() }); } else if (_item is TLChat chat) { var count = 100; var config = CacheService.GetConfig(); if (config != null) { count = config.ForwardedCountMax; } task = ProtoService.AddChatUserAsync(chat.Id, user.ToInputUser(), count); } if (task == null) { return; } var response = await task; if (response.IsSucceeded) { NavigationService.GoBack(); if (response.Result is TLUpdates updates) { var newMessage = updates.Updates.FirstOrDefault(x => x is TLUpdateNewMessage) as TLUpdateNewMessage; if (newMessage != null) { Aggregator.Publish(newMessage.Message); } var newChannelMessage = updates.Updates.FirstOrDefault(x => x is TLUpdateNewChannelMessage) as TLUpdateNewChannelMessage; if (newChannelMessage != null) { Aggregator.Publish(newChannelMessage.Message); } } } else { if (response.Error.TypeEquals(TLErrorType.PEER_FLOOD)) { var dialog = new TLMessageDialog(); dialog.Title = "Telegram"; dialog.Message = AppResources.PeerFloodAddContact; dialog.PrimaryButtonText = "More info"; dialog.SecondaryButtonText = "OK"; var confirm = await dialog.ShowQueuedAsync(); if (confirm == ContentDialogResult.Primary) { MessageHelper.HandleTelegramUrl("t.me/SpamBot"); } } else if (response.Error.TypeEquals(TLErrorType.USERS_TOO_MUCH)) { await TLMessageDialog.ShowAsync(AppResources.UsersTooMuch, "Telegram", "OK"); } else if (response.Error.TypeEquals(TLErrorType.BOTS_TOO_MUCH)) { await TLMessageDialog.ShowAsync(AppResources.BotsTooMuch, "Telegram", "OK"); } else if (response.Error.TypeEquals(TLErrorType.USER_NOT_MUTUAL_CONTACT)) { await TLMessageDialog.ShowAsync(AppResources.UserNotMutualContact, "Telegram", "OK"); } Execute.ShowDebugMessage("channels.inviteToChannel error " + response.Error); } }
public async Task LoadContactsAsync() { //var contacts = CacheService.GetContacts(); //foreach (var item in contacts.OfType<TLUser>()) //{ // var user = item as TLUser; // if (user.IsSelf) // { // continue; // } // //var status = LastSeenHelper.GetLastSeen(user); // //var listItem = new UsersPanelListItem(user as TLUser); // //listItem.fullName = user.FullName; // //listItem.lastSeen = status.Item1; // //listItem.lastSeenEpoch = status.Item2; // //listItem.Photo = listItem._parent.Photo; // //listItem.PlaceHolderColor = BindConvert.Current.Bubble(listItem._parent.Id); // Items.Add(user); //} var contacts = new TLUser[0]; var input = string.Join(",", contacts.Select(x => x.Id).Union(new[] { SettingsHelper.UserId }).OrderBy(x => x)); var hash = Utils.ComputeMD5(input); var hex = BitConverter.ToString(hash).Replace("-", string.Empty).ToLower(); var response = await ProtoService.GetContactsAsync(hex); if (response.IsSucceeded) { var result = response.Result as TLContactsContacts; if (result != null) { Execute.BeginOnUIThread(() => { foreach (var item in result.Users.OfType <TLUser>()) { var user = item as TLUser; if (user.IsSelf) { continue; } //var status = LastSeenHelper.GetLastSeen(user); //var listItem = new UsersPanelListItem(user as TLUser); //listItem.fullName = user.FullName; //listItem.lastSeen = status.Item1; //listItem.lastSeenEpoch = status.Item2; //listItem.Photo = listItem._parent.Photo; //listItem.PlaceHolderColor = BindConvert.Current.Bubble(listItem._parent.Id); Items.Add(user); } }); if (ApplicationSettings.Current.IsContactsSyncEnabled) { await _contactsService.SyncContactsAsync(response.Result); } } } Aggregator.Subscribe(this); }
public override Task OnNavigatedToAsync(object parameter, NavigationMode mode, IDictionary <string, object> state) { Aggregator.Subscribe(this); return(Task.CompletedTask); }
/// <summary> /// Runs the tests in the test assembly. /// </summary> /// <returns>Returns summary information about the tests that were run.</returns> public async Task <RunSummary> RunAsync() { var cancellationTokenSource = new CancellationTokenSource(); var totalSummary = new RunSummary(); #if NETFRAMEWORK var currentDirectory = Directory.GetCurrentDirectory(); #endif var testFrameworkEnvironment = GetTestFrameworkEnvironment(); var testFrameworkDisplayName = GetTestFrameworkDisplayName(); using (var messageBus = CreateMessageBus()) { #if NETFRAMEWORK Directory.SetCurrentDirectory(Path.GetDirectoryName(TestAssembly.Assembly.AssemblyPath)); #endif if (messageBus.QueueMessage(new TestAssemblyStarting(TestCases.Cast <ITestCase>(), TestAssembly, DateTime.Now, testFrameworkEnvironment, testFrameworkDisplayName))) { try { await AfterTestAssemblyStartingAsync(); var masterStopwatch = Stopwatch.StartNew(); totalSummary = await RunTestCollectionsAsync(messageBus, cancellationTokenSource); // Want clock time, not aggregated run time totalSummary.Time = (decimal)masterStopwatch.Elapsed.TotalSeconds; Aggregator.Clear(); await BeforeTestAssemblyFinishedAsync(); if (Aggregator.HasExceptions) { messageBus.QueueMessage(new TestAssemblyCleanupFailure(TestCases.Cast <ITestCase>(), TestAssembly, Aggregator.ToException())); } } finally { messageBus.QueueMessage(new TestAssemblyFinished(TestCases.Cast <ITestCase>(), TestAssembly, totalSummary.Time, totalSummary.Total, totalSummary.Failed, totalSummary.Skipped)); #if NETFRAMEWORK Directory.SetCurrentDirectory(currentDirectory); #endif } } } return(totalSummary); }
private async Task ExecuteTestMethod(MethodInfo runtimeMethod, RunSummary runSummary, IEnumerable <IApplicationAttribute> applicationAttributes, object[] dataRow) { foreach (var applicationAttribute in applicationAttributes) { Application application = null; Window mainWindow = null; WindowFixture fixture = null; try { application = applicationAttribute.ProvideApplication(runtimeMethod); application.WaitWhileBusy(); mainWindow = null; if (!string.IsNullOrEmpty(applicationAttribute.Window)) { mainWindow = application.GetWindow(applicationAttribute.Window); } else { mainWindow = application.GetWindows().FirstOrDefault(); } if (mainWindow == null) { throw new Exception("Could not locate main window " + applicationAttribute.Window); } fixture = new WindowFixture(application, mainWindow); ITypeInfo[] resolvedTypes = null; var methodToRun = runtimeMethod; if (methodToRun.IsGenericMethodDefinition) { resolvedTypes = TestCase.TestMethod.Method.ResolveGenericTypes(dataRow); methodToRun = methodToRun.MakeGenericMethod(resolvedTypes.Select(t => ((IReflectionTypeInfo)t).Type).ToArray()); } List <object> parameterList = new List <object>(); var parameters = methodToRun.GetParameters().ToArray(); object initializerReturn = null; int dataRowIndex = 0; for (int i = 0; i < parameters.Length; i++) { var parameter = parameters[i]; var attributes = parameter.GetCustomAttributes(true); if (parameter.ParameterType == typeof(Window)) { parameterList.Add(mainWindow); } else if (parameter.ParameterType == typeof(IWindowFixture)) { parameterList.Add(fixture); } else if (attributes.Any(a => a is GenerateAttribute)) { var generateAttribute = (GenerateAttribute)attributes.First(a => a is GenerateAttribute); InitializeCustomAttribute(generateAttribute, runtimeMethod, parameter); var constraintName = generateAttribute.ConstraintName ?? parameter.Name; var min = generateAttribute.Min; var max = generateAttribute.Max; var value = fixture.Data.Generate(parameter.ParameterType, constraintName, new { min, max }); parameterList.Add(value); } else if (attributes.Any(a => a is LocateAttribute)) { var locateAttribute = (LocateAttribute)attributes.First(a => a is LocateAttribute); InitializeCustomAttribute(locateAttribute, runtimeMethod, parameter); var value = locateAttribute.Value; if (value == null) { value = fixture.Data.Generate(new SimpleFixture.DataRequest(null, fixture.Data, parameter.ParameterType, parameter.Name, false, null, null)); } parameterList.Add(value); } else if (attributes.Any(a => a is FreezeAttribute)) { var freeze = (FreezeAttribute)attributes.FirstOrDefault(a => a is FreezeAttribute); InitializeCustomAttribute(freeze, runtimeMethod, parameter); var value = freeze.Value; if (value == null) { var constraintName = freeze.ConstraintName ?? parameter.Name; var min = freeze.Min; var max = freeze.Max; value = fixture.Data.Generate(parameter.ParameterType, constraintName, new { min, max }); } parameterList.Add(value); object lastObject = parameterList.Last(); var closedFreezeMethod = FreezeMethod.MakeGenericMethod(lastObject.GetType()); closedFreezeMethod.Invoke(null, new object[] { fixture.Data, value, freeze.For }); } else if (initializerReturn != null && parameter.ParameterType == initializerReturn.GetType()) { parameterList.Add(initializerReturn); initializerReturn = null; } else if (dataRowIndex < dataRow.Length) { var dataValue = dataRow[dataRowIndex]; dataRowIndex++; parameterList.Add(dataValue); } else { var value = fixture.Data.Generate(parameter.ParameterType, parameter.Name); parameterList.Add(value); } } var convertedDataRow = Reflector.ConvertArguments(parameterList.ToArray(), parameters.Select(p => p.ParameterType).ToArray()); var theoryDisplayName = TestCase.TestMethod.Method.GetDisplayNameWithArguments(DisplayName + " " + applicationAttribute.Application, dataRow, resolvedTypes); var test = new XunitTest(TestCase, theoryDisplayName); var skipReason = SkipReason; XunitTestRunner testRunner = CreateTestRunner(test, MessageBus, TestClass, ConstructorArguments, methodToRun, convertedDataRow, skipReason, BeforeAfterAttributes, Aggregator, CancellationTokenSource); runSummary.Aggregate(await testRunner.RunAsync()); } catch (Exception exp) { Aggregator.Add(exp); } finally { var timer = new ExecutionTimer(); timer.Aggregate(() => DisposeOfData(application, mainWindow, fixture, dataRow)); runSummary.Time += timer.Total; } } }
internal LatestPriceProviderContext(IPublicPricingProvider provider, Aggregator aggregator) { Provider = provider; Aggregator = aggregator; }
/// <summary> /// Called when [aggregator] is visited. /// </summary> /// <param name="aggregator">The aggregator.</param> public virtual void OnAggregator(Aggregator aggregator) { }
public void AggregatorClassifier() { List <MainData> dataList = new List <MainData>(); using (StreamReader sr = File.OpenText("Copy of DCManualLog.txt")) { string line; while ((line = sr.ReadLine()) != null) { string[] read = line.Split(','); dataList.Add(new MainData() { Time = DateTime.Parse(read[0]), Process = read[1], Title = read[2], Frequency = 1 }); // This can hit OOM if file is HUGE } } Aggregator agg = new Aggregator(); for (int i = 0; i < dataList.Count; i++) { agg.Add(dataList[i].Process, dataList[i].Title); } var aggRes = agg.GetAggregationResult(); List <MainData> aggregatedDataList = new List <MainData>(); for (int i = 0; i < aggRes.GetLength(0); i++) { dataList[aggRes[i, 0]].Frequency = aggRes[i, 1]; aggregatedDataList.Add(dataList[aggRes[i, 0]]); } Classifier cs = new Classifier(); for (int i = 0; i < aggregatedDataList.Count; i++) { cs.Add(i, aggregatedDataList[i].Process + aggregatedDataList[i].Title, aggregatedDataList[i].Frequency); } var csResult = cs.GetClassificationResult(); List <MainData> finalDataList = new List <MainData>(); for (int i = 0; i < csResult.GetLength(0); i++) { aggregatedDataList[(int)csResult[i, 0]].Frequency = csResult[i, 1]; finalDataList.Add(aggregatedDataList[(int)csResult[i, 0]]); } using (StreamWriter sw = File.AppendText("ClassifiedAnalysis.txt")) { foreach (var item in finalDataList) { sw.WriteLine(string.Format("{0},{1},{2},{3}", item.Time, item.Process, item.Title, item.Frequency)); } } }
public KTableAggregateProcessor(string storeName, bool sendOldValues, Initializer <T> initializer, Aggregator <K, V, T> add, Aggregator <K, V, T> remove) : base(storeName, sendOldValues, true) { this.initializer = initializer; this.add = add; this.remove = remove; }
public override Task OnNavigatedToAsync(object parameter, NavigationMode mode, IDictionary <string, object> state) { var chatId = (long)parameter; Chat = ProtoService.GetChat(chatId); var chat = _chat; if (chat == null) { return(Task.CompletedTask); } Aggregator.Subscribe(this); Delegate?.UpdateChat(chat); if (chat.Type is ChatTypePrivate privata) { var item = ProtoService.GetUser(privata.UserId); var cache = ProtoService.GetUserFull(privata.UserId); Delegate?.UpdateUser(chat, item, false); if (cache == null) { ProtoService.Send(new GetUserFullInfo(privata.UserId)); } else { Delegate?.UpdateUserFullInfo(chat, item, cache, false); } } else if (chat.Type is ChatTypeSecret secretType) { var secret = ProtoService.GetSecretChat(secretType.SecretChatId); var item = ProtoService.GetUser(secretType.UserId); var cache = ProtoService.GetUserFull(secretType.UserId); Delegate?.UpdateSecretChat(chat, secret); Delegate?.UpdateUser(chat, item, true); if (cache == null) { ProtoService.Send(new GetUserFullInfo(secret.UserId)); } else { Delegate?.UpdateUserFullInfo(chat, item, cache, true); } } else if (chat.Type is ChatTypeBasicGroup basic) { var item = ProtoService.GetBasicGroup(basic.BasicGroupId); var cache = ProtoService.GetBasicGroupFull(basic.BasicGroupId); Delegate?.UpdateBasicGroup(chat, item); if (cache == null) { ProtoService.Send(new GetBasicGroupFullInfo(basic.BasicGroupId)); } else { Delegate?.UpdateBasicGroupFullInfo(chat, item, cache); } } else if (chat.Type is ChatTypeSupergroup super) { var item = ProtoService.GetSupergroup(super.SupergroupId); var cache = ProtoService.GetSupergroupFull(super.SupergroupId); Delegate?.UpdateSupergroup(chat, item); if (cache == null) { ProtoService.Send(new GetSupergroupFullInfo(super.SupergroupId)); } else { Delegate?.UpdateSupergroupFullInfo(chat, item, cache); } } return(Task.CompletedTask); }
private protected override void GetAggregatorConsolidationFuncs(Aggregator aggregator, AggregatorDictionaryBase[] dictionaries, out Action <uint, ReadOnlyMemory <char>, Aggregator> addAgg, out Func <Dictionary <string, IDataView> > consolidate) { var stratCol = new List <uint>(); var stratVal = new List <ReadOnlyMemory <char> >(); var isWeighted = new List <bool>(); var ndcg = new List <Double[]>(); var dcg = new List <Double[]>(); var groupName = new List <ReadOnlyMemory <char> >(); var groupNdcg = new List <Double[]>(); var groupDcg = new List <Double[]>(); var groupMaxDcg = new List <Double[]>(); var groupStratCol = new List <uint>(); var groupStratVal = new List <ReadOnlyMemory <char> >(); bool hasStrats = Utils.Size(dictionaries) > 0; bool hasWeight = aggregator.Weighted; bool groupSummary = aggregator.UnweightedCounters.GroupSummary; addAgg = (stratColKey, stratColVal, agg) => { Host.Check(agg.Weighted == hasWeight, "All aggregators must either be weighted or unweighted"); Host.Check(agg.UnweightedCounters.GroupSummary == aggregator.UnweightedCounters.GroupSummary, "All aggregators must either compute group summary or not compute group summary"); stratCol.Add(stratColKey); stratVal.Add(stratColVal); isWeighted.Add(false); ndcg.Add(agg.UnweightedCounters.Ndcg); dcg.Add(agg.UnweightedCounters.Dcg); if (agg.UnweightedCounters.GroupSummary) { groupStratCol.AddRange(agg.UnweightedCounters.GroupDcg.Select(x => stratColKey)); groupStratVal.AddRange(agg.UnweightedCounters.GroupDcg.Select(x => stratColVal)); groupName.AddRange(agg.GroupId.Select(sb => sb.ToString().AsMemory())); groupNdcg.AddRange(agg.UnweightedCounters.GroupNdcg); groupDcg.AddRange(agg.UnweightedCounters.GroupDcg); groupMaxDcg.AddRange(agg.UnweightedCounters.GroupMaxDcg); } if (agg.Weighted) { stratCol.Add(stratColKey); stratVal.Add(stratColVal); isWeighted.Add(true); ndcg.Add(agg.WeightedCounters.Ndcg); dcg.Add(agg.WeightedCounters.Dcg); } }; consolidate = () => { var overallDvBldr = new ArrayDataViewBuilder(Host); if (hasStrats) { overallDvBldr.AddColumn(MetricKinds.ColumnNames.StratCol, GetKeyValueGetter(dictionaries), 0, dictionaries.Length, stratCol.ToArray()); overallDvBldr.AddColumn(MetricKinds.ColumnNames.StratVal, TextType.Instance, stratVal.ToArray()); } if (hasWeight) { overallDvBldr.AddColumn(MetricKinds.ColumnNames.IsWeighted, BoolType.Instance, isWeighted.ToArray()); } overallDvBldr.AddColumn(Ndcg, aggregator.GetSlotNames, NumberType.R8, ndcg.ToArray()); overallDvBldr.AddColumn(Dcg, aggregator.GetSlotNames, NumberType.R8, dcg.ToArray()); var groupDvBldr = new ArrayDataViewBuilder(Host); if (hasStrats) { groupDvBldr.AddColumn(MetricKinds.ColumnNames.StratCol, GetKeyValueGetter(dictionaries), 0, dictionaries.Length, groupStratCol.ToArray()); groupDvBldr.AddColumn(MetricKinds.ColumnNames.StratVal, TextType.Instance, groupStratVal.ToArray()); } if (groupSummary) { groupDvBldr.AddColumn(GroupId, TextType.Instance, groupName.ToArray()); groupDvBldr.AddColumn(Ndcg, aggregator.GetGroupSummarySlotNames("NDCG"), NumberType.R8, groupNdcg.ToArray()); groupDvBldr.AddColumn(Dcg, aggregator.GetGroupSummarySlotNames("DCG"), NumberType.R8, groupDcg.ToArray()); groupDvBldr.AddColumn(MaxDcg, aggregator.GetGroupSummarySlotNames("MaxDCG"), NumberType.R8, groupMaxDcg.ToArray()); } var result = new Dictionary <string, IDataView>(); result.Add(MetricKinds.OverallMetrics, overallDvBldr.GetDataView()); if (groupSummary) { result.Add(GroupSummary, groupDvBldr.GetDataView()); } return(result); }; }
public override Task OnNavigatedFromAsync(IDictionary <string, object> pageState, bool suspending) { Aggregator.Unsubscribe(this); return(Task.CompletedTask); }
public void SetUp() { log = new Log (); parser = new SystemtapParser (); aggregator = new Aggregator (log, parser); }
/// <inheritdoc/> protected override async Task AfterTestCaseStartingAsync() { await base.AfterTestCaseStartingAsync(); try { var dataAttributes = TestCase.TestMethod.Method.GetCustomAttributes(typeof(DataAttribute)); foreach (var dataAttribute in dataAttributes) { var discovererAttribute = dataAttribute.GetCustomAttributes(typeof(DataDiscovererAttribute)).First(); var args = discovererAttribute.GetConstructorArguments().Cast <string>().ToList(); var discovererType = SerializationHelper.GetType(args[1], args[0]); if (discovererType == null) { if (dataAttribute is IReflectionAttributeInfo reflectionAttribute) { Aggregator.Add(new InvalidOperationException($"Data discoverer specified for {reflectionAttribute.Attribute.GetType()} on {TestCase.TestMethod.TestClass.Class.Name}.{TestCase.TestMethod.Method.Name} does not exist.")); } else { Aggregator.Add(new InvalidOperationException($"A data discoverer specified on {TestCase.TestMethod.TestClass.Class.Name}.{TestCase.TestMethod.Method.Name} does not exist.")); } continue; } IDataDiscoverer discoverer; try { discoverer = ExtensibilityPointFactory.GetDataDiscoverer(DiagnosticMessageSink, discovererType); } catch (InvalidCastException) { if (dataAttribute is IReflectionAttributeInfo reflectionAttribute) { Aggregator.Add(new InvalidOperationException($"Data discoverer specified for {reflectionAttribute.Attribute.GetType()} on {TestCase.TestMethod.TestClass.Class.Name}.{TestCase.TestMethod.Method.Name} does not implement IDataDiscoverer.")); } else { Aggregator.Add(new InvalidOperationException($"A data discoverer specified on {TestCase.TestMethod.TestClass.Class.Name}.{TestCase.TestMethod.Method.Name} does not implement IDataDiscoverer.")); } continue; } var data = discoverer.GetData(dataAttribute, TestCase.TestMethod.Method); if (data == null) { Aggregator.Add(new InvalidOperationException($"Test data returned null for {TestCase.TestMethod.TestClass.Class.Name}.{TestCase.TestMethod.Method.Name}. Make sure it is statically initialized before this test method is called.")); continue; } foreach (var dataRow in data) { toDispose.AddRange(dataRow.OfType <IDisposable>()); ITypeInfo[] resolvedTypes = null; var methodToRun = TestMethod; var convertedDataRow = methodToRun.ResolveMethodArguments(dataRow); if (methodToRun.IsGenericMethodDefinition) { resolvedTypes = TestCase.TestMethod.Method.ResolveGenericTypes(convertedDataRow); methodToRun = methodToRun.MakeGenericMethod(resolvedTypes.Select(t => ((IReflectionTypeInfo)t).Type).ToArray()); } var parameterTypes = methodToRun.GetParameters().Select(p => p.ParameterType).ToArray(); convertedDataRow = Reflector.ConvertArguments(convertedDataRow, parameterTypes); var theoryDisplayName = TestCase.TestMethod.Method.GetDisplayNameWithArguments(DisplayName, convertedDataRow, resolvedTypes); var test = CreateTest(TestCase, theoryDisplayName); var skipReason = SkipReason ?? dataAttribute.GetNamedArgument <string>("Skip"); testRunners.Add(CreateTestRunner(test, MessageBus, TestClass, ConstructorArguments, methodToRun, convertedDataRow, skipReason, BeforeAfterAttributes, Aggregator, CancellationTokenSource)); } } } catch (Exception ex) { // Stash the exception so we can surface it during RunTestAsync dataDiscoveryException = ex; } }
protected void Aggregate <Tseries, Tval>(TimeSeriesResampler <Tseries, Tval> resampler, ITimeSeries <Tval> series, Aggregator defaultFunc, Func <Tval, decimal> selector, Func <decimal, Tval> resultCast) where Tval : struct where Tseries : TimeSeriesBase <Tval> { Aggregate(resampler, new List <ITimeSeries <Tval> >() { series }, defaultFunc, selector, resultCast); }
private static void ExecuteSingleVectorOperation <T>(BinaryExpression operation, LinearAlgebraProvider provider, ArrayPoolStack <T> arrayPoolStack, List <NArray <T> > localsToFree, OutputGetter <T> getter, Aggregator aggregator, int vectorLength, int chunkIndex, int startIndex, ExecutionTimer timer) { if (operation == null || operation.NodeType != ExpressionType.Assign) { return; } if (operation == null) { return; } NArray <T> result; var left = operation.Left as ReferencingVectorParameterExpression <T>; NArray <T> aggregationTarget = null; if (left.ParameterType == ParameterType.Local) { result = left.Array; var chunkyStorage = result.Storage as ChunkyStorage <T>; if (chunkyStorage != null) { var newStorage = arrayPoolStack.Pop(); chunkyStorage.SetChunk(chunkIndex, newStorage); } aggregationTarget = getter.TryGetNext(left.Index); } else { result = (operation.Left as ReferencingVectorParameterExpression <T>).Array; } if (operation.Right is UnaryMathsExpression) { var unaryOperation = operation.Right as UnaryMathsExpression; if (unaryOperation.UnaryType == UnaryElementWiseOperation.ScaleOffset) { var scaleOffset = unaryOperation as ScaleOffsetExpression <T>; (provider as IElementWise <T>).ScaleOffset(Slice <T>(unaryOperation.Operand, chunkIndex, startIndex, vectorLength), scaleOffset.Scale, scaleOffset.Offset, Slice(result, chunkIndex, startIndex, vectorLength)); } else if (unaryOperation.UnaryType == UnaryElementWiseOperation.ScaleInverse) { var scaleInverse = unaryOperation as ScaleInverseExpression <T>; (provider as IElementWise <T>).ScaleInverse(Slice <T>(unaryOperation.Operand, chunkIndex, startIndex, vectorLength), scaleInverse.Scale, Slice(result, chunkIndex, startIndex, vectorLength)); } else { (provider as IElementWise <T>).UnaryElementWiseOperation( Slice <T>(unaryOperation.Operand, chunkIndex, startIndex, vectorLength), Slice(result, chunkIndex, startIndex, vectorLength), unaryOperation.UnaryType); } } if (operation.Right is BinaryExpression) { var binaryOperation = operation.Right as BinaryExpression; (provider as IElementWise <T>).BinaryElementWiseOperation(Slice <T>(binaryOperation.Left, chunkIndex, startIndex, vectorLength), Slice <T>(binaryOperation.Right, chunkIndex, startIndex, vectorLength), Slice(result, chunkIndex, startIndex, vectorLength), binaryOperation.NodeType); } if (aggregationTarget != null) { if (aggregator != Aggregator.ElementwiseAdd) { throw new NotImplementedException(); } if (aggregationTarget.IsScalar) { throw new Exception(); } var slice = Slice <T>(aggregationTarget, chunkIndex, startIndex, vectorLength); (provider as IElementWise <T>).BinaryElementWiseOperation( slice, Slice(result, chunkIndex, startIndex, vectorLength), slice, ExpressionType.Add); } foreach (var item in localsToFree) { arrayPoolStack.Push((item.Storage as ChunkyStorage <T>).GetChunk(chunkIndex)); } }
protected virtual void StoreColumn(QuerySelectColumnData column) { Aggregator.AddSelect(column); }
/// <summary> /// Runs the test. /// </summary> /// <returns>Returns summary information about the test that was run.</returns> public async Task <RunSummary> RunAsync() { var runSummary = new RunSummary { Total = 1 }; var output = String.Empty; // TODO: Add output facilities for v2 if (!MessageBus.QueueMessage(new TestStarting(TestCase, DisplayName))) { CancellationTokenSource.Cancel(); } else { AfterTestStarting(); if (!String.IsNullOrEmpty(SkipReason)) { runSummary.Skipped++; if (!MessageBus.QueueMessage(new TestSkipped(TestCase, DisplayName, SkipReason))) { CancellationTokenSource.Cancel(); } } else { var aggregator = new ExceptionAggregator(Aggregator); if (!aggregator.HasExceptions) { runSummary.Time = await aggregator.RunAsync(() => InvokeTestAsync(aggregator)); } var exception = aggregator.ToException(); TestResultMessage testResult; if (exception == null) { testResult = new TestPassed(TestCase, DisplayName, runSummary.Time, output); } else { testResult = new TestFailed(TestCase, DisplayName, runSummary.Time, output, exception); runSummary.Failed++; } if (!CancellationTokenSource.IsCancellationRequested) { if (!MessageBus.QueueMessage(testResult)) { CancellationTokenSource.Cancel(); } } } Aggregator.Clear(); BeforeTestFinished(); if (Aggregator.HasExceptions) { if (!MessageBus.QueueMessage(new TestCleanupFailure(TestCase, DisplayName, Aggregator.ToException()))) { CancellationTokenSource.Cancel(); } } } if (!MessageBus.QueueMessage(new TestFinished(TestCase, DisplayName, runSummary.Time, output))) { CancellationTokenSource.Cancel(); } return(runSummary); }
private void ApplyAggregatorResults(Aggregator aggregator) { aggregator.Evaluate(); DoIt(aggregator.InferredFacts); }
/// <summary> /// Called when [aggregator] is visited. /// </summary> /// <param name="aggregator">The aggregator.</param> public override void OnAggregator(Aggregator aggregator) { _sb.AppendLine(aggregator.ToString()); }
/// <summary> /// Runs the tests in the test case. /// </summary> /// <returns>Returns summary information about the tests that were run.</returns> public async Task <RunSummary> RunAsync() { var summary = new RunSummary(); if (!MessageBus.QueueMessage(new TestCaseStarting(TestCase))) { CancellationTokenSource.Cancel(); } else { try { await AfterTestCaseStartingAsync(); summary = await RunTestAsync(); Aggregator.Clear(); await BeforeTestCaseFinishedAsync(); if (Aggregator.HasExceptions) { if (!MessageBus.QueueMessage(new TestCaseCleanupFailure(TestCase, Aggregator.ToException()))) { CancellationTokenSource.Cancel(); } } } finally { if (!MessageBus.QueueMessage(new TestCaseFinished(TestCase, summary.Time, summary.Total, summary.Failed, summary.Skipped))) { CancellationTokenSource.Cancel(); } } } return(summary); }
/// <summary> /// Adds the aggregator. /// </summary> /// <param name="m">The m.</param> public void AddAggregator(Aggregator m) { AggregatorNode new_production = new AggregatorNode(m.Label); new_production.Aggregator = m; AddProduction(new_production, m.lhs); m.AggregatorNode = new_production; }
protected override void CreateCollectionFixture(Type fixtureType) { Aggregator.Run(() => CollectionFixtureMappings[fixtureType] = _testCollectionLifetimeScope.Resolve(fixtureType)); }
/// <summary> /// Adds the aggregator to the internal list. /// </summary> /// <param name="aggregator">The aggregator.</param> public void AddAggregator(Aggregator aggregator) { _aggregators.Add(aggregator); }
public override Task OnNavigatedToAsync(object parameter, NavigationMode mode, IDictionary <string, object> state) { ProtoService.Send(new GetInstalledStickerSets(false), result => { if (result is StickerSets sets) { BeginOnUIThread(() => Items.ReplaceWith(sets.Sets)); } }); var chatId = (long)parameter; Chat = ProtoService.GetChat(chatId); var chat = _chat; if (chat == null) { return(Task.CompletedTask); } Aggregator.Subscribe(this); //Delegate?.UpdateChat(chat); if (chat.Type is ChatTypeSupergroup super) { var item = ProtoService.GetSupergroup(super.SupergroupId); var cache = ProtoService.GetSupergroupFull(super.SupergroupId); //Delegate?.UpdateSupergroup(chat, item); if (cache == null) { ProtoService.Send(new GetSupergroupFullInfo(super.SupergroupId)); } else { UpdateSupergroupFullInfo(chat, item, cache); } } return(Task.CompletedTask); //Item = null; //Full = null; //SelectedItem = null; //var channel = parameter as TLChannel; //var peer = parameter as TLPeerChannel; //if (peer != null) //{ // channel = CacheService.GetChat(peer.ChannelId) as TLChannel; //} //if (channel != null) //{ // Item = channel; // var full = CacheService.GetFullChat(channel.Id) as TLChannelFull; // if (full == null) // { // var response = await LegacyService.GetFullChannelAsync(channel.ToInputChannel()); // if (response.IsSucceeded) // { // full = response.Result.FullChat as TLChannelFull; // } // } // if (full != null) // { // Full = full; // SelectedItem = _stickersService.GetGroupStickerSetById(full.StickerSet); // } //} }
public AggregationFunction GetAggregator(Aggregator aggregator) { switch (aggregator) { case Aggregator.Sum: return AggregationFunction.Sum; case Aggregator.Count: return AggregationFunction.Count; case Aggregator.Min: return AggregationFunction.Min; case Aggregator.Max: return AggregationFunction.Max; case Aggregator.DistinctCount: return AggregationFunction.DistinctCount; case Aggregator.None: return AggregationFunction.None; case Aggregator.ByAccount: return AggregationFunction.ByAccount; case Aggregator.AverageOfChildren: return AggregationFunction.AverageOfChildren; case Aggregator.FirstChild: return AggregationFunction.FirstChild; case Aggregator.LastChild: return AggregationFunction.LastChild; case Aggregator.FirstNonEmpty: return AggregationFunction.FirstNonEmpty; case Aggregator.LastNonEmpty: return AggregationFunction.LastNonEmpty; } throw new NotSupportedException(string.Format("不支持此枚举类型{0}", aggregator)); }
protected override void GetAggregatorConsolidationFuncs(Aggregator aggregator, AggregatorDictionaryBase[] dictionaries, out Action <uint, DvText, Aggregator> addAgg, out Func <Dictionary <string, IDataView> > consolidate) { var stratCol = new List <uint>(); var stratVal = new List <DvText>(); var auc = new List <Double>(); var drAtK = new List <Double>(); var drAtP = new List <Double>(); var drAtNumAnomalies = new List <Double>(); var thresholdAtK = new List <Single>(); var thresholdAtP = new List <Single>(); var thresholdAtNumAnomalies = new List <Single>(); var numAnoms = new List <DvInt8>(); var scores = new List <Single>(); var labels = new List <Single>(); var names = new List <DvText>(); var topKStratCol = new List <uint>(); var topKStratVal = new List <DvText>(); bool hasStrats = Utils.Size(dictionaries) > 0; addAgg = (stratColKey, stratColVal, agg) => { agg.Finish(); stratCol.Add(stratColKey); stratVal.Add(stratColVal); auc.Add(agg.Auc); drAtK.Add(agg.DrAtK); drAtP.Add(agg.DrAtP); drAtNumAnomalies.Add(agg.DrAtNumAnomalies); thresholdAtK.Add(agg.ThresholdAtK); thresholdAtP.Add(agg.ThresholdAtP); thresholdAtNumAnomalies.Add(agg.ThresholdAtNumAnomalies); numAnoms.Add(agg.AggCounters.NumAnomalies); names.AddRange(agg.Names.Take(agg.NumTopExamples)); scores.AddRange(agg.Scores.Take(agg.NumTopExamples)); labels.AddRange(agg.Labels.Take(agg.NumTopExamples)); if (hasStrats) { topKStratCol.AddRange(agg.Scores.Select(x => stratColKey)); topKStratVal.AddRange(agg.Scores.Select(x => stratColVal)); } }; consolidate = () => { var overallDvBldr = new ArrayDataViewBuilder(Host); if (hasStrats) { overallDvBldr.AddColumn(MetricKinds.ColumnNames.StratCol, GetKeyValueGetter(dictionaries), 0, dictionaries.Length, stratCol.ToArray()); overallDvBldr.AddColumn(MetricKinds.ColumnNames.StratVal, TextType.Instance, stratVal.ToArray()); } overallDvBldr.AddColumn(BinaryClassifierEvaluator.Auc, NumberType.R8, auc.ToArray()); overallDvBldr.AddColumn(OverallMetrics.DrAtK, NumberType.R8, drAtK.ToArray()); overallDvBldr.AddColumn(OverallMetrics.DrAtPFpr, NumberType.R8, drAtP.ToArray()); overallDvBldr.AddColumn(OverallMetrics.DrAtNumPos, NumberType.R8, drAtNumAnomalies.ToArray()); overallDvBldr.AddColumn(OverallMetrics.ThreshAtK, NumberType.R4, thresholdAtK.ToArray()); overallDvBldr.AddColumn(OverallMetrics.ThreshAtP, NumberType.R4, thresholdAtP.ToArray()); overallDvBldr.AddColumn(OverallMetrics.ThreshAtNumPos, NumberType.R4, thresholdAtNumAnomalies.ToArray()); overallDvBldr.AddColumn(OverallMetrics.NumAnomalies, NumberType.I8, numAnoms.ToArray()); var topKdvBldr = new ArrayDataViewBuilder(Host); if (hasStrats) { topKdvBldr.AddColumn(MetricKinds.ColumnNames.StratCol, GetKeyValueGetter(dictionaries), 0, dictionaries.Length, topKStratCol.ToArray()); topKdvBldr.AddColumn(MetricKinds.ColumnNames.StratVal, TextType.Instance, topKStratVal.ToArray()); } topKdvBldr.AddColumn(TopKResultsColumns.Instance, TextType.Instance, names.ToArray()); topKdvBldr.AddColumn(TopKResultsColumns.AnomalyScore, NumberType.R4, scores.ToArray()); topKdvBldr.AddColumn(TopKResultsColumns.Label, NumberType.R4, labels.ToArray()); var result = new Dictionary <string, IDataView>(); result.Add(MetricKinds.OverallMetrics, overallDvBldr.GetDataView()); result.Add(TopKResults, topKdvBldr.GetDataView()); return(result); }; }
protected void Aggregate <Tseries, Tval>(TimeSeriesResampler <Tseries, Tval> resampler, IEnumerable <ITimeSeries <Tval> > series, Aggregator defaultFunc, Func <Tval, decimal> selector, Func <decimal, Tval> resultCast) where Tval : struct where Tseries : TimeSeriesBase <Tval> { switch (AggregatorFunction == Aggregator.Default ? defaultFunc : AggregatorFunction) { case Aggregator.Minimum: { resampler.SampleAggregate(series, x => resultCast(x.Min(selector) * CorrectionFactor + CorrectionOffset)); break; } case Aggregator.Maximum: { resampler.SampleAggregate(series, x => resultCast(x.Max(selector) * CorrectionFactor + CorrectionOffset)); break; } case Aggregator.Sum: { resampler.SampleAggregate(series, x => resultCast(x.Sum(selector) * CorrectionFactor + CorrectionOffset)); break; } case Aggregator.Average: goto default; default: { resampler.SampleAggregate(series, x => resultCast(x.Average(selector) * CorrectionFactor + CorrectionOffset)); break; } } }
public void Run(Aggregator aggregator, string[] argv, string stdin_str) { if (state != State.PreRun) throw new ApplicationException ("Tried to Run() an AggregatorRunner which was not in PreRun state"); if (aggregator == null) throw new ArgumentNullException ("aggregator"); if (argv == null) throw new ArgumentNullException ("argv"); this.aggregator = aggregator; try { int[] pipe; spawn = new Spawn (); pipe = new int[2]; if (unix.pipe (pipe) != 0) throw new UnixIOException (Mono.Unix.Native.Stdlib.GetLastError ()); Spawn.ChildSetupFunc child_setup_fn = delegate () { int process_group; UnixStream child_stream; StreamWriter child_writer; process_group = unix.setsid (); child_stream = new UnixStream (pipe[1], false); child_writer = new StreamWriter (child_stream); child_writer.Write ("{0}\n", process_group); child_writer.Close (); }; spawn.SpawnAsyncWithPipes (null, argv, null, GSpawnFlags.G_SPAWN_DO_NOT_REAP_CHILD | GSpawnFlags.G_SPAWN_SEARCH_PATH, child_setup_fn, out child_pid, out child_stdin, out child_stdout, out child_stderr); child_watch_id = spawn.ChildWatchAdd (child_pid, child_watch_cb); UnixStream parent_stream; StreamReader parent_reader; string str; parent_stream = new UnixStream (pipe[0], false); parent_reader = new StreamReader (parent_stream); str = parent_reader.ReadLine (); parent_reader.Close (); child_process_group = int.Parse (str); if (child_process_group == -1) throw new ApplicationException ("Could not get the child process group"); state = State.Running; stdout_reader = new UnixReader (child_stdout); stdout_reader.DataAvailable += stdout_reader_data_available_cb; stdout_reader.Closed += stdout_reader_closed_cb; stderr_reader = new UnixReader (child_stderr); stderr_reader.DataAvailable += stderr_reader_data_available_cb; stderr_reader.Closed += stderr_reader_closed_cb; line_reader = new LineReader (); line_reader.LineAvailable += line_reader_line_available_cb; if (stdin_str != null) write_stdin_to_child (stdin_str); } catch (GException e) { Console.WriteLine ("error when spawning: {0}", e); /* FIXME: report something better --- re-throw the exception here? */ state = State.Error; } }