Ejemplo n.º 1
0
        /// <summary>
        /// Returns a deep copy of the receiverd
        ///
        /// <summary>
        /// <returns> a deep copy of the receiver.</returns>
        public override Object Clone()
        {
            // overridden for performance only.
            ShortArrayList clone = new ShortArrayList((short[])_elements.Clone());

            clone.SetSizeRaw(Size);
            return(clone);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Retains (keeps) only the elements in the receiver that are contained in the specified other list.
        /// In other words, removes from the receiver all of its elements that are not contained in the
        /// specified other listd
        /// <summary>
        /// <param name="other">the other list to test against.</param>
        /// <returns><code>true</code> if the receiver changed as a result of the call.</returns>
        public override Boolean RetainAll(AbstractShortList other)
        {
            // overridden for performance only.
            if (!(other is ShortArrayList))
            {
                return(base.RetainAll(other));
            }

            /* There are two possibilities to do the thing
             * a) use other.IndexOf(..d)
             * b) sort other, then use other.BinarySearch(..d)
             *
             * Let's try to figure out which one is fasterd Let M=Size, N=other.Size, then
             * a) takes O(M*N) steps
             * b) takes O(N*logN + M*logN) steps (sorting is O(N*logN) and binarySearch is O(logN))
             *
             * Hence, if N*logN + M*logN < M*N, we use b) otherwise we use a).
             */
            int limit       = other.Size - 1;
            int j           = 0;
            var theElements = _elements;
            int mySize      = Size;

            int N = (int)other.Size;
            int M = (int)mySize;

            if ((N + M) * Cern.Jet.Math.Arithmetic.Log2(N) < M * N)
            {
                // it is faster to sort other before searching in it
                ShortArrayList sortedList = (ShortArrayList)other.Clone();
                sortedList.QuickSort();

                for (int i = 0; i < mySize; i++)
                {
                    if (sortedList.BinarySearchFromTo(theElements[i], 0, limit) >= 0)
                    {
                        theElements[j++] = theElements[i];
                    }
                }
            }
            else
            {
                // it is faster to search in other without sorting
                for (int i = 0; i < mySize; i++)
                {
                    if (other.IndexOfFromTo(theElements[i], 0, limit) >= 0)
                    {
                        theElements[j++] = theElements[i];
                    }
                }
            }

            Boolean modified = (j != mySize);

            SetSize(j);
            return(modified);
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Returns a new list of the part of the receiver between <code>from</code>, inclusive, and <code>to</code>, inclusive.
        /// <summary>
        /// <param name="from">the index of the first element (inclusive).</param>
        /// <param name="to">the index of the last element (inclusive).</param>
        /// <returns>a new list</returns>
        /// <exception cref="IndexOutOfRangeException">index is out of range (<i>_size()&gt;0 && (from&lt;0 || from&gt;to || to&gt;=_size())</i>). </exception>
        public virtual AbstractShortList PartFromTo(int from, int to)
        {
            CheckRangeFromTo(from, to, _size);

            int Length = to - from + 1;
            var part   = new ShortArrayList(Length);

            part.AddAllOfFromTo(this, from, to);
            return(part);
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Returns a list which is a concatenation of <code>times</code> times the receiver.
        /// <summary>
        /// <param name="times">the number of times the receiver shall be copied.</param>
        public virtual AbstractShortList Times(int times)
        {
            AbstractShortList newList = new ShortArrayList(times * Size);

            for (int i = times; --i >= 0;)
            {
                newList.AddAllOfFromTo(this, 0, Size - 1);
            }
            return(newList);
        }
Ejemplo n.º 5
0
 /// <summary>
 /// Appends all elements of the specified list to the receiver.
 /// <summary>
 /// <param name="list">the list of which all elements shall be appended.</param>
 public virtual void AddAllOf(ShortArrayList other)
 {
     AddAllOfFromTo(other, 0, other.Size - 1);
 }