public static void MinMaxElement <T>( this ArrayIterator <T> first, ArrayIterator <T> last, Func <T, T, bool> comp, out ArrayIterator <T> min, out ArrayIterator <T> max ) { if (first.IsEqual(last)) { min = last; max = last; } min = first; max = first; while ((first = first.GetNext()).NotEqual(last)) { if (comp(first.GetCurrent(), min.GetCurrent())) { min = first; } if (comp(max.GetCurrent(), first.GetCurrent())) { max = first; } } }
public static ArrayIterator <T> SetDifference <T>( this ArrayIterator <T> first1, ArrayIterator <T> last1, ArrayIterator <T> first2, ArrayIterator <T> last2, ArrayIterator <T> result, Func <T, T, bool> comp ) { while (first1.NotEqual(last1) && first2.NotEqual(last2)) { if (comp(first1.GetCurrent(), first2.GetCurrent())) { result.SetCurrent(first1.GetCurrent()); result = result.GetNext(); first1 = first1.GetNext(); } else if (comp(first2.GetCurrent(), first1.GetCurrent())) { first2 = first2.GetNext(); } else { first1 = first1.GetNext(); first2 = first2.GetNext(); } } return(first1.Copy(last1, result)); }
public static void PartitionCopy <T>( this ArrayIterator <T> first, ArrayIterator <T> last, ArrayIterator <T> resultTrue, ArrayIterator <T> resultFalse, Func <T, bool> pred, out ArrayIterator <T> outResultTrue, out ArrayIterator <T> outResultFalse ) { while (first.NotEqual(last)) { if (pred(first.GetCurrent())) { resultTrue.SetCurrent(first.GetCurrent()); resultTrue = resultTrue.GetNext(); } else { resultFalse.SetCurrent(first.GetCurrent()); resultFalse = resultFalse.GetNext(); } first = first.GetNext(); } outResultTrue = resultTrue; outResultFalse = resultFalse; }
public static ArrayIterator <T> Merge <T>( this ArrayIterator <T> first1, ArrayIterator <T> last1, ArrayIterator <T> first2, ArrayIterator <T> last2, ArrayIterator <T> result, Func <T, T, bool> comp ) { while (true) { if (first1.IsEqual(last1)) { return(first2.Copy(last2, result)); } if (first2.IsEqual(last2)) { return(first1.Copy(last1, result)); } if (comp(first2.GetCurrent(), first1.GetCurrent())) { result.SetCurrent(first2.GetCurrent()); first2 = first2.GetNext(); } else { result.SetCurrent(first1.GetCurrent()); first1 = first1.GetNext(); } result = result.GetNext(); } }
public static ArrayIterator <T> UniqueCopy <T>( this ArrayIterator <T> first, ArrayIterator <T> last, ArrayIterator <T> result, Func <T, T, bool> pred ) { if (first.IsEqual(last)) { return(last); } result.SetCurrent(first.GetCurrent()); while ((first = first.GetNext()).NotEqual(last)) { var val = first.GetCurrent(); if (pred(result.GetCurrent(), val) == false) { result = result.GetNext(); result.SetCurrent(val); } } result = result.GetNext(); return(result); }
public static ArrayIterator <T> Partition <T>( this ArrayIterator <T> first, ArrayIterator <T> last, Func <T, bool> pred ) { while (first.NotEqual(last)) { while (pred(first.GetCurrent())) { first = first.GetNext(); if (first.IsEqual(last)) { return(first); } } do { last = last.GetPrev(); if (first.IsEqual(last)) { return(first); } } while (pred(last.GetCurrent()) == false); first.Swap(last); first = first.GetNext(); } return(first); }
public static ArrayIterator <T> ReplaceCopyIf <T>( this ArrayIterator <T> first, ArrayIterator <T> last, ArrayIterator <T> result, Func <T, bool> pred, T newValue ) { while (first.NotEqual(last)) { result.SetCurrent(pred(first.GetCurrent()) ? newValue : first.GetCurrent()); first = first.GetNext(); result = result.GetNext(); } return(result); }
public static void Swap <T>(this ArrayIterator <T> a, ArrayIterator <T> b) { var temp = a.GetCurrent(); a.SetCurrent(b.GetCurrent()); b.SetCurrent(temp); }
public static void Sort <T>( this ArrayIterator <T> first, ArrayIterator <T> last, Func <T, T, bool> comp ) { // Quicksort if (first.IsEqual(last)) { return; } var sep = first; for (var i = first.GetNext(); i.NotEqual(last); i = i.GetNext()) { if (comp(i.GetCurrent(), first.GetCurrent())) { sep = sep.GetNext(); sep.Swap(i); } } first.Swap(sep); first.Sort(sep, comp); sep.GetNext().Sort(last, comp); }
public static ArrayIterator <T> CopyIf <T>( this ArrayIterator <T> first, ArrayIterator <T> last, ArrayIterator <T> result, Func <T, bool> pred ) { while (first.NotEqual(last)) { if (pred(first.GetCurrent())) { result.SetCurrent(first.GetCurrent()); result = result.GetNext(); } first = first.GetNext(); } return(result); }
public static bool BinarySearch <T>( this ArrayIterator <T> first, ArrayIterator <T> last, T val, Func <T, T, bool> comp ) { first = first.LowerBound(last, val, comp); return(first.NotEqual(last) && comp(val, first.GetCurrent()) == false); }
public static bool IsPartitioned <T>( this ArrayIterator <T> first, ArrayIterator <T> last, Func <T, bool> pred ) { while (first.NotEqual(last) && pred(first.GetCurrent())) { first = first.GetNext(); } while (first.NotEqual(last)) { if (pred(first.GetCurrent())) { return(false); } first = first.GetNext(); } return(true); }
public static void ForEach <T>( this ArrayIterator <T> first, ArrayIterator <T> last, Action <T> callback ) { while (first.NotEqual(last)) { callback(first.GetCurrent()); first = first.GetNext(); } }
public static bool Includes <T>( this ArrayIterator <T> first1, ArrayIterator <T> last1, ArrayIterator <T> first2, ArrayIterator <T> last2, Func <T, T, bool> comp ) { while (first2.NotEqual(last2)) { if ((first1.IsEqual(last1)) || comp(first2.GetCurrent(), first1.GetCurrent())) { return(false); } if (comp(first1.GetCurrent(), first2.GetCurrent()) == false) { first2 = first2.GetNext(); } first1 = first1.GetNext(); } return(true); }
public static bool LexicographicalCompare <T>( this ArrayIterator <T> first1, ArrayIterator <T> last1, ArrayIterator <T> first2, ArrayIterator <T> last2, Func <T, T, bool> comp ) { while (first1.NotEqual(last1)) { if (first2.IsEqual(last2) || comp(first2.GetCurrent(), first1.GetCurrent())) { return(false); } else if (comp(first1.GetCurrent(), first2.GetCurrent())) { return(true); } first1 = first1.GetNext(); first2 = first2.GetNext(); } return(first2.NotEqual(last2)); }
public static ArrayIterator <T> CopyBackward <T>( this ArrayIterator <T> first, ArrayIterator <T> last, ArrayIterator <T> result ) { while (last.NotEqual(first)) { result = result.GetPrev(); last = last.GetPrev(); result.SetCurrent(last.GetCurrent()); } return(result); }
public static ArrayIterator <T> ReverseCopy <T>( this ArrayIterator <T> first, ArrayIterator <T> last, ArrayIterator <T> result ) { while (first.NotEqual(last)) { last = last.GetPrev(); result.SetCurrent(last.GetCurrent()); result = result.GetNext(); } return(result); }
public static ArrayIterator <T> CopyN <T>( this ArrayIterator <T> first, int n, ArrayIterator <T> result ) { while (n > 0) { result.SetCurrent(first.GetCurrent()); result = result.GetNext(); first = first.GetNext(); n--; } return(result); }
public static ArrayIterator <T> Transform <T>( this ArrayIterator <T> first1, ArrayIterator <T> last1, ArrayIterator <T> result, Func <T, T> op ) { while (first1.NotEqual(last1)) { result.SetCurrent(op(first1.GetCurrent())); result = result.GetNext(); first1 = first1.GetNext(); } return(result); }
public static bool AllOf <T>( this ArrayIterator <T> first, ArrayIterator <T> last, Func <T, bool> pred ) { while (first.NotEqual(last)) { if (pred(first.GetCurrent()) == false) { return(false); } first = first.GetNext(); } return(true); }
public static ArrayIterator <T> FindIf <T>( this ArrayIterator <T> first, ArrayIterator <T> last, Func <T, bool> pred ) { while (first.NotEqual(last)) { if (pred(first.GetCurrent())) { return(first); } first = first.GetNext(); } return(last); }
public static void ReplaceIf <T>( this ArrayIterator <T> first, ArrayIterator <T> last, Func <T, bool> pred, T newValue ) { while (first.NotEqual(last)) { if (pred(first.GetCurrent())) { first.SetCurrent(newValue); } first = first.GetNext(); } }
public static int CountIf <T>( this ArrayIterator <T> first, ArrayIterator <T> last, Func <T, bool> pred ) { var count = 0; while (first.NotEqual(last)) { if (pred(first.GetCurrent())) { count++; } first = first.GetNext(); } return(count); }
public static bool Equal <T>( this ArrayIterator <T> first1, ArrayIterator <T> last1, ArrayIterator <T> first2, Func <T, T, bool> pred ) { while (first1.NotEqual(last1)) { if (pred(first1.GetCurrent(), first2.GetCurrent()) == false) { return(false); } first1 = first1.GetNext(); first2 = first2.GetNext(); } return(true); }
public static ArrayIterator <T> MaxElement <T>( this ArrayIterator <T> first, ArrayIterator <T> last, Func <T, T, bool> comp ) { if (first.IsEqual(last)) { return(last); } var largest = first; while ((first = first.GetNext()).NotEqual(last)) { if (comp(largest.GetCurrent(), first.GetCurrent())) { largest = first; } } return(largest); }
public static ArrayIterator <T> FindFirstOf <T>( this ArrayIterator <T> first1, ArrayIterator <T> last1, ArrayIterator <T> first2, ArrayIterator <T> last2, Func <T, T, bool> pred ) { while (first1.NotEqual(last1)) { for (var it = first2; it.NotEqual(last2); it = it.GetNext()) { if (pred(it.GetCurrent(), first1.GetCurrent())) { return(first1); } } first1 = first1.GetNext(); } return(last1); }
public static void Mismatch <T>( this ArrayIterator <T> first1, ArrayIterator <T> last1, ArrayIterator <T> first2, Func <T, T, bool> pred, out ArrayIterator <T> mismatch1, out ArrayIterator <T> mismatch2 ) { while (first1.NotEqual(last1)) { if (pred(first1.GetCurrent(), first2.GetCurrent()) == false) { break; } first1 = first1.GetNext(); first2 = first2.GetNext(); } mismatch1 = first1; mismatch2 = first2; }
public static ArrayIterator <T> IsSortedUntil <T>( this ArrayIterator <T> first, ArrayIterator <T> last, Func <T, T, bool> comp ) { if (first.IsEqual(last)) { return(first); } var next = first; while ((next = next.GetNext()).NotEqual(last)) { if (comp(next.GetCurrent(), first.GetCurrent())) { return(next); } first = first.GetNext(); } return(last); }
public static void PushHeap <T>( this ArrayIterator <T> first, ArrayIterator <T> last, Func <T, T, bool> comp ) { if (first.Distance(last) < 2) { return; } last = last.GetPrev(); var temp = last.GetCurrent(); var parent = first.GetAdvanced((first.Distance(last) - 1) / 2); while (first.Distance(last) > 0 && comp(parent.GetCurrent(), temp)) { last.SetCurrent(parent.GetCurrent()); last = parent; parent = first.GetAdvanced((first.Distance(last) - 1) / 2); } last.SetCurrent(temp); }
public static ArrayIterator <T> AdjacentFind <T>( this ArrayIterator <T> first, ArrayIterator <T> last, Func <T, T, bool> pred ) { if (first.NotEqual(last)) { var next = first; next = next.GetNext(); while (next.NotEqual(last)) { if (pred(first.GetCurrent(), next.GetCurrent())) { return(first); } first = first.GetNext(); next = next.GetNext(); } } return(last); }