private static string GetOperandString(Operand operand, ListIterator<object> iterator)
{
if (operand == Operand.NEXT)
{
iterator.Advance();
return iterator.Next().ToString();
}
else if (operand == Operand.STRING)
{
iterator.Advance();
return "STRING[" + iterator.Next().ToString() + "]";
}
else if (operand == Operand.NONE)
return "";
return operand.ToString();
}
internal static String GetOpcodeString(ListIterator<Object> iterator)
{
if (iterator.AtEnd()) return "";
var instruction = iterator.Next();
if (instruction == null) return "null";
else if (instruction is Instruction)
{
var ins = (instruction as Instruction?).Value;
var r = ins.Opcode.ToString() + " ";
r += GetOperandString(ins.FirstOperand, iterator) + " ";
r += GetOperandString(ins.SecondOperand, iterator) + " ";
r += GetOperandString(ins.ThirdOperand, iterator) + " ";
if (!String.IsNullOrEmpty(ins.Annotation)) r += "#" + ins.Annotation;
return r;
}
else return instruction.ToString();
}
protected override void Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.CornflowerBlue);
spriteBatch.Begin();
Iterator<IControl> IteratorList = new ListIterator<IControl>(this.controlList);
IOption<IControl> ListItem = IteratorList.GetNext();
ControlVisitor controlVisitor = new ControlVisitor();
// This should have a vistor that returns a bool
while (ListItem.isNone() == false && ListItem.getValue().Visit(controlVisitor)) {
IControl control = ListItem.getValue();
control.Draw(spriteBatch, this.font, this.buttonStates);
ListItem = IteratorList.GetNext();
}
spriteBatch.End();
base.Draw(gameTime);
}
public static ListIterator <T> Unique <T>(ListIterator <T> begin, ListIterator <T> end)
where T : IEquatable <T>
{
return(Unique((ForwardIterator <T>)begin, (ForwardIterator <T>)end) as ListIterator <T>);
}
public void PrintWithEmptyListThrowsException()
{
this.sut = new ListIterator <string>(new string[0]);
Assert.Throws <InvalidOperationException>(() => this.sut.Print());
}
public void TestInit()
{
this.sut = new ListIterator <string>(new string[] { "Some", "Random", "Message" });
}
/// <summary>
/// Parse a list and calls a given iterator function on each element. Note that parsing is stopped as soon as
/// one of the iterator calls returns a non-zero value.
/// </summary>
/// <param name="iterator">An iterator function, called on each node of the list.</param>
/// <param name="user">A user-supplied field which is passed as the second argument to the iterator.</param>
public void Iterate(ListIterator iterator, IntPtr user)
{
Error err = FT.FT_List_Iterate(Reference, iterator, user);
if (err != Error.Ok)
throw new FreeTypeException(err);
}
internal static extern Error FT_List_Iterate(IntPtr list, ListIterator iterator, IntPtr user);
public void pushInputs(float[] farray)
{
ListIterator<InNetworkNode> iter = new ListIterator<InNetworkNode>(this.inlayer);
int i = 0;
while(iter.hasNext()){
InNetworkNode bob = iter.next().Value;
bob.setOutput(farray[i]);
i++;
}
}
public void Execute(ref ListIterator list)
{
string result = list.Move().ToString();
Console.WriteLine(result);
}
private void Initialize(IList <string> strings)
{
this.iterator = new ListIterator(strings);
}
public void TestHasNextMethod_TrueOutput(string[] values)
{
ListIterator <string> list = new ListIterator <string>(values);
Assert.That(() => list.HasNext(), Is.EqualTo(true));
}
public static ListIterator <T> AdjacentFind <T>(ListIterator <T> begin, ListIterator <T> end, IEqualityComparer <T> comparer)
{
return((ListIterator <T>)AdjacentFind((InputIterator <T>)begin, (InputIterator <T>)end, comparer));
}
private void CompareListIterators(ListIterator it1, ListIterator it2)
{
while (it1.HasPrevious())
{
NUnit.Framework.Assert.AreEqual(it1.Previous(), it2.Previous());
}
NUnit.Framework.Assert.IsFalse(it2.HasPrevious());
CompareIterators(it1, it2);
}
public Network()
{
Random R = new Random();
inlayer = new LinkedList<InNetworkNode>();
outlayer = new LinkedList<NetworkNode>();
hlayer1 = new LinkedList<NetworkNode>();
hlayer2 = new LinkedList<NetworkNode>();
for (int i = 0; i < 14; i++)
{
InNetworkNode bob = new InNetworkNode();
inlayer.AddLast(bob);
}
for (int i = 0; i < 28; i++)
{
NetworkNode bob = new NetworkNode();
hlayer1.AddLast(bob);
ListIterator<InNetworkNode> iter = new ListIterator<InNetworkNode>(inlayer);
int n = 0;
int m = 0;
int col=0;
int type = 0;
switch (i)
{
case 0: { n = 0; m = 2; type = ROW; } break;
case 1: { n = 3; m = 5; type = ROW; } break;
case 2: { n = 6; m = 8; type = ROW; } break;
case 3: { n = 9; m = 11; type = ROW; } break;
case 4: { n = 12; m = 14; type = ROW; } break;
case 5: { col=0; type = COL; } break;
case 6: { col=1; type = COL; } break;
case 7: { col=2; type = COL; } break;
}
/*
if (type == ROW)
{
for (int j = n; j <= m; j++)
{
bob.addNode(inlayer.ElementAt(j), (float)R.NextDouble() * 2 - 1);
}
}
else
{
switch (col)
{
case 0: {
bob.addNode(inlayer.ElementAt(0), (float)R.NextDouble() * 2 - 1);
bob.addNode(inlayer.ElementAt(3), (float)R.NextDouble() * 2 - 1);
bob.addNode(inlayer.ElementAt(6), (float)R.NextDouble() * 2 - 1);
bob.addNode(inlayer.ElementAt(9), (float)R.NextDouble() * 2 - 1);
bob.addNode(inlayer.ElementAt(12), (float)R.NextDouble() * 2 - 1);
} break;
case 1: {
bob.addNode(inlayer.ElementAt(1), (float)R.NextDouble() * 2 - 1);
bob.addNode(inlayer.ElementAt(4), (float)R.NextDouble() * 2 - 1);
bob.addNode(inlayer.ElementAt(7), (float)R.NextDouble() * 2 - 1);
bob.addNode(inlayer.ElementAt(10), (float)R.NextDouble() * 2 - 1);
bob.addNode(inlayer.ElementAt(13), (float)R.NextDouble() * 2 - 1);
} break;
case 2: {
bob.addNode(inlayer.ElementAt(2), (float)R.NextDouble() * 2 - 1);
bob.addNode(inlayer.ElementAt(5), (float)R.NextDouble() * 2 - 1);
bob.addNode(inlayer.ElementAt(8), (float)R.NextDouble() * 2 - 1);
bob.addNode(inlayer.ElementAt(11), (float)R.NextDouble() * 2 - 1);
bob.addNode(inlayer.ElementAt(14), (float)R.NextDouble() * 2 - 1);
} break;
}
}
*/
for (int j = 0; j < 15; j++)
{
bob.addNode(iter.next().Value, (float)R.NextDouble());
}
}
for (int i = 0; i < 14; i++)
{
NetworkNode bob = new NetworkNode();
hlayer2.AddLast(bob);
ListIterator<NetworkNode> iter2 = new ListIterator<NetworkNode>(hlayer1);
for (int j = 0; j < 8; j++)
{
bob.addNode(iter2.next().Value, (float)R.NextDouble() * 2 - 1);
}
}
for (int i = 0; i < 4; i++)
{
NetworkNode bob = new NetworkNode();
outlayer.AddLast(bob);
ListIterator<NetworkNode> iter = new ListIterator<NetworkNode>(hlayer2);
for (int j = 0; j < 8; j++)
{
bob.addNode(iter.next().Value, (float)R.NextDouble() * 2 - 1);
}
}
}
public static ListIterator <T> Unique <T>(ListIterator <T> begin, ListIterator <T> end, Functional.BinaryPredicate <T> op)
{
return(Unique((ForwardIterator <T>)begin, (ForwardIterator <T>)end, op) as ListIterator <T>);
}
public void TestRangeInsert()
{
int[] array = new int[]{0,1,2,3,4,5,6};
Vector<int> v = new Vector<int>(array);
int[] splice = new int[]{-1,-2,-3};
// range insert in the middle
ListIterator<int> pos = new ListIterator<int>(v, 4);
v.Insert(pos, IteratorUtil.Begin(splice), IteratorUtil.End(splice));
Assert.AreEqual(array.Length+splice.Length, v.Count);
Assert.AreEqual(3, v[3]);
Assert.AreEqual(-1, v[4]);
Assert.AreEqual(-2, v[5]);
Assert.AreEqual(-3, v[6]);
Assert.AreEqual(4, v[7]);
v = new Vector<int>(array);
pos = new ListIterator<int>(v, 4);
v.Insert(pos, 3, 42);
Assert.AreEqual(array.Length+splice.Length, v.Count);
Assert.AreEqual(3, v[3]);
Assert.AreEqual(42, v[4]);
Assert.AreEqual(42, v[5]);
Assert.AreEqual(42, v[6]);
Assert.AreEqual(4, v[7]);
// range insert at the beginning
v = new Vector<int>(array);
v.Insert(v.Begin(), IteratorUtil.Begin(splice), IteratorUtil.End(splice));
Assert.AreEqual(array.Length+splice.Length, v.Count);
Assert.AreEqual(-1, v[0]);
Assert.AreEqual(-2, v[1]);
Assert.AreEqual(-3, v[2]);
Assert.AreEqual(0, v[3]);
Assert.AreEqual(1, v[4]);
v = new Vector<int>(array);
v.Insert(v.Begin(), 3, 42);
Assert.AreEqual(array.Length+splice.Length, v.Count);
Assert.AreEqual(42, v[0]);
Assert.AreEqual(42, v[1]);
Assert.AreEqual(42, v[2]);
Assert.AreEqual(0, v[3]);
Assert.AreEqual(1, v[4]);
// range insert at the end
v = new Vector<int>(array);
v.Insert(v.End(), IteratorUtil.Begin(splice), IteratorUtil.End(splice));
Assert.AreEqual(array.Length+splice.Length, v.Count);
Assert.AreEqual(5, v[5]);
Assert.AreEqual(6, v[6]);
Assert.AreEqual(-1, v[7]);
Assert.AreEqual(-2, v[8]);
Assert.AreEqual(-3, v[9]);
v = new Vector<int>(array);
v.Insert(v.End(), 3, 42);
Assert.AreEqual(array.Length+splice.Length, v.Count);
Assert.AreEqual(5, v[5]);
Assert.AreEqual(6, v[6]);
Assert.AreEqual(42, v[7]);
Assert.AreEqual(42, v[8]);
Assert.AreEqual(42, v[9]);
}
/**
* Removes the bookmark entries for a number of page ranges. The page ranges
* consists of a number of pairs with the start/end page range. The page numbers
* are inclusive.
* @param list the bookmarks
* @param pageRange the page ranges, always in pairs.
*/
public static void EliminatePages(IList <Dictionary <String, Object> > list, int[] pageRange)
{
if (list == null)
{
return;
}
for (ListIterator <Dictionary <String, Object> > it = new ListIterator <Dictionary <string, object> >(list); it.HasNext();)
{
Dictionary <String, Object> map = it.Next();
bool hit = false;
if (map.ContainsKey("Action") && "GoTo".Equals(map["Action"]))
{
String page = null;
if (map.ContainsKey("Page"))
{
page = (String)map["Page"];
}
if (page != null)
{
page = page.Trim();
int idx = page.IndexOf(' ');
int pageNum;
if (idx < 0)
{
pageNum = int.Parse(page);
}
else
{
pageNum = int.Parse(page.Substring(0, idx));
}
int len = pageRange.Length & 0x7ffffffe;
for (int k = 0; k < len; k += 2)
{
if (pageNum >= pageRange[k] && pageNum <= pageRange[k + 1])
{
hit = true;
break;
}
}
}
}
IList <Dictionary <String, Object> > kids = null;
if (map.ContainsKey("Kids"))
{
kids = (IList <Dictionary <String, Object> >)map["Kids"];
}
if (kids != null)
{
EliminatePages(kids, pageRange);
if (kids.Count == 0)
{
map.Remove("Kids");
kids = null;
}
}
if (hit)
{
if (kids == null)
{
it.Remove();
}
else
{
map.Remove("Action");
map.Remove("Page");
map.Remove("Named");
}
}
}
}
internal static extern Error FT_List_Iterate(IntPtr list, ListIterator iterator, IntPtr user);
public IAC_ListIterator(List <E> l, int location)
{
iterator = l.listIterator(location);
}
public static ListIterator <T> FindIf <T>(ListIterator <T> begin, ListIterator <T> end, Functional.UnaryPredicate <T> func)
{
return((ListIterator <T>)FindIf((InputIterator <T>)begin, (InputIterator <T>)end, func));
}
/// <exception cref="NBoilerpipe.BoilerpipeProcessingException"></exception>
public bool Process(TextDocument doc)
{
IList <TextBlock> textBlocks = doc.GetTextBlocks();
if (textBlocks.Count < 2)
{
return(false);
}
int maxNumWords = -1;
TextBlock largestBlock = null;
int level = -1;
int i = 0;
int n = -1;
foreach (TextBlock tb in textBlocks)
{
if (tb.IsContent())
{
int nw = tb.GetNumWords();
if (nw > maxNumWords)
{
largestBlock = tb;
maxNumWords = nw;
n = i;
if (expandToSameLevelText)
{
level = tb.GetTagLevel();
}
}
}
i++;
}
foreach (TextBlock tb_1 in textBlocks)
{
if (tb_1 == largestBlock)
{
tb_1.SetIsContent(true);
}
else
{
tb_1.SetIsContent(false);
tb_1.AddLabel(DefaultLabels.MIGHT_BE_CONTENT);
}
}
if (expandToSameLevelText && n != -1)
{
for (ListIterator <TextBlock> it = textBlocks.ListIterator(n); it.HasPrevious();)
{
TextBlock tb_2 = it.Previous();
int tl = tb_2.GetTagLevel();
if (tl < level)
{
break;
}
else
{
if (tl == level)
{
tb_2.SetIsContent(true);
}
}
}
for (ListIterator <TextBlock> it_1 = textBlocks.ListIterator(n); it_1.HasNext();)
{
TextBlock tb_2 = it_1.Next();
int tl = tb_2.GetTagLevel();
if (tl < level)
{
break;
}
else
{
if (tl == level)
{
tb_2.SetIsContent(true);
}
}
}
}
return(true);
}
public void Initializing()
{
this.initializingCollection = new int[] { 1, 2, 3 };
this.listIterator = new ListIterator <int>(this.initializingCollection);
}
public void ShouldThrowIfNullCollectionIsPassed()
{
ListIterator collection = null;
Assert.Throws <ArgumentNullException>(() => collection = new ListIterator(null), "Passed collection was empty!");
}
internal void Propagate(PdfObject obj, PdfIndirectReference refo, bool restricted)
{
if (obj == null)
{
return;
}
// if (refo != null)
// AddToBody(obj, refo);
if (obj is PdfIndirectReference)
{
return;
}
switch (obj.Type)
{
case PdfObject.DICTIONARY:
case PdfObject.STREAM: {
PdfDictionary dic = (PdfDictionary)obj;
foreach (PdfName key in dic.Keys)
{
if (restricted && (key.Equals(PdfName.PARENT) || key.Equals(PdfName.KIDS)))
{
continue;
}
PdfObject ob = dic.Get(key);
if (ob != null && ob.IsIndirect())
{
PRIndirectReference ind = (PRIndirectReference)ob;
if (!SetVisited(ind) && !IsPage(ind))
{
PdfIndirectReference refi = GetNewReference(ind);
Propagate(PdfReader.GetPdfObjectRelease(ind), refi, restricted);
}
}
else
{
Propagate(ob, null, restricted);
}
}
break;
}
case PdfObject.ARRAY: {
//PdfArray arr = new PdfArray();
for (ListIterator <PdfObject> it = ((PdfArray)obj).GetListIterator(); it.HasNext();)
{
PdfObject ob = it.Next();
if (ob != null && ob.IsIndirect())
{
PRIndirectReference ind = (PRIndirectReference)ob;
if (!IsVisited(ind) && !IsPage(ind))
{
PdfIndirectReference refi = GetNewReference(ind);
Propagate(PdfReader.GetPdfObjectRelease(ind), refi, restricted);
}
}
else
{
Propagate(ob, null, restricted);
}
}
break;
}
case PdfObject.INDIRECT: {
throw new Exception(MessageLocalization.GetComposedMessage("reference.pointing.to.reference"));
}
}
}
public void TestInitialization()
{
this.initializingCollection = new string[] { "asd", "qwe", "zxc" };
this.listIterator = new ListIterator(this.initializingCollection);
}
public void CreateWithNullParameter()
{
Assert.Throws <ArgumentNullException>(() => this.sut = new ListIterator <string>(null));
}
internal virtual void alignWords(LinkedList linkedList, NISTAlign.StringRenderer stringRenderer)
{
ListIterator listIterator = this.referenceItems.listIterator();
ListIterator listIterator2 = this.hypothesisItems.listIterator();
object obj = null;
object obj2 = null;
this.alignedReferenceWords = new LinkedList();
this.alignedHypothesisWords = new LinkedList();
for (int i = linkedList.size() - 2; i >= 0; i--)
{
int num = ((Integer)linkedList.get(i)).intValue();
string text;
if (num != 2)
{
obj = listIterator.next();
text = stringRenderer.getRef(obj, obj2);
}
else
{
text = null;
}
string text2;
if (num != 3)
{
obj2 = listIterator2.next();
text2 = stringRenderer.getHyp(obj, obj2);
}
else
{
text2 = null;
}
switch (num)
{
case 1:
text = String.instancehelper_toUpperCase(text);
text2 = String.instancehelper_toUpperCase(text2);
break;
case 2:
text2 = String.instancehelper_toUpperCase(text2);
break;
case 3:
text = String.instancehelper_toUpperCase(text);
break;
}
if (text == null)
{
text = String.instancehelper_substring("********************************************", 0, String.instancehelper_length(text2));
}
if (text2 == null)
{
text2 = String.instancehelper_substring("********************************************", 0, String.instancehelper_length(text));
}
if (String.instancehelper_length(text) > String.instancehelper_length(text2))
{
text2 = String.instancehelper_concat(text2, String.instancehelper_substring(" ", 0, String.instancehelper_length(text) - String.instancehelper_length(text2)));
}
else if (String.instancehelper_length(text) < String.instancehelper_length(text2))
{
text = String.instancehelper_concat(text, String.instancehelper_substring(" ", 0, String.instancehelper_length(text2) - String.instancehelper_length(text)));
}
this.alignedReferenceWords.add(text);
this.alignedHypothesisWords.add(text2);
}
}
public void EmptyListDoesNotHaveNextElement()
{
this.sut = new ListIterator <string>(new string[0]);
Assert.False(this.sut.HasNext());
}
public static ListIterator <T> MinElement <T>(ListIterator <T> begin, ListIterator <T> end, Functional.BinaryPredicate <T> func)
{
return((ListIterator <T>)MinElement((ForwardIterator <T>)begin, (ForwardIterator <T>)end, func));
}
public static ListIterator <T> Unique <T>(ListIterator <T> begin, ListIterator <T> end, IEqualityComparer <T> comp)
{
return(Unique((ForwardIterator <T>)begin, (ForwardIterator <T>)end, comp) as ListIterator <T>);
}
public static ListIterator <T> MinElement <T>(ListIterator <T> begin, ListIterator <T> end, Comparison <T> comp)
{
return((ListIterator <T>)MinElement((ForwardIterator <T>)begin, (ForwardIterator <T>)end, comp));
}
/// <exception cref="Org.Apache.Hadoop.Yarn.Server.Resourcemanager.Reservation.Exceptions.PlanningException
/// "/>
/// <exception cref="Org.Apache.Hadoop.Yarn.Server.Resourcemanager.Reservation.Exceptions.ContractValidationException
/// "/>
private bool ComputeAllocation(ReservationId reservationId, string user, Plan plan
, ReservationDefinition contract, ReservationAllocation oldReservation)
{
Log.Info("placing the following ReservationRequest: " + contract);
Resource totalCapacity = plan.GetTotalCapacity();
// Here we can addd logic to adjust the ResourceDefinition to account for
// system "imperfections" (e.g., scheduling delays for large containers).
// Align with plan step conservatively (i.e., ceil arrival, and floor
// deadline)
long earliestStart = contract.GetArrival();
long step = plan.GetStep();
if (earliestStart % step != 0)
{
earliestStart = earliestStart + (step - (earliestStart % step));
}
long deadline = contract.GetDeadline() - contract.GetDeadline() % plan.GetStep();
// setup temporary variables to handle time-relations between stages and
// intermediate answers
long curDeadline = deadline;
long oldDeadline = -1;
IDictionary <ReservationInterval, ReservationRequest> allocations = new Dictionary
<ReservationInterval, ReservationRequest>();
RLESparseResourceAllocation tempAssigned = new RLESparseResourceAllocation(plan.GetResourceCalculator
(), plan.GetMinimumAllocation());
IList <ReservationRequest> stages = contract.GetReservationRequests().GetReservationResources
();
ReservationRequestInterpreter type = contract.GetReservationRequests().GetInterpreter
();
// Iterate the stages in backward from deadline
for (ListIterator <ReservationRequest> li = stages.ListIterator(stages.Count); li.
HasPrevious();)
{
ReservationRequest currentReservationStage = li.Previous();
// validate the RR respect basic constraints
ValidateInput(plan, currentReservationStage, totalCapacity);
// run allocation for a single stage
IDictionary <ReservationInterval, ReservationRequest> curAlloc = PlaceSingleStage(
plan, tempAssigned, currentReservationStage, earliestStart, curDeadline, oldReservation
, totalCapacity);
if (curAlloc == null)
{
// if we did not find an allocation for the currentReservationStage
// return null, unless the ReservationDefinition we are placing is of
// type ANY
if (type != ReservationRequestInterpreter.RAny)
{
throw new PlanningException("The GreedyAgent" + " couldn't find a valid allocation for your request"
);
}
else
{
continue;
}
}
else
{
// if we did find an allocation add it to the set of allocations
allocations.PutAll(curAlloc);
// if this request is of type ANY we are done searching (greedy)
// and can return the current allocation (break-out of the search)
if (type == ReservationRequestInterpreter.RAny)
{
break;
}
// if the request is of ORDER or ORDER_NO_GAP we constraint the next
// round of allocation to precede the current allocation, by setting
// curDeadline
if (type == ReservationRequestInterpreter.ROrder || type == ReservationRequestInterpreter
.ROrderNoGap)
{
curDeadline = FindEarliestTime(curAlloc.Keys);
// for ORDER_NO_GAP verify that the allocation found so far has no
// gap, return null otherwise (the greedy procedure failed to find a
// no-gap
// allocation)
if (type == ReservationRequestInterpreter.ROrderNoGap && oldDeadline > 0)
{
if (oldDeadline - FindLatestTime(curAlloc.Keys) > plan.GetStep())
{
throw new PlanningException("The GreedyAgent" + " couldn't find a valid allocation for your request"
);
}
}
// keep the variable oldDeadline pointing to the last deadline we
// found
oldDeadline = curDeadline;
}
}
}
// / If we got here is because we failed to find an allocation for the
// ReservationDefinition give-up and report failure to the user
if (allocations.IsEmpty())
{
throw new PlanningException("The GreedyAgent" + " couldn't find a valid allocation for your request"
);
}
// create reservation with above allocations if not null/empty
ReservationRequest ZeroRes = ReservationRequest.NewInstance(Resource.NewInstance(
0, 0), 0);
long firstStartTime = FindEarliestTime(allocations.Keys);
// add zero-padding from arrival up to the first non-null allocation
// to guarantee that the reservation exists starting at arrival
if (firstStartTime > earliestStart)
{
allocations[new ReservationInterval(earliestStart, firstStartTime)] = ZeroRes;
firstStartTime = earliestStart;
}
// consider to add trailing zeros at the end for simmetry
// Actually add/update the reservation in the plan.
// This is subject to validation as other agents might be placing
// in parallel and there might be sharing policies the agent is not
// aware off.
ReservationAllocation capReservation = new InMemoryReservationAllocation(reservationId
, contract, user, plan.GetQueueName(), firstStartTime, FindLatestTime(allocations
.Keys), allocations, plan.GetResourceCalculator(), plan.GetMinimumAllocation());
if (oldReservation != null)
{
return(plan.UpdateReservation(capReservation));
}
else
{
return(plan.AddReservation(capReservation));
}
}
public static ListIterator <T> MinElement <T>(ListIterator <T> begin, ListIterator <T> end)
where T : IComparable <T>
{
return((ListIterator <T>)MinElement((ForwardIterator <T>)begin, (ForwardIterator <T>)end));
}
/**
* Removes the bookmark entries for a number of page ranges. The page ranges
* consists of a number of pairs with the start/end page range. The page numbers
* are inclusive.
* @param list the bookmarks
* @param pageRange the page ranges, always in pairs.
*/
public static void EliminatePages(ArrayList list, int[] pageRange)
{
if (list == null)
{
return;
}
for (ListIterator it = new ListIterator(list); it.HasNext();)
{
Hashtable map = (Hashtable)it.Next();
bool hit = false;
if ("GoTo".Equals(map["Action"]))
{
String page = (String)map["Page"];
if (page != null)
{
page = page.Trim();
int idx = page.IndexOf(' ');
int pageNum;
if (idx < 0)
{
pageNum = int.Parse(page);
}
else
{
pageNum = int.Parse(page.Substring(0, idx));
}
int len = pageRange.Length & 0x7ffffffe;
for (int k = 0; k < len; k += 2)
{
if (pageNum >= pageRange[k] && pageNum <= pageRange[k + 1])
{
hit = true;
break;
}
}
}
}
ArrayList kids = (ArrayList)map["Kids"];
if (kids != null)
{
EliminatePages(kids, pageRange);
if (kids.Count == 0)
{
map.Remove("Kids");
kids = null;
}
}
if (hit)
{
if (kids == null)
{
it.Remove();
}
else
{
map.Remove("Action");
map.Remove("Page");
map.Remove("Named");
}
}
}
}
/// <summary>
/// Generates a list of numbers from a string.
/// </summary>
/// <param name="ranges">the comma separated ranges</param>
/// <param name="maxNumber">the maximum number in the range</param>
/// <returns>a list with the numbers as Integer </returns>
public static ArrayList Expand(string ranges, int maxNumber)
{
var parse = new SequenceList(ranges);
var list = new ArrayList();
var sair = false;
while (!sair)
{
sair = parse.GetAttributes();
if (parse.Low == -1 && parse.High == -1 && !parse.Even && !parse.Odd)
{
continue;
}
if (parse.Low < 1)
{
parse.Low = 1;
}
if (parse.High < 1 || parse.High > maxNumber)
{
parse.High = maxNumber;
}
if (parse.Low > maxNumber)
{
parse.Low = maxNumber;
}
//System.out.Println("low="+parse.low+",high="+parse.high+",odd="+parse.odd+",even="+parse.even+",inverse="+parse.inverse);
var inc = 1;
if (parse.Inverse)
{
if (parse.Low > parse.High)
{
var t = parse.Low;
parse.Low = parse.High;
parse.High = t;
}
for (var it = new ListIterator(list); it.HasNext();)
{
var n = (int)it.Next();
if (parse.Even && (n & 1) == 1)
{
continue;
}
if (parse.Odd && (n & 1) == 0)
{
continue;
}
if (n >= parse.Low && n <= parse.High)
{
it.Remove();
}
}
}
else
{
if (parse.Low > parse.High)
{
inc = -1;
if (parse.Odd || parse.Even)
{
--inc;
if (parse.Even)
{
parse.Low &= ~1;
}
else
{
parse.Low -= ((parse.Low & 1) == 1 ? 0 : 1);
}
}
for (var k = parse.Low; k >= parse.High; k += inc)
{
list.Add(k);
}
}
else
{
if (parse.Odd || parse.Even)
{
++inc;
if (parse.Odd)
{
parse.Low |= 1;
}
else
{
parse.Low += ((parse.Low & 1) == 1 ? 1 : 0);
}
}
for (var k = parse.Low; k <= parse.High; k += inc)
{
list.Add(k);
}
}
}
}
return(list);
}
/**
* Generates a list of numbers from a string.
* @param ranges the comma separated ranges
* @param maxNumber the maximum number in the range
* @return a list with the numbers as <CODE>Integer</CODE>
*/
public static ICollection <int> Expand(String ranges, int maxNumber)
{
SequenceList parse = new SequenceList(ranges);
List <int> list = new List <int>();
bool sair = false;
while (!sair)
{
sair = parse.GetAttributes();
if (parse.low == -1 && parse.high == -1 && !parse.even && !parse.odd)
{
continue;
}
if (parse.low < 1)
{
parse.low = 1;
}
if (parse.high < 1 || parse.high > maxNumber)
{
parse.high = maxNumber;
}
if (parse.low > maxNumber)
{
parse.low = maxNumber;
}
//System.out.Println("low="+parse.low+",high="+parse.high+",odd="+parse.odd+",even="+parse.even+",inverse="+parse.inverse);
int inc = 1;
if (parse.inverse)
{
if (parse.low > parse.high)
{
int t = parse.low;
parse.low = parse.high;
parse.high = t;
}
for (ListIterator <int> it = new ListIterator <int>(list); it.HasNext();)
{
int n = it.Next();
if (parse.even && (n & 1) == 1)
{
continue;
}
if (parse.odd && (n & 1) == 0)
{
continue;
}
if (n >= parse.low && n <= parse.high)
{
it.Remove();
}
}
}
else
{
if (parse.low > parse.high)
{
inc = -1;
if (parse.odd || parse.even)
{
--inc;
if (parse.even)
{
parse.low &= ~1;
}
else
{
parse.low -= ((parse.low & 1) == 1 ? 0 : 1);
}
}
for (int k = parse.low; k >= parse.high; k += inc)
{
list.Add(k);
}
}
else
{
if (parse.odd || parse.even)
{
++inc;
if (parse.odd)
{
parse.low |= 1;
}
else
{
parse.low += ((parse.low & 1) == 1 ? 1 : 0);
}
}
for (int k = parse.low; k <= parse.high; k += inc)
{
list.Add(k);
}
}
}
}
return(list);
}
public void Initialize()
{
args = new string[] { "Pesho", "Gosho", "Stamat", "Ivan" };
collection = new ListIterator(args);
}
private ListIterator (ListIterator other)
: base (other)
{
this.list = (IList) ((ICloneable) other.list).Clone ();
}
public float[] pullOutputs()
{
ListIterator<NetworkNode> iterhidden1 = new ListIterator<NetworkNode>(hlayer1);
ListIterator<NetworkNode> iterhidden2 = new ListIterator<NetworkNode>(hlayer2);
ListIterator<NetworkNode> iterout = new ListIterator<NetworkNode>(outlayer);
while(iterhidden1.hasNext()){
iterhidden1.next().Value.UpdateOutput();
}
while (iterhidden2.hasNext())
{
iterhidden2.next().Value.UpdateOutput();
}
while(iterout.hasNext()){
iterout.next().Value.UpdateOutput();
}
ListIterator<NetworkNode> iterfinal = new ListIterator<NetworkNode>(outlayer);
int i = 0;
float[] barray = new float[4];
while(iterfinal.hasNext()){
NetworkNode bob = iterfinal.next().Value;
barray[i] = (bob.getOutput())>0.6f?1:0;
i++;
}
return barray;
}
