C# MultiDimensionalArray.InsertAt方法代码示例

        public void InsertAt_3D()
        {
            IMultiDimensionalArray array = new MultiDimensionalArray(2, 2, 2);
            array[0, 0, 0] = 1;
            array[0, 0, 1] = 5;
            array[0, 1, 0] = 2;
            array[0, 1, 1] = 6;
            array[1, 0, 0] = 3;
            array[1, 0, 1] = 7;
            array[1, 1, 0] = 4;
            array[1, 1, 1] = 8;
            /*
             {
               {{1, 5}{2, 6}}
               {{3, 7}{4, 8}}
             }
             */

            Assert.IsTrue(array.Shape.SequenceEqual(new[] { 2, 2, 2 }));
            Assert.IsTrue(array.Stride.SequenceEqual(new[] { 4, 2, 1 }));

            array.InsertAt(2, 0);
            /*
             {
               {{<null>, 1, 5}{<null>, 2, 6}}
               {{<null>, 3, 7}{<null>, 4, 8}}
             }
             */

            Assert.IsTrue(array.Shape.SequenceEqual(new[] { 2, 2, 3 }));
            Assert.IsTrue(array.Stride.SequenceEqual(new[] { 6, 3, 1 }));

            array.InsertAt(2, 3);
            /*
             {
               {{<null>, 1, 5, <null>}{<null>, 2, 6, <null>}}
               {{<null>, 3, 7, <null>}{<null>, 4, 8, <null>}}
             }
             */

            Assert.IsTrue(array.Shape.SequenceEqual(new[] { 2, 2, 4 }));
            Assert.IsTrue(array.Stride.SequenceEqual(new[] { 8, 4, 1 }));
        }

        public void InsertAtRemoveAt()
        {
            IMultiDimensionalArray array = new MultiDimensionalArray();
            array.Resize(2, 2);
            array[0, 0] = 5;
            array[1, 1] = 2;

            array.InsertAt(0, 2);
            log.Info(array.ToString());
            array.RemoveAt(0, 2);
            log.Info(array.ToString());
            array.InsertAt(0, 2);
            log.Info(array.ToString());
            array.RemoveAt(0, 2);
            log.Info(array.ToString());
        }

        public void InsertAndRemoveOneDimensionalArray()
        {
            //{ 1, 3, 4} --> {1, 2, 3, 4}
            IMultiDimensionalArray array = new MultiDimensionalArray(3);
            array[0] = 1;
            array[1] = 3;
            array[2] = 4;

            //insert our new item
            array.InsertAt(0, 1);
            array[1] = 2;
            //TODO : find a nicer way for these asserts.
            Assert.AreEqual(1, array[0]);
            Assert.AreEqual(2, array[1]);
            Assert.AreEqual(3, array[2]);
            Assert.AreEqual(4, array[3]);

            // {1,2,3,4} --> {1,4}
            array.RemoveAt(0, 1, 2);
            Assert.AreEqual(1, array[0]);
            Assert.AreEqual(4, array[1]);
            Assert.AreEqual(2, array.Count);
        }

        public void InsertAt()
        {
            // 1 2
            // 5 6 
            IMultiDimensionalArray array = new MultiDimensionalArray(2, 2);
            array[0, 0] = 1;
            array[0, 1] = 2;
            array[1, 0] = 5;
            array[1, 1] = 6;
            Assert.IsTrue(array.Shape.SequenceEqual(new[] { 2, 2 }));
            Assert.IsTrue(array.Stride.SequenceEqual(new[] { 2, 1 }));

            //insert a row between the other rows
            array.InsertAt(0, 1);
            array[1, 0] = 3;
            array[1, 1] = 4;
            //now should have the following
            // 1 2
            // 3 4
            // 5 6
            Assert.IsTrue(array.Shape.SequenceEqual(new[] { 3, 2 }));
            Assert.IsTrue(array.Stride.SequenceEqual(new[] { 2, 1 }));
            Assert.AreEqual(2, array[0, 1]);
            Assert.AreEqual(3, array[1, 0]);
            Assert.AreEqual(4, array[1, 1]);
            Assert.AreEqual(6, array[2, 1]);

            //now insert two empty columns like this
            // - - 1 2
            // - - 3 4
            // - - 5 6 
            array.InsertAt(1, 0, 2);
            Assert.IsTrue(array.Shape.SequenceEqual(new[] { 3, 4 }));
            Assert.IsTrue(array.Stride.SequenceEqual(new[] { 4, 1 }));
            Assert.AreEqual(null, array[0, 0]);
            Assert.AreEqual(null, array[0, 1]);
            Assert.AreEqual(1, array[0, 2]);
            Assert.AreEqual(2, array[0, 3]);
        }

        public void BubblePropertyChangesOfInsertedObject()
        {
            var testNotifyPropertyChangedObject = new TestNotifyPropertyChangedObject();

            IMultiDimensionalArray<TestNotifyPropertyChangedObject> array = new MultiDimensionalArray<TestNotifyPropertyChangedObject>
                                                                                {
                                                                                    IsAutoSorted = false
                                                                                };
            array.Add(new TestNotifyPropertyChangedObject());

            array.InsertAt(0, 0, 1, new[] { testNotifyPropertyChangedObject });

            TestHelper.AssertPropertyChangedIsFired((INotifyPropertyChanged)array, 1, testNotifyPropertyChangedObject.FireChanged);
        }

 [NUnit.Framework.Category(TestCategory.WorkInProgress)] //not required yet?
 public void InsertOneRowInEmptyMatrix()
 {
     IMultiDimensionalArray array = new MultiDimensionalArray(2,2);
     array.Clear();
     array.Resize(2,2);
     array.InsertAt(0, 0, 2, new List<double> { 1.0, 2.0 });
     Assert.AreEqual(array[0, 0], 1.0);
     Assert.AreEqual(array[1, 0], 2.0);
 }

        public void InsertAtGivesAggregatedCollectionChangedEvent()
        {
            var array = new MultiDimensionalArray<double>(new[] { 2, 2 });

            var callCount = 0;
            array.CollectionChanged += (s, e) =>
            {
                callCount++;
                var args = (MultiDimensionalArrayChangingEventArgs)e;
                Assert.AreEqual(NotifyCollectionChangeAction.Add, args.Action);
                Assert.AreEqual(new[] { 0, 0 }, args.MultiDimensionalIndex);
                Assert.AreEqual(new[] { 3, 2 }, args.Shape);
                //inserted a 3x2 block
                Assert.AreEqual(new[] { 1, 2, 3, 4, 5, 6 }, args.Items);
            };

            //insert 2 slices on the first dimension
            array.InsertAt(0, 0, 3, new object[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 });

            Assert.AreEqual(1, callCount);
        }

        public void ThrowExceptionIfInsertedValuesCountIsIncorrect()
        {
            //array of 4x3
            var array = new MultiDimensionalArray<double>(new[] {4, 3});

            //insert 2 slices of dim1 ...expected 2*3 = 6 values insert 2 should give exception
            array.InsertAt(0, 0, 2, new object[] {1.0, 2.0});
        }

 public void InsertAtWithValuesInTheMiddle()
 {
     var array = new MultiDimensionalArray<int>(new[] {3});
     array[0] = 0;
     array[1] = 4;
     array[2] = 5;
     array.InsertAt(0, 1, 3, new object[] {1, 2, 3});
     Assert.AreEqual(new[] {6}, array.Shape);
     Assert.AreEqual(new[] {0, 1, 2, 3, 4,5}, array);
 }

 public void InsertAtWithValuesAtTheEnd()
 {
     var array = new MultiDimensionalArray<int>(new[] {1});
     array[0] = 4;
     array.InsertAt(0, 1, 3, new object[] {1, 2, 3});
     Assert.AreEqual(new[] {4}, array.Shape);
     Assert.AreEqual(new[] {4, 1, 2, 3}, array);
 }

 public void ReadOnlyInsertAt2Args()
 {
     var array = new MultiDimensionalArray(true, false, 1, new[] { 1 }, new[] { 1 });
     array.InsertAt(0, 0,1);
 }

        [NUnit.Framework.Category(TestCategory.BadQuality)] // TODO: split this test in two tests measuring actual time and use TestHelper.AssertIsFasterThan()
        public void InsertAtOnFirstDimensionShouldPerformLinearly()
        {
            //TODO: move this test back to MDAT...only here to use functionview..

            // TODO: split this test in two tests measuring actual time and use TestHelper.AssertIsFasterThan()

            int secondDimensionSize = 500;
            var array = new MultiDimensionalArray(new[] { 0, secondDimensionSize });
            int collectionChangedCount = 0;
            array.CollectionChanged += (s, e) =>
            {
                collectionChangedCount++;
            };
            var perfSeries = new Function { Arguments = { new Variable<int> { Name = "values added" } }, Components = { new Variable<double> { Name = "total ticks" } } };

            var startTime = DateTime.Now;
            int slicesToAdd = 20000;
            for (int i = 0; i < slicesToAdd; i++)
            {
                array.InsertAt(0, i);
                if ((i % 1000) == 0)
                {
                    perfSeries[i] = (DateTime.Now - startTime).TotalMilliseconds;
                }
            }
            //one collection change per slice
            Assert.AreEqual(slicesToAdd, collectionChangedCount);
            //check the numberslice/elapsed is just about constant..
            var ratios = new List<double>();
            for (int i = 0; i < perfSeries.Arguments[0].Values.Count; i++)
            {
                ratios.Add(((double)perfSeries.Components[0].Values[i]) / (int)perfSeries.Arguments[0].Values[i]);
            }
            //check the ratios are 'about' the same 'everywhere'..get this formalized in a testhelper or something..
            Assert.AreEqual(ratios[5], ratios[9], 0.05);
            Assert.AreEqual(ratios[12], ratios[9], 0.05);
            Assert.AreEqual(ratios[12], ratios[4], 0.05);
            // to see it move this test to functionviewtest and uncomment
            //var functionView = new FunctionView { Data = perfSeries };
            //WindowsFormsTestHelper.ShowModal(functionView);
        }

        public void ReduceBeforeAddingValuesAndGetValuesAfterwards()
        {
            var array = new MultiDimensionalArray(3, 3);
            for (int i = 0; i < 3; i++)
                for (int j = 0; j < 3; j++)
                    array[i, j] = i * 3 + j;
            var subArray = new MultiDimensionalArrayView(array);

            subArray.SelectedIndexes[0] = new int[] { 3 }; //set non-existent index
            subArray.Reduce[0] = true; //try to reduce the first dimension

            //we can't get any values
            subArray.Count.Should("Count should be 0").Be.EqualTo(0);
            foreach(var value in subArray)
                throw new ExpectationViolationException("Shouldn't return any values");
            
            //add the index the view is looking for
            array.InsertAt(0,3);
            array[3, 0] = 9;
            array[3, 1] = 10;
            array[3, 2] = 11;

            //and now we can get values
            subArray.Count.Should("Count should be 3").Be.EqualTo(3);
            int actualCount = subArray.Cast<object>().Count();
            actualCount.Should("Actual count should be 3").Be.EqualTo(3);
        }