/** * Searches this list for the specified object and returns the index of the * first occurrence. * * @param object * the object to search for. * @return the index of the first occurrence of the object, or -1 if it was * not found. */ public virtual int indexOf(Object obj) { ListIterator <E> it = listIterator(); if (obj != null) { while (it.hasNext()) { if (obj.equals(it.next())) { return(it.previousIndex()); } } } else { while (it.hasNext()) { if (it.next() == null) { return(it.previousIndex()); } } } return(-1); }
private void testListIterator(List <DSInteger> the_list) { ListIterator <DSInteger> it = the_list.listIterator(); int count = 0; while (it.hasNext()) { count++; it.next(); } //you are at the last item, not one before the first item when the //initial loop begins count--; while (it.hasPrevious()) { count--; it.previous(); } Assert.AreEqual(0, count); //test values returned it = the_list.listIterator(); Assert.AreEqual(30, it.next().value); Assert.AreEqual(60, it.next().value); //test removal DSInteger removed = it.remove(); Assert.AreEqual(60, removed.value); Assert.AreEqual(90, it.next().value); it.next(); //120 it.next(); //150 //test removing the last item Assert.AreEqual(false, it.hasNext()); Assert.AreEqual(150, it.remove().value); Assert.AreEqual(false, it.hasNext()); Assert.AreEqual(90, it.previous().value); Assert.AreEqual(true, it.hasNext()); Assert.AreEqual(120, it.next().value); //test removing the first item the_list.clear(); addInitialItems(the_list); it = the_list.listIterator(); Assert.AreEqual(false, it.hasPrevious()); Assert.AreEqual(30, it.next().value); it.remove(); Assert.AreEqual(false, it.hasPrevious()); Assert.AreEqual(60, it.next().value); Assert.AreEqual(90, it.next().value); Assert.AreEqual(60, it.previous().value); Assert.AreEqual(false, it.hasPrevious()); }
private static int[] CountPaths(int start, int end, int maxDistancia, bool countHops) { List <Situacao> situacoes = new List <Situacao>(); LinkedList Distancias = new LinkedList(); Situacao current = new Situacao { Ponto = start, Distancia = 0 }; //initialize current /* note: this loop is organized counter-intuitively. this is to insure that * start is never current when we're checking if we've found a path. otherwise * when start==end we would always find a Distancia-0 path and there's never one */ while (true) { LinkedList neighborList = getNeighbors(current.Ponto); //get neighbor list ListIterator i = neighborList.listIterator(0); while (i.hasNext()) { Ponto neighbor = (Ponto)i.next(); //for each neighbor int DistanciaFromStart = current.Distancia; if (countHops) { DistanciaFromStart += 1; } else { DistanciaFromStart += neighbor.Distancia; } if (DistanciaFromStart <= maxDistancia) //if within range, add to queue { situacoes.Add(new Situacao { Ponto = neighbor.Valor, Distancia = DistanciaFromStart }); } } try { current = (Situacao)situacoes.removeFirst(); //try to get next node to explore } catch { break; } //break if none if (current.Ponto == end) //if we found another path to end { Distancias.add(current.Distancia); //take down its Distancia } } return(listToArray(Distancias)); }
public override E set(int location, E obj) { ListIterator <E> it = listIterator(location); if (!it.hasNext()) { throw new java.lang.IndexOutOfBoundsException(); } E result = it.next(); it.set(obj); return(result); }
public Model add(List l) { ListIterator iter = l.listIterator(); while (iter.hasNext()) { Object obj = iter.next(); if (obj is Statement) { this._g.Assert(JenaConverter.FromJena((Statement)obj, this._mapping)); } } return(this); }
public static int ShortestPath(int start, int end) { var Situacao = new Situacao[27]; Situacao[start] = new Situacao { Distancia = 0, Status = false }; int current = start; do { LinkedList neighborList = getNeighbors(current); //get neighbors ListIterator i = neighborList.listIterator(0); while (i.hasNext()) //for each neighbor { Ponto neighbor = (Ponto)i.next(); int DistanciaThroughCurrent = Situacao[current].Distancia + neighbor.Distancia; if (Situacao[neighbor.Valor] == null) //if we've never seen it before { // add it to Situacao list Situacao[neighbor.Valor] = new Situacao { Distancia = DistanciaThroughCurrent, Status = false }; } //if we've found a shorter path else if (Situacao[neighbor.Valor].Distancia > DistanciaThroughCurrent) { Situacao[neighbor.Valor].Distancia = DistanciaThroughCurrent; //change Distancia } } //done going through neighbors Situacao[current].Status = true; //we should never come back to the current node if (current == end) // This only happens on the first iteration since { Situacao[current] = null; // it is the loop exit condition, so if its true then } // current == start == end. We want to find this node again // so we pretend we haven't seen it yet current = GetClosest(Situacao); //the next node is the closest onea if (current == -1) { throw new Exception("No such path"); //if no more next nodes } } while (current != end); return(Situacao[end].Distancia); }
private string toString(LinkedList linkedList) { if (linkedList == null || linkedList.isEmpty()) { return(""); } StringBuilder stringBuilder = new StringBuilder(); ListIterator listIterator = linkedList.listIterator(); while (listIterator.hasNext()) { stringBuilder.append(listIterator.next()).append(' '); } stringBuilder.setLength(stringBuilder.length() - 1); return(stringBuilder.toString()); }
} //in the list, so we could get two with different wieghts if //the input is careless public static int Distance(int v1, int v2) { CheckValid(v1); CheckValid(v2); ListIterator i = nodeList[v1].listIterator(0); while (i.hasNext()) { Ponto current = (Ponto)i.next(); //get the next edge in the adjacency-list if (current.node == v2) { return(current.distance); } } throw new Exception("No such edge"); }
internal virtual void optimize() { for (int i = 0; i < this.arcList.size(); i++) { GrammarArc grammarArc = (GrammarArc)this.arcList.get(i); this.arcList.set(i, this.optimizeArc(grammarArc)); } if (this.isEmpty()) { ListIterator listIterator = this.arcList.listIterator(); while (listIterator.hasNext()) { GrammarArc grammarArc = (GrammarArc)listIterator.next(); if (this == grammarArc.getGrammarNode()) { listIterator.remove(); } } } }
public bool hasNext() { return(iterator.hasNext()); }
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 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; }