public static AggregateAggregateValue Create( AggregateOperator aggregateOperator, string continuationToken) { IAggregator aggregator; switch (aggregateOperator) { case AggregateOperator.Average: aggregator = AverageAggregator.Create(continuationToken); break; case AggregateOperator.Count: aggregator = CountAggregator.Create(continuationToken); break; case AggregateOperator.Max: aggregator = MinMaxAggregator.CreateMaxAggregator(continuationToken); break; case AggregateOperator.Min: aggregator = MinMaxAggregator.CreateMinAggregator(continuationToken); break; case AggregateOperator.Sum: aggregator = SumAggregator.Create(continuationToken); break; default: throw new ArgumentException($"Unknown {nameof(AggregateOperator)}: {aggregateOperator}."); } return(new AggregateAggregateValue(aggregator)); }
public static TryCatch <AggregateValue> TryCreate( AggregateOperator aggregateOperator, string continuationToken) { TryCatch <IAggregator> tryCreateAggregator; switch (aggregateOperator) { case AggregateOperator.Average: tryCreateAggregator = AverageAggregator.TryCreate(continuationToken); break; case AggregateOperator.Count: tryCreateAggregator = CountAggregator.TryCreate(continuationToken); break; case AggregateOperator.Max: tryCreateAggregator = MinMaxAggregator.TryCreateMaxAggregator(continuationToken); break; case AggregateOperator.Min: tryCreateAggregator = MinMaxAggregator.TryCreateMinAggregator(continuationToken); break; case AggregateOperator.Sum: tryCreateAggregator = SumAggregator.TryCreate(continuationToken); break; default: throw new ArgumentException($"Unknown {nameof(AggregateOperator)}: {aggregateOperator}."); } return(tryCreateAggregator.Try <AggregateValue>((aggregator) => new AggregateAggregateValue(aggregator))); }
protected override Expression TransformFunction(FunctionExpression functionExpression) { if (functionExpression.Function == Operators.Diff) { VariableListExtractor extractor = new VariableListExtractor(); extractor.Visit(functionExpression[1]); IReadOnlyList <Variable> variables = extractor.Variables; if (variables.Count == 0) { throw new InvalidOperationException("Cannot calculate derivative by constant"); } throw new NotImplementedException(); } if (functionExpression.Function == Operators.Plus) { return(Transform(functionExpression[0])); } if (functionExpression.Function is Operator) { SumAggregator aggregator = new SumAggregator(); aggregator.VisitFunction(functionExpression); return(aggregator.ToExpression()); } return(functionExpression.Function.Apply(functionExpression.Select(Transform))); }
public void SumAggregator() { var sumAggr = new SumAggregator("test"); Func <object, string, object> getVal = (r, f) => { Assert.Equal("test", f); return(r); }; sumAggr.Push(5, getVal); Assert.Equal(5M, sumAggr.Value); sumAggr.Push(3, getVal); Assert.Equal(8M, sumAggr.Value); }
public void SumAggregator_Merge() { var sumAggr1 = new SumAggregator("test"); var sumAggr2 = new SumAggregator("test"); Func <object, string, object> getVal = (r, f) => { return(r); }; for (int i = 0; i < 10; i++) { sumAggr1.Push(i, getVal); sumAggr2.Push(i % 2, getVal); } sumAggr1.Merge(sumAggr2); Assert.Equal(50M, Convert.ToDecimal(sumAggr1.Value)); Assert.Equal(20, (int)sumAggr1.Count); }
public void AggregateField_Given_a_valid_field_Agregate_shound_be_equal_to_sum_of_the_field_value() { var aggregate = new Aggregate(); var target = new SumAggregator { Aggregate = aggregate, Description = "Record Count", Name = "Record Count" }; var field1 = new Field { Index = 1, Raw = "100", ValidationResult = ValidationResultType.Valid, Value = 100 }; var field2 = new Field { Index = 2, Raw = "200", ValidationResult = ValidationResultType.Valid, Value = 200 }; target.AggregateField(field1); target.AggregateField(field2); Assert.AreEqual(300m, aggregate.Value); }
public RemoteAvgAggregator(IAccessor <T> accessor) : base(accessor) { _countAggregator = new SumAggregator <T>(accessor); _valueAggregator = new SumAggregator <T>(accessor); }