public static IBinaryHeap <T, T> Wrap <T>(this IListX <T> inner, int count, long offset = 0) where T : IComparable <T>
{
if (inner == null)
{
throw new ArgumentNullException("BinaryHeap_List inner list can not be null");
}
if (inner is T[])
{
T[] _inner = inner as T[];
if (offset == 0)
{
BHX.MinHeapify <T>(_inner, count);
}
else
{
BHX.MinHeapify <T>(_inner, count, offset);
}
return(new BinaryHeap_Array <T>()
{
_inner = _inner.Segment(offset, count)
});
}
else if (inner is ArraySeg <T> )
{
var _inner = (ArraySeg <T>)inner;
_inner = _inner.SubShift(offset, count, count);
if (_inner._offset == 0)
{
BHX.MinHeapify <T>(_inner._inner, _inner._count);
}
else
{
BHX.MinHeapify <T>(_inner._inner, _inner._count, _inner._offset);
}
return(new BinaryHeap_Array <T>()
{
_inner = _inner
});
}
else if (inner is Segment <T, IListX <T> > )
{
var _inner = (Segment <T, IListX <T> >)inner;
_inner = _inner.SubShift((int)offset, count, count);
BHX.MinHeapify <T>(_inner);
return(new BinaryHeap_List <T>()
{
_inner = _inner
});
}
else
{
var _inner = inner.SegmentI((int)offset, count);
BHX.MinHeapify <T>(_inner);
return(new BinaryHeap_List <T>()
{
_inner = _inner
});
}
}
public IEnumerable <T> PopMany(int itemCount)
{
if (_inner.Count < itemCount)
{
throw new OverflowException("[BinaryHeap:Pop] not enough item in heap");
}
return(BHX.PopMany <T>(_inner, itemCount));
}
public void DropWhileLess(T limit)
{
if (_inner._offset > 0)
{
_inner._count = BHX.DropWhileLess <T>(_inner._inner, limit, _inner._count, _inner._offset);
}
else
{
_inner._count = BHX.DropWhileLess <T>(_inner._inner, limit, _inner._count);
}
}
public void Sort()
{
if (_inner._offset > 0)
{
BHX.SortMinHeap <T>(_inner._inner, _inner._count, _inner._offset);
}
else
{
BHX.SortMinHeap <T>(_inner._inner, _inner._count);
}
}
public T Pop()
{
if (Empty)
{
throw new OverflowException("[BinaryHeap:Pop] no more item in heap");
}
else
{
return(BHX.Pop <T>(_inner));
}
}
public static IBinaryHeap <T, P> Wrap <T, P>(this IListX <T> inner)//, P priorityRef)
where T : IPriority <P>
where P : IComparable <P>
{
if (inner == null)
{
throw new ArgumentNullException("BinaryHeap_List inner list can not be null");
}
if (inner is T[])
{
T[] _inner = inner as T[];
BHX.MinHeapify <T, P>(_inner);
return(new BinaryHeap_Array <T, P>()
{
_inner = _inner.Segment(0, _inner.Length)
});
}
else if (inner is ArraySeg <T> )
{
var _inner = (ArraySeg <T>)inner;
if (_inner._offset == 0)
{
BHX.MinHeapify <T, P>(_inner._inner, _inner._count);
}
else
{
BHX.MinHeapify <T, P>(_inner._inner, _inner._count, _inner._offset);
}
return(new BinaryHeap_Array <T, P>()
{
_inner = _inner
});
}
else if (inner is Segment <T, IListX <T> > )
{
var _inner = (Segment <T, IListX <T> >)inner;
BHX.MinHeapify <T, P>(_inner);
return(new BinaryHeap_List <T, P>()
{
_inner = _inner
});
}
else
{
BHX.MinHeapify <T, P>(inner);
return(new BinaryHeap_List <T, P>()
{
_inner = inner
});
}
}
public bool Drop(T item)
{
bool suc;
if (_inner._offset > 0)
{
(suc, _inner._count) = BHX.Drop <T>(_inner._inner, item, _inner._count, _inner._offset);
}
else
{
(suc, _inner._count) = BHX.Drop <T>(_inner._inner, item, _inner._count);
}
return(suc);
}
public bool DropMany(int itemCount)
{
bool suc;
if (_inner._offset > 0)
{
(suc, _inner._count) = BHX.DropMany <T>(_inner._inner, itemCount, _inner._count, _inner._offset);
}
else
{
(suc, _inner._count) = BHX.DropMany <T>(_inner._inner, itemCount, _inner._count);
}
return(suc);
}
public void PushMany(ICollection <T> items)
{
if (_inner.FreeCount < items.Count)
{
throw new OverflowException("[BinaryHeap:Push] not enough capacity in heap");
}
else if (_inner._offset > 0)
{
_inner._count = BHX.PushMany <T>(_inner._inner, _inner._count, _inner._offset, items);
}
else
{
_inner._count = BHX.PushMany <T>(_inner._inner, _inner._count, items);
}
}
public void Push(T item)
{
if (_inner._count >= _inner._capacity)
{
throw new OverflowException("[BinaryHeap:Push] no more capacity in heap");
}
else if (_inner._offset > 0)
{
_inner._count = BHX.Push <T>(_inner._inner, item, _inner._count, _inner._offset);
}
else
{
_inner._count = BHX.Push <T>(_inner._inner, item, _inner._count);
}
}
public IEnumerable <T> PopWhileLess(T limit)
{
if (Empty)
{
yield break;
}
var until = _inner._offset > 0 ?
BHX.PopWhileLess <T>(_inner._inner, limit, _inner._count, _inner._offset) :
BHX.PopWhileLess <T>(_inner._inner, limit, _inner._count);
foreach (var item in until)
{
_inner._count = item.heapCount;
yield return(item.elem);
}
}
public IEnumerable <T> PopAll()
{
if (Empty)
{
throw new OverflowException("[BinaryHeap:Pop] no more item in heap");
}
var all = _inner._offset > 0 ?
BHX.PopAll <T>(_inner._inner, _inner._count, _inner._offset) :
BHX.PopAll <T>(_inner._inner, _inner._count);
foreach (var item in all)
{
_inner._count = item.heapCount;
yield return(item.elem);
}
}
public T Pop()
{
if (Empty)
{
throw new OverflowException("[BinaryHeap:Pop] no more item in heap");
}
else if (_inner._offset > 0)
{
T elem;
(elem, _inner._count) = BHX.Pop <T>(_inner._inner, _inner._count, _inner._offset);
return(elem);
}
else
{
T elem;
(elem, _inner._count) = BHX.Pop <T>(_inner._inner, _inner._count);
return(elem);
}
}
public void Toogle(int opcion)
{
switch (opcion)
{
case 0:
LDC.SetActive(T_LDC.isOn);
break;
case 1:
VM.SetActive(T_VM.isOn);
break;
case 2:
BHX.SetActive(T_BHX.isOn);
break;
case 3:
BHY.SetActive(T_BHY.isOn);
break;
case 4:
BHZ.SetActive(T_BHZ.isOn);
break;
case 5:
BM.SetActive(T_BM.isOn);
break;
case 6:
MR.SetActive(T_MR.isOn);
break;
case 7:
EDT.SetActive(T_EDT.isOn);
break;
case 8:
CuerpoGO.SetActive(T_Cuerpo.isOn);
break;
}
}
public bool DropMany(int itemCount) => BHX.DropMany <T>(_inner, itemCount);
public void PushMany(ICollection <T> items) => BHX.PushMany <T>(_inner, items);
public void PushMany(params T[] items) => BHX.PushMany <T>(_inner, items);
public void Push(T item) => BHX.Push <T>(_inner, item);
public BinaryHeap_List(params T[] items)
{
_inner = new ListX <T>(items);
BHX.MinHeapify <T>(_inner);
}
public void DropWhileLessOrEqual(T limit) => BHX.DropWhileLessOrEqual <T>(_inner, limit);
public void Sort() => BHX.SortMinHeap <T>(_inner);
public void DropWhileLess(T limit) => BHX.DropWhileLess <T>(_inner, limit);
public bool Remove(T item) => BHX.Drop <T>(_inner, item);
public IEnumerable <T> PopWhileLess(T limit) => BHX.PopWhileLess <T>(_inner, limit);
public IEnumerable <T> PopAll() => BHX.PopAll <T>(_inner);
public bool Drop(T item) => BHX.Drop <T>(_inner, item);
public BinaryHeap_List(ICollection <T> items)
{
_inner = new ListX <T>(items);
BHX.MinHeapify <T>(_inner);
}
public IEnumerable <T> PopWhileLessOrEqual(T limit) => BHX.PopWhileLessOrEqual <T>(_inner, limit);
public BinaryHeap_Array(params T[] items)
{
_inner = items.Segment(0, items.Length);
BHX.MinHeapify <T>(_inner._inner, _inner._count, _inner._offset);
}
