public static FSharpList <RankedTree <a> > insertTree <a>(IComparer <a> comparer, RankedTree <a> t, FSharpList <RankedTree <a> > ts) { while (true) { FSharpList <RankedTree <a> > fsharpList1 = ts; if (fsharpList1.get_TailOrNull() != null) { FSharpList <RankedTree <a> > fsharpList2 = fsharpList1; FSharpList <RankedTree <a> > tailOrNull = fsharpList2.get_TailOrNull(); RankedTree <a> headOrDefault = fsharpList2.get_HeadOrDefault(); if (BinomialHeap.rank <a>(t) >= BinomialHeap.rank <a>(headOrDefault)) { IComparer <a> comparer1 = comparer; RankedTree <a> rankedTree = BinomialHeap.link <a>(comparer, t, headOrDefault); ts = tailOrNull; t = rankedTree; comparer = comparer1; } else { goto label_3; } } else { break; } } return(FSharpList <RankedTree <a> > .Cons(t, FSharpList <RankedTree <a> > .get_Empty())); label_3: return(FSharpList <RankedTree <a> > .Cons(t, ts)); }
internal static Tuple <RankedTree <a>, FSharpList <RankedTree <a> > > removeMinTree <a>(IComparer <a> comparer, FSharpList <RankedTree <a> > heap) { FSharpList <RankedTree <a> > fsharpList1 = heap; if (fsharpList1.get_TailOrNull() == null) { throw new InvalidOperationException("The heap is empty."); } FSharpList <RankedTree <a> > fsharpList2 = fsharpList1; if (fsharpList2.get_TailOrNull().get_TailOrNull() == null) { return(new Tuple <RankedTree <a>, FSharpList <RankedTree <a> > >(fsharpList2.get_HeadOrDefault(), FSharpList <RankedTree <a> > .get_Empty())); } FSharpList <RankedTree <a> > tailOrNull = fsharpList2.get_TailOrNull(); RankedTree <a> headOrDefault = fsharpList2.get_HeadOrDefault(); Tuple <RankedTree <a>, FSharpList <RankedTree <a> > > tuple = BinomialHeap.removeMinTree <a>(comparer, tailOrNull); FSharpList <RankedTree <a> > fsharpList3 = tuple.Item2; RankedTree <a> rankedTree = tuple.Item1; FSharpChoice <Unit, Unit, Unit> fsharpChoice = BinomialHeap.LTGTEQ(comparer.Compare(BinomialHeap.root <a>(headOrDefault), BinomialHeap.root <a>(rankedTree))); if (fsharpChoice is FSharpChoice <Unit, Unit, Unit> .Choice1Of3 || fsharpChoice is FSharpChoice <Unit, Unit, Unit> .Choice3Of3) { return(new Tuple <RankedTree <a>, FSharpList <RankedTree <a> > >(headOrDefault, tailOrNull)); } return(new Tuple <RankedTree <a>, FSharpList <RankedTree <a> > >(rankedTree, FSharpList <RankedTree <a> > .Cons(headOrDefault, fsharpList3))); }
public virtual bool Equals(object obj, IEqualityComparer comp) { if (this == null) { return(obj == null); } RankedTree <T> rankedTree1 = obj as RankedTree <T>; if (rankedTree1 == null) { return(false); } RankedTree <T> rankedTree2 = rankedTree1; RankedTree <T> rankedTree3 = this; RankedTree <T> rankedTree4 = this; RankedTree <T> rankedTree5 = rankedTree2; if (rankedTree4.item1 != rankedTree5.item1 || !LanguagePrimitives.HashCompare.GenericEqualityWithComparerIntrinsic <T>(comp, (M0)rankedTree4.item2, (M0)rankedTree5.item2)) { return(false); } IEqualityComparer equalityComparer = comp; return(rankedTree4.item3.Equals((object)rankedTree5.item3, equalityComparer)); }
public virtual int CompareTo(object obj, IComparer comp) { RankedTree <T> rankedTree1 = (RankedTree <T>)obj; if (this != null) { if ((RankedTree <T>)obj == null) { return(1); } RankedTree <T> rankedTree2 = this; RankedTree <T> rankedTree3 = this; RankedTree <T> rankedTree4 = rankedTree1; int num1 = rankedTree3.item1; int num2 = rankedTree4.item1; int num3 = num1 >= num2 ? (num1 > num2 ? 1 : 0) : -1; if (num3 < 0 || num3 > 0) { return(num3); } int num4 = LanguagePrimitives.HashCompare.GenericComparisonWithComparerIntrinsic <T>(comp, (M0)rankedTree3.item2, (M0)rankedTree4.item2); if (num4 < 0 || num4 > 0) { return(num4); } IComparer comparer = comp; return(rankedTree3.item3.CompareTo((object)rankedTree4.item3, comparer)); } return((RankedTree <T>)obj != null ? -1 : 0); }
public virtual int CompareTo(RankedTree <T> obj) { if (this != null) { if (obj == null) { return(1); } RankedTree <T> rankedTree1 = this; RankedTree <T> rankedTree2 = this; RankedTree <T> rankedTree3 = obj; LanguagePrimitives.get_GenericComparer(); int num1 = rankedTree2.item1; int num2 = rankedTree3.item1; int num3 = num1 >= num2 ? (num1 > num2 ? 1 : 0) : -1; if (num3 < 0 || num3 > 0) { return(num3); } int num4 = LanguagePrimitives.HashCompare.GenericComparisonWithComparerIntrinsic <T>(LanguagePrimitives.get_GenericComparer(), (M0)rankedTree2.item2, (M0)rankedTree3.item2); if (num4 < 0 || num4 > 0) { return(num4); } IComparer genericComparer = LanguagePrimitives.get_GenericComparer(); return(rankedTree2.item3.CompareTo((object)rankedTree3.item3, genericComparer)); } return(obj != null ? -1 : 0); }
public override sealed bool Equals(object obj) { RankedTree <T> rankedTree = obj as RankedTree <T>; if (rankedTree != null) { return(this.Equals(rankedTree)); } return(false); }
public virtual int GetHashCode(IEqualityComparer comp) { if (this == null) { return(0); } RankedTree <T> rankedTree1 = this; RankedTree <T> rankedTree2 = this; int num1 = 0; int num2 = rankedTree2.item3.GetHashCode(comp) + ((num1 << 6) + (num1 >> 2)) - 1640531527; int num3 = LanguagePrimitives.HashCompare.GenericHashWithComparerIntrinsic <T>(comp, (M0)rankedTree2.item2) + ((num2 << 6) + (num2 >> 2)) - 1640531527; return(rankedTree2.item1 + ((num3 << 6) + (num3 >> 2)) - 1640531527); }
internal static RankedTree <a> link <a>(IComparer <a> comparer, RankedTree <a> _arg2, RankedTree <a> _arg1) { RankedTree <a> rankedTree1 = _arg2; a x = rankedTree1.item2; int num = rankedTree1.item1; FSharpList <RankedTree <a> > fsharpList1 = rankedTree1.item3; RankedTree <a> rankedTree2 = _arg1; a y = rankedTree2.item2; FSharpList <RankedTree <a> > fsharpList2 = rankedTree2.item3; if (BinomialHeap.LTGTEQ(comparer.Compare(x, y)) is FSharpChoice <Unit, Unit, Unit> .Choice2Of3) { return(RankedTree <a> .NewNode(num + 1, y, FSharpList <RankedTree <a> > .Cons(rankedTree1, fsharpList2))); } return(RankedTree <a> .NewNode(num + 1, x, FSharpList <RankedTree <a> > .Cons(rankedTree2, fsharpList1))); }
public virtual bool Equals(RankedTree <T> obj) { if (this == null) { return(obj == null); } if (obj == null) { return(false); } RankedTree <T> rankedTree1 = this; RankedTree <T> rankedTree2 = this; RankedTree <T> rankedTree3 = obj; if (rankedTree2.item1 == rankedTree3.item1 && LanguagePrimitives.HashCompare.GenericEqualityERIntrinsic <T>((M0)rankedTree2.item2, (M0)rankedTree3.item2)) { return(LanguagePrimitives.HashCompare.GenericEqualityERIntrinsic <FSharpList <RankedTree <T> > >((M0)rankedTree2.item3, (M0)rankedTree3.item3)); } return(false); }
public static FSharpList <RankedTree <a> > mergeTrees <a>(IComparer <a> comparer, FSharpList <RankedTree <a> > _arg1_0, FSharpList <RankedTree <a> > _arg1_1) { Tuple <FSharpList <RankedTree <a> >, FSharpList <RankedTree <a> > > tuple = new Tuple <FSharpList <RankedTree <a> >, FSharpList <RankedTree <a> > >(_arg1_0, _arg1_1); FSharpList <RankedTree <a> > fsharpList1; if (tuple.Item2.get_TailOrNull() != null) { FSharpList <RankedTree <a> > fsharpList2 = tuple.Item2; if (tuple.Item1.get_TailOrNull() != null) { FSharpList <RankedTree <a> > fsharpList3 = tuple.Item1; FSharpList <RankedTree <a> > tailOrNull1 = fsharpList2.get_TailOrNull(); FSharpList <RankedTree <a> > fsharpList4 = tuple.Item2; FSharpList <RankedTree <a> > tailOrNull2 = fsharpList3.get_TailOrNull(); FSharpList <RankedTree <a> > fsharpList5 = tuple.Item1; RankedTree <a> headOrDefault1 = fsharpList2.get_HeadOrDefault(); RankedTree <a> headOrDefault2 = fsharpList3.get_HeadOrDefault(); int num1 = BinomialHeap.rank <a>(headOrDefault2); int num2 = BinomialHeap.rank <a>(headOrDefault1); FSharpChoice <Unit, Unit, Unit> fsharpChoice = BinomialHeap.LTGTEQ(num1 >= num2 ? (num1 > num2 ? 1 : 0) : -1); if (fsharpChoice is FSharpChoice <Unit, Unit, Unit> .Choice2Of3) { return(FSharpList <RankedTree <a> > .Cons(headOrDefault1, BinomialHeap.mergeTrees <a>(comparer, fsharpList5, tailOrNull1))); } if (!(fsharpChoice is FSharpChoice <Unit, Unit, Unit> .Choice3Of3)) { return(FSharpList <RankedTree <a> > .Cons(headOrDefault2, BinomialHeap.mergeTrees <a>(comparer, tailOrNull2, fsharpList4))); } return(BinomialHeap.insertTree <a>(comparer, BinomialHeap.link <a>(comparer, headOrDefault2, headOrDefault1), BinomialHeap.mergeTrees <a>(comparer, tailOrNull2, tailOrNull1))); } fsharpList1 = tuple.Item2; } else { fsharpList1 = tuple.Item1; } return(fsharpList1); }
internal static a root <a>(RankedTree <a> _arg1) { return(_arg1.item2); }
internal static int rank <a>(RankedTree <a> _arg1) { return(_arg1.item1); }
public static BinomialHeap <a> insert <a>(a x, BinomialHeap <a> heap) { FSharpList <RankedTree <a> > heap1 = BinomialHeap.insertTree <a>(heap.Comparer, RankedTree <a> .NewNode(0, x, FSharpList <RankedTree <a> > .get_Empty()), heap.Heap); return(new BinomialHeap <a>(heap.Comparer, heap1)); }
public int get_Tag() { RankedTree <T> rankedTree = this; return(0); }