/// <summary> /// Performs a smaller-to-bigger summation of sequence members. /// Works slightly slower than a simple sequential summation, /// but as smallest values are summed up first, this method /// significantly increases precision if the sequence doesn't non-decrease /// monotonously and consequent values are of different degrees. /// /// Requires a general term formula dependent on both argument and integer index (<paramref name="memberFormula"/>) as well as the current function argument. /// Also requires a comparer allowing of knowing which sequence element is bigger and which is smaller. /// </summary> /// <param name="startIndex">The inclusive beginning index of sequence summation.</param> /// <param name="endIndex">The inclusive ending index of sequence summation.</param> /// <param name="comparer">The comparer to compare values of type <typeparamref name="T"/>. Should return a positive value if the first value is bigger than the second, zero value if they are equal, and a negative value if the first object is less.</param> /// <param name="memberFormula">The general term formula dependent on both argument and integer index.</param> /// <param name="argument">The current argument for the sequence.</param> /// <returns>The result of sequential summation of the sequence starting with index <paramref name="startIndex"/> and ending with index <paramref name="endIndex"/>, both inclusive.</returns> public T Sum_SmallerToBigger(T argument, Func <T, int, T> memberFormula, int startIndex, int endIndex, IComparer <T> comparer) { IPriorityQueue <T> sequence = new BinaryHeap <T>(comparer.GetReverseComparer()); if (startIndex >= endIndex) { for (int i = startIndex; i <= endIndex; i++) { sequence.Insert(memberFormula(argument, i)); } } else { for (int i = endIndex; i >= startIndex; i--) { sequence.Insert(memberFormula(argument, i)); } } T sum = this.Zero; while (!sequence.IsEmpty) { sum = this.OperatorPlus(sum, sequence.Pop()); } return(sum); }