C# Function.Filter方法代码示例

        [Category(TestCategory.Jira)] //TOOLS-4934
        public void EventBubbleCorerctlyForFunctionWithReducedArgument()
        {
            IFunction function = new Function
                                     {
                                         Arguments = {new Variable<int>("x1"), new Variable<int>("x2")},
                                         Components = {new Variable<int>("f")}
                                     };

            function[0, 1] = new[] {1};
            function[0, 2] = new[] {2};
            function[1, 1] = new[] {3};
            function[1, 2] = new[] {4};

            var arg1 = function.Arguments[0];

            var filteredFunction = function.Filter(new VariableValueFilter<int>(arg1, 0), new VariableReduceFilter(arg1));
            
            int called = 0;

            filteredFunction.ValuesChanged += (s, e) => called++;

            function[0, 2] = 3; //set value

            Assert.AreEqual(1, called);
        }

        public void FilterFunction()
        {
            IVariable<double> x = new Variable<double>("x");
            IVariable<double> y = new Variable<double>("y");
            IVariable<double> fx = new Variable<double>("fx");
            IVariable<double> fy = new Variable<double>("fy");

            IFunction f = new Function();
            f.Arguments.Add(x);
            f.Arguments.Add(y);
            f.Components.Add(fx);
            f.Components.Add(fy);

            x.SetValues(new[] { 1.0, 2.0, 3.0 });
            y.SetValues(new[] { 10.0, 20.0 });

            f.Components[0].Values[1, 1] = 100.0;
            f.Components[1].Values[1, 1] = 200.0;

            // fx       10.0  20.0 
            //          ------------
            //    1.0  | 0.0    0.0
            //    2.0  | 0.0  100.0 
            //    3.0  | 0.0    0.0
            //
            // fy       10.0  20.0 
            //          ------------
            //    1.0  | 0.0    0.0
            //    2.0  | 0.0  200.0 
            //    3.0  | 0.0    0.0

            var filteredFunction = f.Filter(x.CreateValueFilter(2.0), y.CreateValueFilter(20.0));

            Assert.AreEqual(2, filteredFunction.Components.Count);
            Assert.AreEqual(2, filteredFunction.Arguments.Count);

            Assert.AreEqual(1, filteredFunction.Arguments[0].Values.Count);
            Assert.AreEqual(1, filteredFunction.Arguments[1].Values.Count);
            Assert.AreEqual(1, filteredFunction.Components[0].Values.Count);
            Assert.AreEqual(1, filteredFunction.Components[1].Values.Count);

            Assert.AreEqual(100.0, filteredFunction.Components[0].Values[0]);
            Assert.AreEqual(200.0, filteredFunction.Components[1].Values[0]);
        }

        public void BindToFilteredFuntion()
        {
            //setup a 2D function and fix one dimension
            IFunction function = new Function();
            IVariable<int> x = new Variable<int>();

            function.Arguments.Add(x);
            function.Arguments.Add(new Variable<int>("Y"));
            function.Components.Add(new Variable<int>());

            function[0, 0] = 2;
            function[0, 1] = 3;
            function[1, 0] = 1;
            function[1, 1] = 4;

            IFunction filteredFunction = function.Filter(new VariableValueFilter<int>(x, 0));

            ILineChartSeries lineChartSeries = ChartSeriesFactory.CreateLineSeries();
            var variable = filteredFunction.Arguments[1];
            var component = filteredFunction.Components[0]; 
            
            lineChartSeries.XValuesDataMember = variable.DisplayName;
            lineChartSeries.YValuesDataMember = component.DisplayName;

            var functionBindingList = new FunctionBindingList(filteredFunction);
            lineChartSeries.DataSource = functionBindingList;
            while (functionBindingList.IsProcessing)
            {
                Application.DoEvents();
            }

            Assert.AreEqual(2, lineChartSeries.XValues.Count);
            Assert.AreEqual(2, lineChartSeries.YValues.Count);
            Assert.AreEqual(0.0, lineChartSeries.XValues[0]);
            Assert.AreEqual(1.0, lineChartSeries.XValues[1]);
            Assert.AreEqual(2.0, lineChartSeries.YValues[0]);
            Assert.AreEqual(3.0, lineChartSeries.YValues[1]);
        }

        public void GetValuesOfFilteredFunction()
        {
            IFunction function = new Function();
            function.Components.Add(new Variable<int>());
            function.Arguments.Add(new Variable<int>());
            function[0] = 1;
            function[1] = 2;
            function[2] = 3;


            IFunction filtered =
                function.Filter(new VariableValueFilter<int>(function.Arguments[0], new[] {0, 1}));

            Assert.AreEqual(1, filtered[0]);
        }

        public void FilterUsingComponent()
        {
            IFunction f = new Function();
            IVariable c1 = new Variable<int>("c1");
            IVariable c2 = new Variable<int>("c2");
            IVariable x = new Variable<int>("x");
            IVariable y = new Variable<int>("y");
            f.Components.Add(c1);
            f.Components.Add(c2);
            f.Arguments.Add(x);
            f.Arguments.Add(y);

            f.SetValues(
                new[] { 100, 200 },
                new VariableValueFilter<int>(x, new[] { 1, 2, 3, 4, 5 }),
                new VariableValueFilter<int>(y, new[] { 1, 2, 3 })
                );

            IFunction filtered = f.Filter(new ComponentFilter(c1));

            IMultiDimensionalArray<int> values = filtered.GetValues<int>(new VariableValueFilter<int>(x, new[] { 1, 2, 3 }));

            Assert.IsTrue(values.Shape.SequenceEqual(new[] { 3, 3 }));
            Assert.AreEqual(100, values[2, 2]);
        }

        public void FilteredFunctionArgumentInterpolationAndExtrapolationTakenFromParent()
        {
            IFunction function = new Function();
            function.Components.Add(new Variable<int>());
            function.Arguments.Add(new Variable<int>{InterpolationType = InterpolationType.Constant});
            function.Arguments[0].ExtrapolationType = ExtrapolationType.Linear;
            function[0] = 1;
            function[1] = 2;

            IFunction filtered =
                function.Filter(new VariableValueFilter<int>(function.Arguments[0], new[] { 0, 1 }));

            Assert.AreEqual(InterpolationType.Constant, filtered.Arguments[0].InterpolationType);
            Assert.AreEqual(ExtrapolationType.Linear, filtered.Arguments[0].ExtrapolationType);
        }

 public void SettingNoDataValuesOfFilteredFunctionGivesException()
 {
     IFunction function = new Function();
     function.Components.Add(new Variable<int>());
     function.Arguments.Add(new Variable<int>());
     function[0] = 1;
     function[1] = 2;
     function[2] = 3;
     function.Components[0].NoDataValue = 79;
     var filtered = function.Filter(new VariableValueFilter<int>(function.Arguments[0], new[] { 0, 1 }));
     filtered.Components[0].NoDataValue = 88;
 }

 [Category(TestCategory.Jira)] //TOOLS-4258
 public void NoDataValuesOfFilteredFunction()
 {
     IFunction function = new Function();
     function.Components.Add(new Variable<int>());
     function.Arguments.Add(new Variable<int>());
     function[0] = 1;
     function[1] = 2;
     function[2] = 3;
     function.Components[0].NoDataValue = 79;
     var filtered = function.Filter(new VariableValueFilter<int>(function.Arguments[0], new[] { 0, 1 }));
     Assert.AreEqual(79, filtered.Components[0].NoDataValue);
 }

        public void ClearSourceFunctionShouldClearFilteredBindingList()
        {
            IFunction function = new Function
            {
                Arguments = { new Variable<int>("x")},
                Components = { new Variable<int>("f") }
            };

            function[1] = 1;
            function[2] = 4;

            var filteredFunction = function.Filter(new VariableValueFilter<int>(function.Arguments[0], new[] { 1 }));

            IFunctionBindingList functionBindingList = new FunctionBindingList { Function = filteredFunction };

            functionBindingList.Count
                .Should().Be.EqualTo(1);

            function.Clear();

            functionBindingList.Count
                .Should().Be.EqualTo(0);
        }

        public void Filtered2DFunction()
        {
            IFunction function = new Function
                                     {
                                         Arguments = { new Variable<int>("x"), new Variable<int>("y") },
                                         Components = {new Variable<int>("f")}
                                     };

            function[1, 1] = 1;
            function[1, 2] = 2;
            function[2, 1] = 3;
            function[2, 2] = 4;

            var filteredFunction = function.Filter(new VariableValueFilter<int>(function.Arguments[0], new[]{1}));

            IFunctionBindingList functionBindingList = new FunctionBindingList { Function = filteredFunction };

            functionBindingList.Count
                .Should().Be.EqualTo(2);
        }

        [Category(TestCategory.WorkInProgress)] //TOOLS-
        public void PropertyChangeBubbleCorerctlyForFilteredFunction()
        {
            IFunction function = new Function
            {
                Arguments = { new Variable<int>("x1"), new Variable<int>("x2") },
                Components = { new Variable<int>("f") }
            };

            function[0, 1] = new[] { 1 };
            function[0, 2] = new[] { 2 };
            function[1, 1] = new[] { 3 };
            function[1, 2] = new[] { 4 };

            var arg1 = function.Arguments[0];

            var filteredFunction = function.Filter(new VariableValueFilter<int>(arg1, 0), new VariableReduceFilter(arg1));

            int called = 0;

            ((INotifyPropertyChange)filteredFunction).PropertyChanged += (s, e) => called++;

            filteredFunction[0] = 3; //set value

            Assert.AreEqual(2, called); // Expect IsEditing is changed twice (true, false)
        }

        public void SetFunctionValuesUsingFilteredFunction()
        {
            IFunction function = new Function
            {
                Arguments = { new Variable<int>("x") },
                Components = { new Variable<int>("f1"), new Variable<int>("f2") }
            };

            function[1] = new[] { 1, 10 };
            function[2] = new[] { 2, 20 };

            var filteredFunction = function.Filter(new VariableValueFilter<int>(function.Arguments[0], new[] { 2 }));

            var f1ValueChangeCount = 0;
            filteredFunction.Components[0].ValuesChanged += delegate { f1ValueChangeCount++; };

            // replace value
            filteredFunction.Components[0].Values[0] = 3;

            function.Components[0].Values.Cast<int>()
                .Should().Have.SameSequenceAs(new[] {1, 3});

            function.Components[1].Values.Cast<int>()
                .Should().Have.SameSequenceAs(new[] { 10, 20 });

            f1ValueChangeCount
                .Should().Be.EqualTo(1);
        }

        public void FilteredFunctionStore()
        {
            IFunction function = new Function { Arguments = { new Variable<int>("x") }, Components = { new Variable<int>("y") } };

            function[1] = 1;
            function[2] = 2;

            var store = function.Store;
            
            var filteredFunction = function.Filter(new VariableValueFilter<int>(function.Arguments[0], new[] {2}));

            filteredFunction.Store
                .Should().Be.EqualTo(store);

            store.Functions.Count
                .Should("Filtered functions not added to store").Be.EqualTo(3);
        }

        public void EventShouldNotBubbleIfFunctionOutsideReducedFunctionIsRemoved()
        {
            int called = 0;
            IFunction function = new Function
            {
                Arguments = { new Variable<int>("x1"), 
                    new Variable<int>("x2") },
                Components = { new Variable<int>("f") }
            };

            function[0, 1] = new[] { 1 };
            function[0, 2] = new[] { 2 };
            function[1, 1] = new[] { 3 };
            function[1, 2] = new[] { 4 };

            var arg1 = function.Arguments[0];

            var filteredFunction = function.Filter(new VariableValueFilter<int>(arg1, 0), new VariableReduceFilter(arg1));

            filteredFunction.ValuesChanged += (s, e) => called++;

            function.Arguments[0].Values.Remove(1);
            Assert.AreEqual(0, called, "Removing unrelated argument value: should not fire events");
        }

        public void EventShouldNotBubbleIfReducedFunctionIsUnaffected()
        {
            int called = 0;
            IFunction function = new Function
            {
                Arguments = { new Variable<int>("x1"), 
                    new Variable<int>("x2") },
                Components = { new Variable<int>("f") }
            };

            function[0, 1] = new[] { 1 };
            function[0, 2] = new[] { 2 };
            function[1, 1] = new[] { 3 };
            function[1, 2] = new[] { 4 };

            var arg1 = function.Arguments[0];

            var filteredFunction = function.Filter(new VariableValueFilter<int>(arg1, 0), new VariableReduceFilter(arg1));
            
            filteredFunction.ValuesChanged += (s, e) => called++;

            called = 0;
            function[1, 1] = 55; //set value
            Assert.AreEqual(0, called, "Filtered function should be unaffected: should not fire events");

            called = 0;
            function[0, 1] = 3; //set value
            Assert.AreEqual(1, called, "Filtered function should be affected: should fire events");
        }