C# Function.Clone方法代码示例

        public void CloneShouldBeFast()
        {
            var f = new Function();
            IVariable<double> component = new Variable<double>();
            IVariable<double> x = new Variable<double>();
            IVariable<double> y = new Variable<double>();
            f.Components.Add(component);
            f.Arguments.Add(x);
            f.Arguments.Add(y);

            x.SetValues(new[] { 0.1, 0.2, 1, 2, 3, 4, 5, 6, 7 });
            y.SetValues(new[] { 0.1, 0.2, 1, 2, 3, 4, 5, 6, 7 });
            component.SetValues(new[] { 1.0 });

            var t = DateTime.Now; // measure time
            for (int i = 0; i < 1000; i++)
            {
                var f2 = f.Clone();
            }
            var cloneDt = DateTime.Now.Subtract(t).TotalMilliseconds;
            log.DebugFormat("Cloned 2d function 10000 times in {0} ms", cloneDt);
            Assert.Less(cloneDt, 700);
        }

        public void ClonedArgumentShouldNotChangeTheValueOfOriginalArgument()
        {
            var x = new Variable<int>("x");
            var y = new Variable<int>("y");
            var component = new Variable<int>("f");
            var f = new Function
                        {
                            Arguments = { x, y },
                            Components = { component }
                        };

            f[1, 10] = 100;
            f[2, 20] = 200;

            var clone = (IFunction)f.Clone();

            f[1, 10] = 199;
            f[2, 20] = 299;

            Assert.AreNotEqual(199, clone[1, 10]);
            Assert.AreNotEqual(299, clone[2, 20]);
        }

        public void CloneWithTargetStore()
        {
            var x = new Variable<int>("x");
            var y = new Variable<int>("y");

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

            f[1, 10] = 100;
            f[2, 20] = 200;

            var targetStore = new MemoryFunctionStore();
            targetStore = (MemoryFunctionStore) f.Store;

            var clonedFunction = (IFunction)function.Clone();//(targetStore);

            // assserts
            //clonedFunction.Store
            //    .Should().Be.EqualTo(targetStore);

            targetStore.Functions.Count
                .Should("function in the new store should be: function, f, x, y").Be.EqualTo(4);

            clonedFunction.Components.Count
                .Should("1 component: f").Be.EqualTo(1);
            clonedFunction.Arguments.Count
                .Should("2 arguments: x, y").Be.EqualTo(2);
            
            var clonedX = (IVariable<int>)clonedFunction.Arguments[0];
            var clonedY = (IVariable<int>)clonedFunction.Arguments[1];
            var clonedF = (IVariable<int>)clonedFunction.Components[0];

            clonedX.Values
                .Should("values of cloned x").Have.SameSequenceAs(new[] { 1, 2 });
            
            clonedY.Values
                .Should("values of cloned y").Have.SameSequenceAs(new[] { 10, 20 });
            
            clonedF.Values
                .Should("values of cloned f component").Have.SameSequenceAs(new[] { 100, 0, 0, 200 });
        }

        public void CloneFuntionWithTwoVariablesWhereTheClonedVariablesShouldHaveSameStore()
        {
            IVariable<double> x = new Variable<double>("x");
            IVariable<double> x2 = new Variable<double>("x2");
            IVariable<double> y = new Variable<double>("y");

            IFunction f = new Function
                              {
                                  Arguments = { x,x2 },
                                  Components = { y }
                              };

            var clone = (IFunction)f.Clone();

            Assert.AreEqual(4, f.Store.Functions.Count);
            Assert.AreEqual(4, clone.Store.Functions.Count);
            Assert.AreEqual(4, clone.Arguments[0].Store.Functions.Count);

            Assert.AreNotSame(f.Store,clone.Store);
            Assert.AreSame(clone.Arguments[0].Store, clone.Components[0].Store);
            Assert.AreSame(clone.Arguments[0].Store, clone.Arguments[1].Store);

        }

        public void CloneWith2Arguments()
        {
            var x = new Variable<int>("x");
            var y = new Variable<int>("y");
            var component = new Variable<int>("f");
            var f = new Function
                        {
                            Arguments = {x, y},
                            Components = {component}
                        };

            f[1, 10] = 100;
            f[2, 20] = 200;

            var clone = (IFunction) f.Clone();

            Assert.AreEqual(f.Name, clone.Name);
            Assert.AreEqual(f.Arguments.Count, clone.Arguments.Count);
            Assert.AreEqual(f.Components.Count, clone.Components.Count);

            var clonedX = (IVariable<int>) clone.Arguments[0];
            var clonedY = (IVariable<int>) clone.Arguments[1];

            Assert.AreEqual(x.Values.Count, clonedX.Values.Count);
            Assert.AreEqual(y.Values.Count, clonedY.Values.Count);
            Assert.AreEqual(component.Values.Count, component.Values.Count);
        }

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

            IFunction f = new Function { Arguments = {x}, Components = {y} };

            f[10.0] = 100.0;
            f[20.0] = 200.0;
            f[30.0] = 300.0;

            var clone = (IFunction) f.Clone();

            Assert.AreEqual(f.Name, clone.Name);
            Assert.AreEqual(f.Arguments.Count, clone.Arguments.Count);
            Assert.AreEqual(f.Components.Count, clone.Components.Count);

            var clonedValues = clone.GetValues();
            var expectedValues = f.GetValues();
            Assert.AreEqual(expectedValues, clonedValues, "values must be cloned");
        }

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

            IFunction f = new Function { Arguments = { x }, Components = { y } };

            var fileBasedStore = mocks.Stub<IMockFileBasedFunctionStore>();
            fileBasedStore.Functions = new EventedList<IFunction> { f, x, y };

            using (mocks.Record())
            {
                fileBasedStore.Expect(s => s.Clone()).Return(fileBasedStore); // assert, clone should be called

                fileBasedStore.FunctionValuesChanged += null;
                LastCall.Constraints(Is.NotNull()).Repeat.Any();

                fileBasedStore.FunctionValuesChanging += null;
                LastCall.Constraints(Is.NotNull()).Repeat.Any();
            }

            using (mocks.Playback())
            {
                f.Store = fileBasedStore;
                f.Clone();
            }
        }

        public void InsertAtForClonedFunction()
        {
            var x = new Variable<int>("x");
            var y = new Variable<int>("y");

            var f = new Function { Arguments = { x }, Components = { y } };

            f[1] = 1;
            f[5] = 5;
            f[10] = 10;
            f[15] = 15;

            var clone = (IFunction) f.Clone();
            clone.Arguments[0].Values.InsertAt(0,4);

            //clone.Arguments[0].Values.InsertAt(0, 4);
            Assert.AreEqual(5,clone.Components[0].Values.Count);
        }

        public void CloneWithoutValues()
        {
            var x = new Variable<int>("x") { Values = { 1, 2, 3 } };
            var y = new Variable<double>("y") { Values = { 1, 2, 3 } };
            var f = new Function("f") { Arguments = { x }, Components = { y } };
            
            var clone = (IFunction) f.Clone(false);

            Assert.AreEqual(1, clone.Arguments.Count);
            Assert.AreEqual(1, clone.Components.Count);
            Assert.IsTrue(clone is Function);
            Assert.IsTrue(clone.Arguments[0] is IVariable<int>);
            Assert.IsTrue(clone.Components[0] is IVariable<double>);

            var store = clone.Store;
            Assert.AreEqual(store, clone.Arguments[0].Store);
            Assert.AreEqual(store, clone.Components[0].Store);
            
            Assert.AreEqual(0, clone.Arguments[0].Values.Count);
        }

        public void CloneTwoComponentsFunctionAndAddValues()
        {
            IVariable x = new Variable<double>("x");
            IVariable l = new Variable<double>("left");
            IVariable r = new Variable<double>("right");

            IFunction f = new Function();
            f.Arguments.Add(x);
            f.Components.Add(l);
            f.Components.Add(r);

            f[0.0] = new[] {10.0,3.0 };
            f[1.0] = new[] { 20.0, 6.0 };

            var clone = (IFunction)f.Clone();

            clone[2.0] = new[] { 30.0, 9.0 };

            Assert.AreEqual(3,clone.Arguments[0].Values.Count);
        }

        public void CloneShouldRetainDefaultValueBehaviour()
        {
            IVariable<double> x = new Variable<double>("x");
            IVariable<double> y = new Variable<double>("y") {DefaultValue = 1.23};

            IFunction f = new Function { Arguments = { x }, Components = { y } };
            var clone = (IFunction) f.Clone();

            Assert.AreEqual(1.23, (double)f.Components[0].DefaultValue, 1.0e-6);
            Assert.AreEqual(1.23, (double)f.Components[0].Values.DefaultValue, 1.0e-6);

            Assert.AreEqual(1.23, (double)clone.Components[0].DefaultValue, 1.0e-6);
            Assert.AreEqual(1.23, (double)clone.Components[0].Values.DefaultValue, 1.0e-6);

            f.Arguments[0].AddValues(new[] {100.0});
            Assert.AreEqual(1.23, (double)f[100.0], 1.0e-6);

            clone.Arguments[0].AddValues(new[] {100.0});
            // next line fails if clone.Components[0].Values.DefaultValue is incorrect
            Assert.AreEqual(1.23, (double)clone[100.0], 1.0e-6);
        }

        public void CloneShouldBeFast()
        {
            var f = new Function { Name = "f" };
            IVariable<double> component = new Variable<double> { Name = "component" };
            IVariable<double> x = new Variable<double> { Name = "x" };
            IVariable<double> y = new Variable<double> { Name = "y"};
            f.Components.Add(component);
            f.Arguments.Add(x);
            f.Arguments.Add(y);

            x.SetValues(new[] { 0.1, 0.2, 1, 2, 3, 4, 5, 6, 7 });
            y.SetValues(new[] { 0.1, 0.2, 1, 2, 3, 4, 5, 6, 7 });
            component.SetValues(new[] { 1.0 });

            Action action = delegate
                                {
                                    for (int i = 0; i < 1000; i++)
                                    {
                                        var f2 = f.Clone();
                                    }
                                };

            TestHelper.AssertIsFasterThan(840, action);
        }