public void Sort(int[][] array, IComparer comparer)
 {
     if (comparer == null || array == null)
         throw new ArgumentNullException("Arguments can't be null.");
     
     QuickSort(array, 0, array.GetLength(0) - 1, comparer.Compare);
 }
示例#2
0
    /// <summary>
    /// A simple bubble sort for two arrays, limited to some region of the arrays.
    /// This is a regular bubble sort, nothing fancy.
    /// </summary>
    public static void SimpleSort(Array array, Array items, int startingIndex, int length, IComparer comparer)
    {
        bool finished = false;
        while (!finished)
        {
            bool swapped = false;
            for (int g = startingIndex; g < startingIndex + length - 1; g++)
            {
                Object first = array.GetValue(g);
                Object second = array.GetValue(g + 1);
                int comparison = comparer.Compare(first, second);
                if (comparison == 1)
                {
                    Swap(g, g + 1, array, items);
                    swapped = true;

                    first = array.GetValue(g);
                    second = array.GetValue(g + 1);
                }
            }
            if (!swapped)
            {
                finished = true;
            }
        }
    }
 /// <summary>
 /// Creates a new instance of the <see cref="ListViewTextColumnComparer"/> class
 /// with the specified string comparer.
 /// </summary>
 /// <param name="stringComparer">The string comparer used to compare the item texts.</param>
 public ListViewTextColumnComparer(IComparer<string> stringComparer)
 {
     if (stringComparer == null) {
         throw new ArgumentNullException("stringComparer");
     }
     this.stringComparer = stringComparer;
 }
示例#4
0
 public SortedList()
 {
     this.keys = emptyArray;
     this.values = emptyArray;
     this._size = 0;
     this.comparer = new Comparer(CultureInfo.CurrentCulture);
 }
示例#5
0
 public void Sort(
     int index,
     int count,
     IComparer comparer)
 {
     theList.Sort(index, count, comparer);
 }
示例#6
0
        public Index(File file, string name, BiosParameterBlock bpb, UpperCase upCase)
        {
            _file = file;
            _name = name;
            _bpb = bpb;
            _isFileIndex = name == "$I30";

            _blockCache = new ObjectCache<long, IndexBlock>();

            _root = _file.GetStream(AttributeType.IndexRoot, _name).GetContent<IndexRoot>();
            _comparer = _root.GetCollator(upCase);

            using (Stream s = _file.OpenStream(AttributeType.IndexRoot, _name, FileAccess.Read))
            {
                byte[] buffer = Utilities.ReadFully(s, (int)s.Length);
                _rootNode = new IndexNode(WriteRootNodeToDisk, 0, this, true, buffer, IndexRoot.HeaderOffset);

                // Give the attribute some room to breathe, so long as it doesn't squeeze others out
                // BROKEN, BROKEN, BROKEN - how to figure this out?  Query at the point of adding entries to the root node?
                _rootNode.TotalSpaceAvailable += _file.MftRecordFreeSpace(AttributeType.IndexRoot, _name) - 100;
            }

            if (_file.StreamExists(AttributeType.IndexAllocation, _name))
            {
                _indexStream = _file.OpenStream(AttributeType.IndexAllocation, _name, FileAccess.ReadWrite);
            }

            if (_file.StreamExists(AttributeType.Bitmap, _name))
            {
                _indexBitmap = new Bitmap(_file.OpenStream(AttributeType.Bitmap, _name, FileAccess.ReadWrite), long.MaxValue);
            }
        }
示例#7
0
        /// <summary>
        /// Rearranges the array in ascending order, using the natural order.
        /// </summary>
        /// <param name="a">a the array to be sorted</param>
        public static void Sort(IComparable[] a, IComparer c = null)
        {
            //make sure we have the comparer passed by argument or create default
            IComparer comparer = c ?? Comparer<object>.Default;

            int N = a.Length;

            int h = 1;

            //3*x +1 -> 1, 4, 13, 40, 121, 364, ..
            while (h < N / 3)
            {
                h = 3 * h + 1;
            }

            while (h >= 1)
            {

                //h- sort array
                for (int i = h; i < N; i++)
                {
                    for (int j = i; j >= h && less(comparer, a[j], a[j - h]); j -= h)
                    {
                        exch(a, j, j - h);
                    }
                }

                Debug.Assert(isHsorted(a, comparer, h));
                h = h / 3;
            }

            Debug.Assert(isSorted(a, comparer));
        }
示例#8
0
 /// <summary>
 /// 初始化服务容器
 /// </summary>
 /// <param name="serviceName"> 服务约定名称 </param>
 /// <param name="serviceType"> 服务约定基类或接口类型 </param>
 /// <param name="typeComparer"> 比较2个类型服务的优先级 </param>
 /// <param name="logger"> 日志记录器 </param>
 /// <exception cref="ArgumentNullException">
 /// <paramref name="serviceName" /> and <paramref name="serviceType" /> is all
 /// <see langword="null" />.
 /// </exception>
 /// <exception cref="OverflowException"> 匹配插件数量超过字典的最大容量 (<see cref="F:System.Int32.MaxValue" />)。 </exception>
 protected ServiceContainer(string serviceName, Type serviceType, IComparer<Type> typeComparer, TraceSource logger = null)
 {
     TypeComparer = typeComparer;
     _logger = logger ?? LogServices.Logger;
     _items = new ConcurrentDictionary<Type, ServiceItem>();
     _logger?.Write(TraceEventType.Start, $"开始扫描服务插件 serviceName={serviceName},serviceType={serviceType}");
     foreach (var p in MEF.PlugIns.GetPlugIns(serviceName, serviceType).OrderByDescending(p => p.Priority))
     {
         var value = p.GetValue(serviceType);
         if (value == null)
         {
             continue;
         }
         var type = GetServiceType(p, value);
         if (type == null)
         {
             continue;
         }
         var item = new ServiceItem(this, type, value, p);
         item.MakeSystem(); //默认为系统插件
         if (_items.TryAdd(type, item) == false)
         {
             _logger?.Write(TraceEventType.Verbose, $"服务插件({value.GetType().FullName})因优先级({p.Priority})过低被抛弃");
         }
         else
         {
             _logger?.Write(TraceEventType.Verbose, $"服务插件({value.GetType().FullName}),优先级({p.Priority})装载完成");
         }
     }
     _logger?.Write(TraceEventType.Stop, $"服务插件装载完成,有效服务 {Count} 个");
 }
示例#9
0
 public override void AddSort(object expr, IComparer comparer)
 {
     // sort makes sense only when we are dealing with a query that
     // returns a nodeset.
     Query evalExpr;
     string query = expr as string;
     if (query != null)
     {
         evalExpr = new QueryBuilder().Build(query, out _needContext); // this will throw if expr is invalid
     }
     else
     {
         CompiledXpathExpr xpathExpr = expr as CompiledXpathExpr;
         if (xpathExpr != null)
         {
             evalExpr = xpathExpr.QueryTree;
         }
         else
         {
             throw XPathException.Create(SR.Xp_BadQueryObject);
         }
     }
     SortQuery sortQuery = _query as SortQuery;
     if (sortQuery == null)
     {
         _query = sortQuery = new SortQuery(_query);
     }
     sortQuery.AddSort(evalExpr, comparer);
 }
示例#10
0
        // Helper method for sorting an ArrayList.  If the comparer is a SortFieldComparer,
        // use the cached-value approach to avoid excessive reflection.  For other 
        // comparers, sort the usual way
        internal static void SortHelper(ArrayList al, IComparer comparer)
        {
            SortFieldComparer sfc = comparer as SortFieldComparer; 
            if (sfc == null)
            { 
                // sort the usual way 
                al.Sort(comparer);
            } 
            else
            {
                // Sort with cached values.
                // Step 1.  Copy the items into a list augmented with slots for 
                // the cached values.
                int n = al.Count; 
                int nFields = sfc._fields.Length; 
                CachedValueItem[] list = new CachedValueItem[n];
                for (int i=0; i<n; ++i) 
                {
                    list[i].Initialize(al[i], nFields);
                }
 
                // Step 2. Sort the augmented list.  The SortFieldComparer will
                // fill in the slots as necessary to perform its comparisons. 
                Array.Sort(list, sfc); 

                // Step 3. Copy the items back into the original list, now in 
                // sorted order
                for (int i=0; i<n; ++i)
                {
                    al[i] = list[i].OriginalItem; 
                }
            } 
        } 
示例#11
0
		public ListDictionary ()
		{
			count = 0;
			version = 0;
			comparer = null;
			head = null;
		}
        public ListViewColumnSorter()
        {
            SortColumn = 0;
            SortOrder = SortOrder.Ascending;

            mComparer = new CaseInsensitiveComparer();
        }
        public ListViewColumnSorter(IComparer comparer)
        {
            SortColumn = 0;
            SortOrder = SortOrder.Ascending;

            mComparer = comparer;
        }
示例#14
0
		/// <summary>
		/// Initializes a new instance of the SorterBase class with the specified 
		/// TableModel, Column index, IComparer and SortOrder
		/// </summary>
		/// <param name="tableModel">The TableModel that contains the data to be sorted</param>
		/// <param name="column">The index of the Column to be sorted</param>
		/// <param name="comparer">The IComparer used to sort the Column's Cells</param>
		/// <param name="sortOrder">Specifies how the Column is to be sorted</param>
		public SorterBase(TableModel tableModel, int column, IComparer comparer, SortOrder sortOrder)
		{
			this.tableModel = tableModel;
			this.column = column;
			this.comparer = comparer;
			this.sortOrder = sortOrder;
		}
示例#15
0
 public AdaptiveGridArchive(int maxSize, int bisections, int objectives)
     : base(maxSize)
 {
     _maxSize = maxSize;
     _dominance = new DominanceComparator();
     Grid = new AdaptiveGrid(bisections, objectives);
 }
示例#16
0
 /// <summary>
 /// Suspends sorting until ResumeSorting is called. Does so by clearing the ListViewItemSorter property.
 /// </summary>
 public void SuspendSorting() {
     if( suspendSortDepth == 0 ) {
         suspendedComparer = this.ListViewItemSorter;
         this.ListViewItemSorter = null;
     }
     suspendSortDepth++;
 }
 public StockMessageFactory(IStockRepository repoA, IStockRepository repoB, IComparer<Stock> comparer, char userInput)
 {
     _repoA = repoA;
     _repoB = repoB;
     _comparer = comparer;
     _userInput = userInput;
 }
    void GroundCheck()
    {
        Ray ray = new Ray(transform.position + Vector3.up * .1f, -Vector3.up);

        RaycastHit[] hits = Physics.RaycastAll(ray, .1f);
        rayHitComparer = new RayHitComparer();
        System.Array.Sort(hits, rayHitComparer);

        if (velocity.y < jumpPower * .5f)
        {
            onGround = false;
            rigidBody.useGravity = true;

            foreach (var hit in hits)
            {
                if (!hit.collider.isTrigger)
                {
                    if (velocity.y <= 0)
                    {
                          rigidBody.position = Vector3.MoveTowards(rigidBody.position, hit.point, Time.deltaTime * 100);
                    }

                    onGround = true;
                    rigidBody.useGravity = false;
                }
            }
        }
    }
示例#19
0
        public SurvivedTextTreeCreator(IComparer<string> comparer)
        {
            if (comparer == null)
                throw new ArgumentNullException();

            Comparer = comparer;
        }
示例#20
0
 /// <summary>
 /// The basic constructor does a quicksort using the built in comparer and swapper
 /// </summary>
 /// <param name="array">The array to sort.</param>
 public static void QuickSort(ArrayList array)
 {
     Sort s=new Sort();
     Sort.comparer=s;
     Sort.swapper=s;
     QuickSort(array, 0, array.Count-1);
 }
示例#21
0
        private static bool AreCollectionsEqual(ICollection expected, ICollection actual, IComparer comparer, ref string reason)
        {
            Assert.CheckParameterNotNull(comparer, "Assert.AreCollectionsEqual", "comparer", string.Empty, new object[0]);

            if (!object.ReferenceEquals(expected, actual))
            {
                if ((expected == null) || (actual == null))
                {
                    return false;
                }
                if (expected.Count != actual.Count)
                {
                    reason = (string)TestingResources.NumberOfElementsDiff;
                    return false;
                }
                IEnumerator enumerator = expected.GetEnumerator();
                IEnumerator enumerator2 = actual.GetEnumerator();
                for (int i = 0; enumerator.MoveNext() && enumerator2.MoveNext(); i++)
                {
                    if (0 != comparer.Compare(enumerator.Current, enumerator2.Current))
                    {
                        reason = (string)TestingResources.ElementsAtIndexDontMatch(i);
                        return false;
                    }
                }
                reason = (string)TestingResources.BothCollectionsSameElements;
                return true;
            }
            reason = (string)TestingResources.BothCollectionsSameReference(string.Empty);
            return true;
        }
示例#22
0
文件: SetOp.cs 项目: GodLesZ/svn-dump
		private SetOp() { } // disable construction

		/// <summary>
		/// Computes union of two sorted sequences.
		/// </summary>
		/// <remarks>
		/// <para>Both set1 and set2 must be sorted in ascending order with respect to comparer.</para>
		/// <para>Union contains elements present in one or both ranges.</para>
		/// <para>Result is written to the output iterator one member at a time</para>
		/// 
		/// <para>Union differs from <see cref="Merge">Merge</see> for multisets.</para>
		/// 
		/// <para>If k equal elements are present in set1 and m elements equal to those k
		/// are present in set2,then k elements from set1 are included in the output, 
		/// followed by max(m-k, 0) elements from set2. The total of max(k,m) are
		/// added to the output. If you'd like to have m+k elements, use Merge function.
		/// </para>
		/// <para>Complexity: linear on combined number of items in both sequences</para>
		/// </remarks>
		/// <example>
		/// <para>set1 = { "a", "test", "Test", "z" }</para>
		/// <para>set2 = { "b", "tEst", "teSt", "TEST", "Z" }</para>
		/// <para>comparer is a case-insensitive comparer</para>
		/// <para>The following elements will be added to output:
		/// {"a", "b", "test", "Test", "TEST", "z" }</para>
		/// </example>
		public static void Union(IEnumerable set1, IEnumerable set2, IComparer comparer, IOutputIterator output) {
			IEnumerator enum1 = set1.GetEnumerator();
			IEnumerator enum2 = set2.GetEnumerator();

			bool have1 = enum1.MoveNext();
			bool have2 = enum2.MoveNext();

			while (have1 && have2) {
				int compare = comparer.Compare(enum1.Current, enum2.Current);

				if (compare < 0) {
					output.Add(enum1.Current);
					have1 = enum1.MoveNext();
				} else if (compare > 0) {
					output.Add(enum2.Current);
					have2 = enum2.MoveNext();
				} else {
					output.Add(enum1.Current);
					have1 = enum1.MoveNext();
					have2 = enum2.MoveNext();
				}
			}

			while (have1) {
				output.Add(enum1.Current);
				have1 = enum1.MoveNext();
			}

			while (have2) {
				output.Add(enum2.Current);
				have2 = enum2.MoveNext();
			}
		}
 // Methods
 public LastWriteTimeComparator(bool bAscending, IComparer subComparer)
 {
     this._IsAscending = true;
     this._InnerComparer = null;
     this.IsAscending = bAscending;
     this.InnerComparer = subComparer;
 }
 public void TreeWithPointProvider(CustomPoint[] point, CustomPoint[] resultPoint, IComparer<CustomPoint> comparer)
 {
     var tree = new BinaryTree<CustomPoint>(point, comparer);
     var pointCompare = new PointComparer();
     var enumeratorBook = tree.Preorder().ToArray();
     CollectionAssert.AreEqual(enumeratorBook, resultPoint, pointCompare);
 }
示例#25
0
 public static PersistentTreeSet create(IComparer comp, ISeq init)
 {
     PersistentTreeSet ret = new PersistentTreeSet(null, new PersistentTreeMap(null, comp));
     for (ISeq s = init; s != null; s = s.next())
         ret = (PersistentTreeSet)ret.cons(s.first());
     return ret;
 }
    /// <summary>
    /// Check if the player is in collision with the ground
    /// </summary>
    void GroundCheck()
    {
        Ray ray = new Ray (transform.position + Vector3.up * .1f, -Vector3.up);

        RaycastHit[] hits = Physics.RaycastAll (ray, .1f);
        rayHitComparer = new RayHitComparer ();
        System.Array.Sort (hits, rayHitComparer);

        if (this.GetComponent<Rigidbody> ().velocity.y < jumpForce * .5f) {
            grounded = false;
            this.GetComponent<Rigidbody> ().useGravity = true;

            foreach (var hit in hits) {
                if (!hit.collider.isTrigger) {
                    if (this.GetComponent<Rigidbody> ().velocity.y <= 0) {
                        //this.GetComponent<Rigidbody> ().position = Vector3.MoveTowards (this.GetComponent<Rigidbody> ().position, hit.point, Time.deltaTime * 100);
                    }
                    candoubleJump = true;
                    grounded = true;
                    this.GetComponent<Rigidbody> ().useGravity = false;
                }
            }
        } else {
            grounded = false;
            this.GetComponent<Rigidbody> ().useGravity = true;
        }
    }
示例#27
0
 //==========================================================================================
 // Constructors
 //==========================================================================================
 /// <summary>
 /// Initializes a new instance of the <see cref="SortedCollection"/> class.
 /// </summary>
 /// <param name="comparer">An <see cref="IComparer"/> to use for the sorting.</param>
 protected SortedCollection(IComparer comparer)
     : base(new ArrayList())
 {
     Tracer.VerifyNonNullArgument(comparer, "comparer");
     this.comparer = comparer;
     this.list = (ArrayList)this.InnerCollection;
 }
 /// <summary>
 /// Creates a new iterator, buffering entries from the specified iterator </summary>
 public BufferedInputIterator(IInputIterator source)
 {
     BytesRef spare;
     int freqIndex = 0;
     hasPayloads = source.HasPayloads;
     hasContexts = source.HasContexts;
     while ((spare = source.Next()) != null)
     {
         entries.Append(spare);
         if (hasPayloads)
         {
             payloads.Append(source.Payload);
         }
         if (hasContexts)
         {
             contextSets.Add(source.Contexts);
         }
         if (freqIndex >= freqs.Length)
         {
             freqs = ArrayUtil.Grow(freqs, freqs.Length + 1);
         }
         freqs[freqIndex++] = source.Weight;
     }
     comp = source.Comparator;
 }
示例#29
0
 public SortedList(IComparer comparer) : this()
 {
     if (comparer != null)
     {
         this.comparer = comparer;
     }
 }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="identifier"></param>
 /// <param name="state"></param>
 /// <param name="metricsEvaluator"></param>
 /// <param name="endCriteriaEvaluator"></param>
 /// <param name="getCallableGenes">Gets the IGEPGenes that can be called by the given IGEPGene.</param>
 public GEPEnvironment(IEnvironmentIdentifier identifier, IEnvironmentState state, 
     IMetricsEvaluator metricsEvaluator, IEndCriteriaEvaluator endCriteriaEvaluator,
     IComparer<IOrganism> organismValueComparer,
     ICallableGenesProvider callableGenesProvider)
     : base(identifier, state, metricsEvaluator, endCriteriaEvaluator, callableGenesProvider: callableGenesProvider, organismValueComparer: organismValueComparer)
 {
 }
        static protected RangeView <TElement> FindUniqueRangeCore <TKey>(TElement[] indexArray, Func <TElement, TKey> keySelector, IComparer <TKey> comparer, TKey min, TKey max, bool ascendant)
        {
            var lo = BinarySearch.FindClosest(indexArray, 0, indexArray.Length, min, keySelector, comparer, false);
            var hi = BinarySearch.FindClosest(indexArray, 0, indexArray.Length, max, keySelector, comparer, true);

            return(new RangeView <TElement>(indexArray, lo, hi, ascendant));
        }
 /// <summary>
 /// Create a new instance of priority queue with default initial capacity.
 /// </summary>
 /// <param name="comparer">Priority comparer. Default for type will be used unless custom is provided.</param>
 public ConcurrentPriorityQueue(IComparer<TPriority> comparer = null): this(_defaultCapacity, comparer)
 {
 }
 /// <summary>
 /// Create a new instance of priority queue with given initial capacity.
 /// </summary>
 /// <param name="capacity">Initial queue capacity. Should be greater than 0.</param>
 /// <param name="comparer">Priority comparer. Default for type will be used unless custom is provided.</param>
 public ConcurrentPriorityQueue(int capacity, IComparer<TPriority> comparer = null):base(capacity, comparer)
 {
     _shrinkBound = Capacity / _shrinkRatio;
 }
示例#34
0
        /// <summary>
        /// Do not add an item to the cache unless the current transaction
        /// timestamp is later than the timestamp at which the item was
        /// invalidated. (Otherwise, a stale item might be re-added if the
        /// database is operating in repeatable read isolation mode.)
        /// </summary>
        /// <returns>Whether the item was actually put into the cache</returns>
        public async Task <bool> PutAsync(CacheKey key, object value, long txTimestamp, object version, IComparer versionComparator,
                                          bool minimalPut, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();
            if (txTimestamp == long.MinValue)
            {
                // MinValue means cache is disabled
                return(false);
            }

            using (await _lockObjectAsync.LockAsync())
            {
                if (log.IsDebugEnabled())
                {
                    log.Debug("Caching: {0}", key);
                }

                var lockValue = await(_cache.LockAsync(key, cancellationToken)).ConfigureAwait(false);
                try
                {
                    ILockable lockable = (ILockable)await(Cache.GetAsync(key, cancellationToken)).ConfigureAwait(false);

                    bool puttable = lockable == null ||
                                    lockable.IsPuttable(txTimestamp, version, versionComparator);

                    if (puttable)
                    {
                        await(Cache.PutAsync(key, CachedItem.Create(value, Cache.NextTimestamp(), version), cancellationToken)).ConfigureAwait(false);
                        if (log.IsDebugEnabled())
                        {
                            log.Debug("Cached: {0}", key);
                        }
                        return(true);
                    }
                    else
                    {
                        if (log.IsDebugEnabled())
                        {
                            if (lockable.IsLock)
                            {
                                log.Debug("Item was locked: {0}", key);
                            }
                            else
                            {
                                log.Debug("Item was already cached: {0}", key);
                            }
                        }
                        return(false);
                    }
                }
                finally
                {
                    await(_cache.UnlockAsync(key, lockValue, cancellationToken)).ConfigureAwait(false);
                }
            }
        }
示例#35
0
 /// <summary>
 /// Sorts the move using the specified IComparer.
 /// The Pv move will not be effected by this sorting.
 /// </summary>
 /// <param name="comparer">The IComparer to use when comparing and sorting moves.</param>
 public void Sort(IComparer <Move> comparer)
 {
     m_moves.Sort(1, m_moves.Count - 1, comparer);
 }
        static protected RangeView <TElement> FindManyClosestCore <TKey>(TElement[] indexArray, Func <TElement, TKey> keySelector, IComparer <TKey> comparer, TKey key, bool selectLower)
        {
            var closest = BinarySearch.FindClosest(indexArray, 0, indexArray.Length, key, keySelector, comparer, selectLower);

            if (closest == -1)
            {
                return(RangeView <TElement> .Empty);
            }

            return(FindManyCore(indexArray, keySelector, comparer, keySelector(indexArray[closest])));
        }
        // Many

        static protected RangeView <TElement> FindManyCore <TKey>(TElement[] indexKeys, Func <TElement, TKey> keySelector, IComparer <TKey> comparer, TKey key)
        {
            var lo = BinarySearch.LowerBound(indexKeys, 0, indexKeys.Length, key, keySelector, comparer);

            if (lo == -1)
            {
                return(RangeView <TElement> .Empty);
            }

            var hi = BinarySearch.UpperBound(indexKeys, 0, indexKeys.Length, key, keySelector, comparer);

            if (hi == -1)
            {
                return(RangeView <TElement> .Empty);
            }

            return(new RangeView <TElement>(indexKeys, lo, hi, true));
        }
        // Optimize for IntKey
        static protected TElement FindUniqueCoreInt(TElement[] indexArray, Func <TElement, int> keySelector, IComparer <int> _, int key)
        {
            var index = BinarySearch.FindFirstIntKey(indexArray, key, keySelector);

            return((index != -1) ? indexArray[index] : default(TElement));
        }
        // Util

        protected TElement[] CloneAndSortBy <TKey>(Func <TElement, TKey> indexSelector, IComparer <TKey> comparer)
        {
            var array      = new TElement[data.Length];
            var sortSource = new TKey[data.Length];

            for (int i = 0; i < data.Length; i++)
            {
                array[i]      = data[i];
                sortSource[i] = indexSelector(data[i]);
            }

            Array.Sort(sortSource, array, 0, array.Length, comparer);
            return(array);
        }
        static protected TElement FindUniqueClosestCore <TKey>(TElement[] indexArray, Func <TElement, TKey> keySelector, IComparer <TKey> comparer, TKey key, bool selectLower)
        {
            var index = BinarySearch.FindClosest(indexArray, 0, indexArray.Length, key, keySelector, comparer, selectLower);

            return((index != -1) ? indexArray[index] : default(TElement));
        }
示例#41
0
 /// <summary>
 /// Creates a new historical scheduler with the specified initial clock value.
 /// </summary>
 /// <param name="initialClock">Initial value for the clock.</param>
 /// <param name="comparer">Comparer to determine causality of events based on absolute time.</param>
 /// <exception cref="ArgumentNullException"><paramref name="comparer"/> is <c>null</c>.</exception>
 public HistoricalScheduler(DateTimeOffset initialClock, IComparer <DateTimeOffset> comparer)
     : base(initialClock, comparer)
 {
 }
        // Unique

        static protected TElement FindUniqueCore <TKey>(TElement[] indexArray, Func <TElement, TKey> keySelector, IComparer <TKey> comparer, TKey key)
        {
            var index = BinarySearch.FindFirst(indexArray, key, keySelector, comparer);

            return((index != -1) ? indexArray[index] : default(TElement));
        }
示例#43
0
 /// <summary>
 /// Sorts the specified action.
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="action">The action.</param>
 /// <param name="id">The id.</param>
 /// <param name="comparer">The comparer.</param>
 /// <returns></returns>
 public static IEnumerable <T> Sort <T>(Func <int, IEnumerable <T> > action, int id, IComparer <T> comparer) => action(id).Sort(comparer.Compare);
        static protected RangeView <TElement> FindManyRangeCore <TKey>(TElement[] indexArray, Func <TElement, TKey> keySelector, IComparer <TKey> comparer, TKey min, TKey max, bool ascendant)
        {
            var lo = FindManyClosestCore(indexArray, keySelector, comparer, min, false).FirstIndex;
            var hi = FindManyClosestCore(indexArray, keySelector, comparer, max, true).LastIndex;

            return(new RangeView <TElement>(indexArray, lo, hi, ascendant));
        }
 public ActionResult SortByLikes(string userName)
 {
     _currentPage     = 0;
     _currentComparer = new LikeComparer();
     return(PartialView("_DisplayVideos", GetItemsPage(userName, _currentComparer).Videos.ToList()));
 }
示例#46
0
 /// <summary>
 /// Creates a new historical scheduler with the specified initial clock value and absolute time comparer.
 /// </summary>
 /// <param name="initialClock">Initial value for the clock.</param>
 /// <param name="comparer">Comparer to determine causality of events based on absolute time.</param>
 protected HistoricalSchedulerBase(DateTimeOffset initialClock, IComparer <DateTimeOffset> comparer)
     : base(initialClock, comparer)
 {
 }
示例#47
0
        /// <summary>
        /// Returns the item with the minimum value in a sequence of values.
        /// </summary>
        /// <typeparam name="TSource">The type of the elements of source.</typeparam>
        /// <typeparam name="TKey">The type of the elements of selector.</typeparam>
        /// <param name="source">A sequence of values to determine the minimum value of.</param>
        /// <param name="selector">A delegate used to select the values</param>
        /// <param name="comparer">
        /// A comparer used to compare the value defined by <typeparamref name="TKey"/>
        /// </param>
        /// <returns>The minimum value in the sequence</returns>
        public static TSource MinBy <TSource, TKey>(this IEnumerable <TSource> source, Func <TSource, TKey> selector, IComparer <TKey> comparer)
        {
            // https://stackoverflow.com/questions/914109/how-to-use-linq-to-select-object-with-minimum-or-maximum-property-value

            if (source == null)
            {
                throw new ArgumentNullException("source");
            }

            if (selector == null)
            {
                throw new ArgumentNullException("selector");
            }

            comparer = comparer ?? Comparer <TKey> .Default;

            using (var sourceIterator = source.GetEnumerator())
            {
                if (!sourceIterator.MoveNext())
                {
                    throw new InvalidOperationException("Sequence contains no elements");
                }

                var min    = sourceIterator.Current;
                var minKey = selector(min);

                while (sourceIterator.MoveNext())
                {
                    var candidate          = sourceIterator.Current;
                    var candidateProjected = selector(candidate);
                    if (comparer.Compare(candidateProjected, minKey) < 0)
                    {
                        min    = candidate;
                        minKey = candidateProjected;
                    }
                }
                return(min);
            }
        }
示例#48
0
 /// <summary>
 /// Sorts the specified action.
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="action">The action.</param>
 /// <param name="comparer">The comparer.</param>
 /// <returns></returns>
 public static IEnumerable <T> Sort <T>(Func <IEnumerable <T> > action, IComparer <T> comparer) => action().Sort(comparer.Compare);
示例#49
0
        public static void Sort <T, TValue>(this List <T> source, Func <T, TValue> selector, IComparer <TValue> comparer, bool descending)
        {
            if (source == null)
            {
                throw new ArgumentNullException("source");
            }

            if (comparer == null)
            {
                comparer = Comparer <TValue> .Default;
            }

            var itemComparer = new ProjectionComparer <T, TValue>(selector, comparer);

            source.Sort(descending ? itemComparer.Reverse() : itemComparer);
        }
示例#50
0
 public static void SetCustomSorter(DependencyObject obj, IComparer value)
 {
     obj.SetValue(CustomSorterProperty, value);
 }
示例#51
0
 /// <summary>
 /// Sorts the array.
 /// </summary>
 /// <param name="comparer">The comparer to use in sorting. If <c>null</c>, the default comparer is used.</param>
 public void Sort(IComparer<T> comparer)
 {
     Array.Sort(this.elements, 0, this.Count, new Comparer(comparer));
 }
示例#52
0
 public BinaryHeap(IComparer <T> comparer)
 {
     Comparer   = comparer;
     collection = CreateCollection();
 }
示例#53
0
        public static IAsyncObserver <TSource> MaxBy <TSource, TKey>(IAsyncObserver <IList <TSource> > observer, Func <TSource, TKey> keySelector, IComparer <TKey> comparer)
        {
            if (observer == null)
            {
                throw new ArgumentNullException(nameof(observer));
            }
            if (keySelector == null)
            {
                throw new ArgumentNullException(nameof(keySelector));
            }
            if (comparer == null)
            {
                throw new ArgumentNullException(nameof(comparer));
            }

            return(MaxBy(observer, x => Task.FromResult(keySelector(x)), comparer));
        }
示例#54
0
 internal Comparer(IComparer<T> comparer = null)
 {
     Requires.NotNull(comparer, "comparer");
     this.comparer = comparer;
 }
示例#55
0
        public static IAsyncObserver <TSource> MaxBy <TSource, TKey>(IAsyncObserver <IList <TSource> > observer, Func <TSource, Task <TKey> > keySelector, IComparer <TKey> comparer)
        {
            if (observer == null)
            {
                throw new ArgumentNullException(nameof(observer));
            }
            if (keySelector == null)
            {
                throw new ArgumentNullException(nameof(keySelector));
            }
            if (comparer == null)
            {
                throw new ArgumentNullException(nameof(comparer));
            }

            var hasValue = false;
            var lastKey  = default(TKey);
            var list     = new List <TSource>();

            return(Create <TSource>(
                       async x =>
            {
                var key = default(TKey);
                try
                {
                    key = await keySelector(x).ConfigureAwait(false);
                }
                catch (Exception ex)
                {
                    await observer.OnErrorAsync(ex).ConfigureAwait(false);
                    return;
                }

                var comparison = 0;

                if (!hasValue)
                {
                    hasValue = true;
                    lastKey = key;
                }
                else
                {
                    try
                    {
                        comparison = comparer.Compare(key, lastKey);
                    }
                    catch (Exception ex)
                    {
                        await observer.OnErrorAsync(ex).ConfigureAwait(false);
                        return;
                    }
                }

                if (comparison > 0)
                {
                    lastKey = key;
                    list.Clear();
                }

                if (comparison >= 0)
                {
                    list.Add(x);
                }
            },
                       observer.OnErrorAsync,
                       async() =>
            {
                await observer.OnNextAsync(list).ConfigureAwait(false);
                await observer.OnCompletedAsync().ConfigureAwait(false);
            }
                       ));
        }
示例#56
0
 public IntersectAsyncIterator(IEnumerable <IAsyncEnumerable <TSource> > sources, int?limit, Func <TSource, TKey> keySelector, Func <TSource, TResult> resultSelector, IComparer <TKey> comparer)
     : base(sources, limit, keySelector, resultSelector, comparer)
 {
 }
 public static OrderedEnumerableRowCollection <TRow> OrderBy <TRow, TKey> (this EnumerableRowCollection <TRow> source, Func <TRow, TKey> keySelector, IComparer <TKey> comparer)
 {
     return(OrderedEnumerableRowCollection <TRow> .Create <TRow, TKey> (source, keySelector, comparer, false));
 }
示例#58
0
        public static IAsyncObservable <IList <TSource> > MaxBy <TSource, TKey>(IAsyncObservable <TSource> source, Func <TSource, Task <TKey> > keySelector, IComparer <TKey> comparer)
        {
            if (source == null)
            {
                throw new ArgumentNullException(nameof(source));
            }
            if (keySelector == null)
            {
                throw new ArgumentNullException(nameof(keySelector));
            }
            if (comparer == null)
            {
                throw new ArgumentNullException(nameof(comparer));
            }

            return(Create <IList <TSource> >(observer => source.SubscribeSafeAsync(AsyncObserver.MaxBy(observer, keySelector, comparer))));
        }
示例#59
0
 /// <summary>
 /// Instantiate a new Priority Queue
 /// </summary>
 /// <param name="comparer">The comparer used to compare TPriority values.  Defaults to Comparer&lt;TPriority&gt;.default</param>
 public SimplePriorityQueue(IComparer <TPriority> comparer) : this(comparer.Compare)
 {
 }
 public static OrderedEnumerableRowCollection <TRow> ThenByDescending <TRow, TKey> (this OrderedEnumerableRowCollection <TRow> source, Func <TRow, TKey> keySelector, IComparer <TKey> comparer)
 {
     return(OrderedEnumerableRowCollection <TRow> .AddSort <TRow, TKey> (source, keySelector, comparer, true));
 }