Esempio n. 1
0
        private void OnPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            switch (e.PropertyName)
            {
            case nameof(Filter.IsChecked):
                CombinationFilter.CalculateSummary(Trades);
                break;

            case nameof(Filter.ArgumentValue):
                var filter = sender as Filter;
                if (filter != null)
                {
                    // Which vm does this correspond with?
                    var vm = Filters.SingleOrDefault(x => x.Filter == filter);
                    if (vm != null)
                    {
                        vm.CalculateSummary(Trades);
                    }

                    // Update combination filter as well
                    CombinationFilter.CalculateSummary(Trades);
                }

                break;
            }
        }
        public void CombinationFilter_OrOperator_GetPredicate_FiltersToExpectedResults()
        {
            var filter1 = new NumericRangeFilter(5, 10);
            var filter2 = new NumericRangeFilter(8, 15);
            var filter  = new CombinationFilter <NumericRangeFilter>(new[] { filter1, filter2 }, CombinationOperator.Any);
            var values  = new[] { 1, 3, 5, 9, 11 };
            var expectedFilteredValues = new[] { 5, 9, 11 };

            var filterPredicate = filter.GetPredicate <NumericRangeFilter, int>();
            var filteredValues  = values.Where(filterPredicate);

            Assert.Equal(expectedFilteredValues, filteredValues);
        }
Esempio n. 3
0
        public void ComplexFilter_IsMatch_FiltersToExpectedResults()
        {
            var filter5To10        = new NumericRangeFilter(5, 10);
            var filter8To15        = new NumericRangeFilter(8, 15);
            var filter5To10Or8To15 = new CombinationFilter <NumericRangeFilter>(new[] { filter5To10, filter8To15 }, CombinationOperator.Any);
            var filter9To12        = new NumericRangeFilter(9, 12);
            var filter             = new CombinationFilter <NumericRangeFilter>(new IFilterNode <NumericRangeFilter>[] { filter5To10Or8To15, filter9To12 }, CombinationOperator.All);

            var values = new[] { 1, 3, 5, 9, 11 };
            var expectedFilteredValues = new[] { 9, 11 };

            var filteredValues = values.Where(v => filter.IsMatch(v));

            Assert.Equal(expectedFilteredValues, filteredValues);
        }
        public void ComplexFilter_GetPredicate_FiltersToExpectedResults()
        {
            var filter5To10         = new NumericRangeFilter(5, 10);
            var filter8To15         = new NumericRangeFilter(8, 15);
            var filter5To10And8To15 = new CombinationFilter <NumericRangeFilter>(new[] { filter5To10, filter8To15 }, CombinationOperator.Any);
            var filter9To12         = new NumericRangeFilter(9, 12);
            var filter = new CombinationFilter <NumericRangeFilter>(new IFilterNode <NumericRangeFilter>[] { filter5To10And8To15, filter9To12 }, CombinationOperator.All);
            var values = new[] { 1, 3, 5, 9, 11 };
            var expectedFilteredValues = new[] { 9, 11 };

            var filterPredicate = filter.GetPredicate <NumericRangeFilter, int>();
            var filteredValues  = values.Where(filterPredicate);

            Assert.Equal(expectedFilteredValues, filteredValues);
        }
Esempio n. 5
0
        public void Aggregate_ReturnsExpectedResult_WhenComputingLengthOfLongestInterval()
        {
            var filter5To10        = new NumericRangeFilter(5, 10);
            var filter8To15        = new NumericRangeFilter(8, 15);
            var filter5To10Or8To15 = new CombinationFilter <NumericRangeFilter>(new[] { filter5To10, filter8To15 }, CombinationOperator.Any);
            var filter9To12        = new NumericRangeFilter(9, 12);
            var filter             = new CombinationFilter <NumericRangeFilter>(new IFilterNode <NumericRangeFilter>[] { filter5To10Or8To15, filter9To12 }, CombinationOperator.All);

            // Reduce the filter to get the length of the longest interval
            var result = filter.Aggregate <double>(
                (lengths, _) => lengths.Max(),
                length => double.PositiveInfinity,
                f => f.UpperBound - f.LowerBound);

            // Max is 15 - 8
            Assert.Equal(7, result);
        }
Esempio n. 6
0
        public void Map_ReturnsCorrectStructureAndValues()
        {
            var filter5To10        = new NumericRangeFilter(5, 10);
            var filter8To15        = new NumericRangeFilter(8, 15);
            var filter5To10Or8To15 = new CombinationFilter <NumericRangeFilter>(new[] { filter5To10, filter8To15 }, CombinationOperator.Any);
            var filter9To12        = new NumericRangeFilter(9, 12);
            var filter             = new CombinationFilter <NumericRangeFilter>(new IFilterNode <NumericRangeFilter>[] { filter5To10Or8To15, filter9To12 }, CombinationOperator.All);

            var result = filter.Map(
                f =>
            {
                var newLowerBound = f.LowerBound + 1;
                var newUpperBound = f.UpperBound - 1;
                return(new NumericRangeFilter(newLowerBound, newUpperBound));
            });

            var filter6To9        = new NumericRangeFilter(6, 9);
            var filter9To14       = new NumericRangeFilter(9, 14);
            var filter6To9Or9To14 = new CombinationFilter <NumericRangeFilter>(new[] { filter6To9, filter9To14 }, CombinationOperator.Any);
            var filter10To11      = new NumericRangeFilter(10, 11);
            var expectedFilter    = new CombinationFilter <NumericRangeFilter>(new IFilterNode <NumericRangeFilter>[] { filter6To9Or9To14, filter10To11 }, CombinationOperator.All);

            Assert.Equal(expectedFilter, result, EqualityComparer <IFilterNode> .Default);
        }
Esempio n. 7
0
        public void GetPartial_Example()
        {
            // All the numbers from -5 to 10, EXCEPT numbers from 2 to 6
            var filter = new CombinationFilter <NumericRangeFilter>(new IFilterNode <NumericRangeFilter>[]
            {
                new NumericRangeFilter(-5, 10),
                new InvertedFilter <NumericRangeFilter>(new NumericRangeFilter(2, 6)),
            }, CombinationOperator.All);

            // Exclude filters with negative values
            var partialFilter = filter.GetPartial(f => f.LowerBound >= 0);

            var positiveValues    = new[] { 1, 3, 5, 7, 12 };
            var prefilteredValues = positiveValues.Where(partialFilter.IsMatch).ToList();

            Assert.Equal(new[] { 1, 7, 12 }, prefilteredValues);

            var additionalValues = new[] { -7, -4, 11 };
            var combinedValues   = prefilteredValues.Concat(additionalValues);

            var finalValues = combinedValues.Where(filter.IsMatch);

            Assert.Equal(new[] { 1, 7, -4 }, finalValues);
        }