Ejemplo n.º 1
0
 /*
  * Takes a set of sketch nodes, and returns an ArrayList<Integer> such that
  * arr.get(i) gives the index of the sketch node that node i is closest too.
  *
  * Need to work the return values a little bit. Make a proper data
  * structure.
  */
 public ArrayList<ArrayList<Integer>> distSketch(int len, Counter sketchNodes) {
   ArrayList<Integer> closestIndex = new ArrayList<Integer>();
   for (int i = 0; i < len; i++) closestIndex.set(i, -1);
   ArrayList<Double> closestDist = new ArrayList<Double>();
   for (int i = 0; i < len; i++) closestDist.set(i, Double.MAX_VALUE);
   ArrayList<ArrayList<Integer>> sketchReverseIndex = new ArrayList<ArrayList<Integer>>();
   for (int index : sketchNodes.keySet()) {
     Counter distances = this.bfs(index);
     for (int j = 0; j < len; j++) {
       double curDist = closestDist.get(j);
       double dist = distances.getPath(index);
       if (dist < curDist) {
         closestIndex.set(j, index);
       }
     }
     sketchReverseIndex.add(new ArrayList<Integer>());
   }
   for (int j = 0; j < len; j++) {
     int closest = closestIndex.get(j);
     sketchReverseIndex.get(closest).add(j);
   }
   // Return sketchReverseIndex, closestIndex forward index, and index
   // correspondence bimap
   return sketchReverseIndex;
 }
Ejemplo n.º 2
0
     public void sortFrontbyR(){
    
        sortByR = new ArrayList();
    
        for (int i = 0 ; i < Fronts.size() ; i++){
            
       
            ArrayList tempfront = (ArrayList) Fronts.get(i);
			
			for (int j = 0 ; j < tempfront.size() ; j++){
				
				for (int a = 0 ; a <  tempfront.size() ; a++){
			
					if (a > j){
						
						NSGAII.Solutions.QRTPSolution.OneSolution first = (NSGAII.Solutions.QRTPSolution.OneSolution) tempfront.get(j);
						double x  = first.getRecall();
						NSGAII.Solutions.QRTPSolution.OneSolution second = (NSGAII.Solutions.QRTPSolution.OneSolution) tempfront.get(a);
						double y  = second.getRecall();
						
						if (y > x){
						
							tempfront.set(j, second);
							tempfront.set(a, first);
						
						}else{}
					}        
				}      
			}   
			
			sortByR.add(tempfront);
		}
    

    }
Ejemplo n.º 3
0
  public int partition(int[] array, int index) {
    // the basics
    ArrayList<Integer> source = new ArrayList<Integer>();
    for (int c : array) source.add(new Integer(c));
    int wall = 0;
    int wall2 = 1;
    Integer pivot = source.get(index);

    // the switch
    source.set(index, source.get(source.size() - 1));
    source.set(source.size() - 1, pivot);

    // the loop
    Integer store = new Integer(0);
    for (int x = 0; x < source.size() - 1; x++) {
      if (source.get(x).compareTo(pivot) < 0) {
        swap(source, wall, x);
        wall++;
        wall2++;
      } else if (source.get(x).compareTo(pivot) == 0) {
        swap(source, wall2, x);
        wall2++;
      }
      //	      System.out.println(Arrays.toString(source.toArray()));
    }

    // the switch 2.0
    swap(source, wall, source.size() - 1);
    for (int x = 0; x < source.size(); x++) array[x] = source.get(x).intValue();
    return wall;
  }
Ejemplo n.º 4
0
  private static void getTopDocuments(int num, HashMap<String, Float> scoremap, String filename)
      throws FileNotFoundException {
    PrintWriter out = new PrintWriter(filename);
    Iterator<String> itr = scoremap.keySet().iterator();
    ArrayList<String> urls = new ArrayList<String>();
    ArrayList<Float> scores = new ArrayList<Float>();

    while (itr.hasNext()) {
      String key = itr.next();
      if (scores.size() < num) {
        scores.add(scoremap.get(key));
        urls.add(key);
      } else {
        int index = scores.indexOf(Collections.min(scores));
        if (scores.get(index) < scoremap.get(key)) {
          scores.set(index, scoremap.get(key));
          urls.set(index, key);
        }
      }
    }

    while (scores.size() > 0) {
      int index = scores.indexOf(Collections.max(scores));
      out.println(urls.get(index) + "\t" + scores.get(index));
      urls.remove(index);
      scores.remove(index);
    }
    out.close();
  }
Ejemplo n.º 5
0
  // Executes the given action
  public void executeAction(Action a) {

    // For each state variable, retrieve the DD for it, evaluate it
    // w.r.t. the current state and build a new state.
    ArrayList new_state = new ArrayList();
    int c;
    for (c = 0; c < (_nVars << 1); c++) {
      new_state.add("-");
    }
    for (c = 0; c < (_nVars << 1); c++) {
      Object cur_assign = _state.get(c);
      if (cur_assign instanceof Boolean) {
        // System.out.println(a._tmID2DD);
        int nonprime_id = c + 1;
        int prime_id = nonprime_id - _nVars;
        Object DD = a._tmID2DD.get(new Integer(prime_id));
        _state.set(prime_id - 1, TRUE);
        double p_true = _mdp._context.evaluate(DD, _state);
        // System.out.println("ID: " + nonprime_id + ", " + prime_id + ": " +
        //		   _mdp._context.printNode(DD) + " -> " +
        //		   _mdp._df.format(p_true));
        new_state.set(c, (_r.nextFloat() < p_true) ? TRUE : FALSE);
      }
    }

    _state = new_state;
  }
Ejemplo n.º 6
0
  public String toString(Molecule molecule) {
    // write header
    String returnString =
        String.format(
            "%%mem=%dGB\n%%nprocshared=%d\n#p geom=connect %s/genecp empiricaldispersion=gd3bj opt\n",
            mem, nprocshared, method);
    returnString += "\ntitle\n\n0 1\n";

    // write geometry
    returnString = returnString + molecule.getGJFstring() + "\n";

    // initialize some variables
    Atom fromAtom = null;
    Atom toAtom = null;
    Integer fromAtomNumber = 0;
    Integer toAtomNumber = 0;
    Double bondOrder = 0.0;
    DefaultWeightedEdge thisEdge = null;

    // read connectivity data into parallel arrays
    ArrayList<Integer> fromAtoms = new ArrayList<Integer>();
    ArrayList<Integer> toAtoms = new ArrayList<Integer>();
    ArrayList<Double> bondOrders = new ArrayList<Double>();
    ArrayList<Boolean> visited = new ArrayList<Boolean>();
    for (DefaultWeightedEdge e : molecule.connectivity.edgeSet()) {
      fromAtom = molecule.connectivity.getEdgeSource(e);
      fromAtomNumber = molecule.contents.indexOf(fromAtom) + 1;
      toAtom = molecule.connectivity.getEdgeTarget(e);
      toAtomNumber = molecule.contents.indexOf(toAtom) + 1;
      bondOrder = molecule.connectivity.getEdgeWeight(e);

      fromAtoms.add(fromAtomNumber);
      toAtoms.add(toAtomNumber);
      bondOrders.add(bondOrder);
      visited.add(false);
    }

    // write connectivity data
    for (int i = 0; i < molecule.contents.size(); i++) {
      returnString = returnString + (i + 1) + " ";
      for (int j = 0; j < fromAtoms.size(); j++) {
        if (fromAtoms.get(j) == i + 1 && visited.get(j) == false) {
          returnString =
              returnString + toAtoms.get(j) + " " + String.format("%.1f ", bondOrders.get(j));
          visited.set(j, true);
        }
        if (toAtoms.get(j) == i + 1 && visited.get(j) == false) {
          returnString =
              returnString + fromAtoms.get(j) + " " + String.format("%.1f ", bondOrders.get(j));
          visited.set(j, true);
        }
      }
      returnString = returnString + "\n";
    }

    // write footer
    returnString += String.format("\n@%s\n\n", basis);
    return returnString;
  }
Ejemplo n.º 7
0
 public void toggleFavorite(int index) {
   Board t = getItem(index);
   t.favorite = !t.favorite;
   mDataShown.set(index, t);
   mAllData.set(mAllData.indexOf(t), t);
   Log.i("debug", "State : " + t.favorite);
   super.notifyDataSetChanged();
 }
Ejemplo n.º 8
0
 // shuffle elements of AL "varList"
 public void shuffle() {
   int randomIndex;
   for (int i = numVars - 1; i > 0; i--) {
     // pick an index at random
     randomIndex = (int) ((i + 1) * Math.random());
     // swap the values at position i and randomIndex
     varList.set(i, varList.set(randomIndex, varList.get(i)));
   }
 }
Ejemplo n.º 9
0
 static void shuffle(ArrayList keys) {
   int size = keys.size();
   for (int i = size; i > 1; i--) {
     int r = rng.nextInt(i);
     Object t = keys.get(i - 1);
     keys.set(i - 1, keys.get(r));
     keys.set(r, t);
   }
 }
Ejemplo n.º 10
0
 public ArrayList<Integer> addPawnNum(Color color, ArrayList<Integer> pawnList) {
   for (int i = 0; i < COL_NUM; i++) {
     if (row.get(i).is(color, Piece.Type.PAWN)) {
       pawnList.set(i, pawnList.get(i) + 1);
     } else if (row.get(i).is(color, Piece.Type.PAWN)) {
       pawnList.set(i, pawnList.get(i) + 1);
     }
   }
   return pawnList;
 }
Ejemplo n.º 11
0
  // Shuffles Arraylist like a deck of cards
  private static ArrayList<Restaurant> shuffle(ArrayList<Restaurant> places) {
    int j = 0;
    Restaurant temp = null;

    // Randomly swaps one index with another
    for (int i = 0; i < places.size(); i++) {
      j = ThreadLocalRandom.current().nextInt(0, i + 1);
      temp = places.get(j);
      places.set(j, places.get(i));
      places.set(i, temp);
    }
    return places;
  }
  private void reconstructMoves(SearchNode searcher) {
    while (searcher != null) {
      solution.add(searcher.getObject());
      searcher = searcher.getParent();
    }

    for (int i = 0; i < solution.size() / 2; ++i) {
      T temp = solution.get(i);
      int other = solution.size() - i - 1;
      solution.set(i, solution.get(other));
      solution.set(other, temp);
    }
  }
Ejemplo n.º 13
0
 public static ArrayList<Card> bubblesort(ArrayList<Card> cards) {
   for (int i = 1; i < cards.size(); i++) {
     for (int j = 0; j < cards.size() - 1; j++) {
       // comparing cards by rank
       if (cards.get(j).getRank() > cards.get(j + 1).getRank()) {
         Card tempcard = cards.get(j);
         cards.set(j, cards.get(j + 1));
         cards.set(j + 1, tempcard);
       }
     }
   }
   return cards;
 }
  public <T extends Comparable<T>> void sortList(ArrayList<T> arr) {

    int i, j;
    T newValue;

    for (i = 1; i < arr.size(); i++) {
      newValue = arr.get(i);
      j = i;
      while (j > 0 && arr.get(j - 1).compareTo(newValue) > 0) {
        arr.set(j, arr.get(j - 1));
        j--;
      }
      arr.set(j, newValue);
    }
  }
Ejemplo n.º 15
0
  /** Tokenize string s into an array */
  public static String[] tokenize(String s) {
    ArrayList<String> r = new ArrayList<String>();
    String remain = s;
    int n = 0, pos;

    remain = remain.trim();
    while (remain.length() > 0) {
      if (remain.startsWith("\"")) {
        // Field in quotes
        pos = remain.indexOf('"', 1);
        if (pos == -1) break;
        r.add(remain.substring(1, pos));
        if (pos + 1 < remain.length()) pos++;
      } else {
        // Space-separated field
        pos = remain.indexOf(' ', 0);
        if (pos == -1) {
          r.add(remain);
          remain = "";
        } else r.add(remain.substring(0, pos));
      }
      remain = remain.substring(pos + 1);
      remain = remain.trim();
      // - is used as a placeholder for empy fields
      if (r.get(n).equals("-")) r.set(n, "");
      n++;
    }
    return r.toArray(new String[0]);
  }
Ejemplo n.º 16
0
  public int store(int offset) {
    int temp = pop();

    runStack.set(offset, temp);

    return offset;
  }
Ejemplo n.º 17
0
  public static void qsHelp(int lo, int hi, ArrayList<Book> d) {

    if (lo >= hi) return;

    int tmpLo = lo;
    int tmpHi = hi;
    Book pivot = d.get(lo);

    while (tmpLo < tmpHi) {
      // first, slide markers in as far as possible without swaps
      while (d.get(tmpLo).compareTo(pivot) < 0) {
        // System.out.println("2");
        tmpLo++;
      }
      while (d.get(tmpHi).compareTo(pivot) > 0) {
        // System.out.println("3");
        tmpHi--;
      }

      swap(tmpLo, tmpHi, d);
    }

    // pivot has been floating around... plant it where it belongs
    d.set(tmpLo, pivot);

    // recurse on lower and upper ranges
    qsHelp(lo, tmpLo - 1, d);
    qsHelp(tmpLo + 1, hi, d);
  } // end qsHelp
Ejemplo n.º 18
0
  private void fixTabs(int tabSize) {

    int rowIndex = 0;

    for (StringBuilder row1 : rows) {
      String row = row1.toString();
      StringBuilder newRow = new StringBuilder();

      char[] chars = row.toCharArray();
      for (char c : chars) {
        if (c == '\t') {
          int spacesLeft = tabSize - newRow.length() % tabSize;
          if (DEBUG) {
            System.out.println("Found tab. Spaces left: " + spacesLeft);
          }
          String spaces = StringUtils.repeatString(" ", spacesLeft);
          newRow.append(spaces);
        } else {
          String character = Character.toString(c);
          newRow.append(character);
        }
      }
      rows.set(rowIndex, newRow);
      rowIndex++;
    }
  }
  public void setColor(int index, int color) {
    int old_color = m_colors.get((index + 4 - m_rotation) % 4);
    m_colors.set((index + 4 - m_rotation) % 4, color);

    m_hash_code -= old_color;
    m_hash_code += color;
  }
 protected Collection<FileInfo> loadFileInfos(long fileId) {
   final ArrayList<FileInfo> infos = new ArrayList<FileInfo>();
   while (fileId != -1) {
     final Cursor cursor =
         myDatabase.rawQuery(
             "SELECT name,size,parent_id FROM Files WHERE file_id = " + fileId, null);
     if (cursor.moveToNext()) {
       FileInfo info = createFileInfo(fileId, cursor.getString(0), null);
       if (!cursor.isNull(1)) {
         info.FileSize = cursor.getLong(1);
       }
       infos.add(0, info);
       fileId = cursor.isNull(2) ? -1 : cursor.getLong(2);
     } else {
       fileId = -1;
     }
     cursor.close();
   }
   for (int i = 1; i < infos.size(); ++i) {
     final FileInfo oldInfo = infos.get(i);
     final FileInfo newInfo = createFileInfo(oldInfo.Id, oldInfo.Name, infos.get(i - 1));
     newInfo.FileSize = oldInfo.FileSize;
     infos.set(i, newInfo);
   }
   return infos;
 }
Ejemplo n.º 21
0
 public ChangeVO updateRow(
     int windowNo,
     int AD_Tab_ID,
     int queryResultID,
     int relRowNo,
     Map<String, String> context,
     boolean force) {
   if (context == null || context.size() == 0)
     return new ChangeVO(true, Msg.translate(m_context, "NoContext"));
   ArrayList<String[]> data = m_results.get(queryResultID);
   if (data == null || data.size() == 0)
     return new ChangeVO(true, Msg.translate(m_context, "CachedDataNotFound"));
   UITab tab = getTab(AD_Tab_ID);
   if (tab == null) {
     log.config("Not found AD_Tab_ID=" + AD_Tab_ID);
     return new ChangeVO(true, Msg.translate(m_context, "@NotFound@ @AD_Tab_ID@=" + AD_Tab_ID));
   }
   CContext ctx = new CContext(m_context.entrySet());
   ctx.addWindow(windowNo, context);
   ChangeVO retValue;
   if (force) retValue = tab.saveRow(ctx, windowNo, false, null);
   else retValue = tab.saveRow(ctx, windowNo, false, data.get(relRowNo));
   if (retValue.hasError()) return retValue;
   // Update Results
   String[] dataRow = retValue.rowData.clone();
   data.set(relRowNo, dataRow);
   postProcessChangeVO(retValue, windowNo, context, dataRow, tab);
   retValue.trxInfo = GridTab.getTrxInfo(tab.getTableName(), ctx, windowNo, tab.getTabNo());
   if (retValue.isRefreshAll()) {}
   return retValue;
 }
Ejemplo n.º 22
0
  public static void recSort(ArrayList<Integer> arr, int left, int right) {

    if (left >= right) return;

    int mid = (left + right) / 2;

    recSort(arr, left, mid);
    recSort(arr, mid + 1, right);

    // combine

    ArrayList<Integer> copy = new ArrayList<Integer>();

    // MERGE
    int a = left;
    int b = mid + 1;

    while (a <= mid && b <= right) {
      int cmp;
      cmp = arr.get(a) - arr.get(b);

      if (cmp < 0) copy.add(arr.get(a++));
      else copy.add(arr.get(b++));
    }

    while (a <= mid) copy.add(arr.get(a++));
    while (b <= right) copy.add(arr.get(b++));

    // Put back
    int c = 0;
    for (int i = left; i <= right; i++) arr.set(i, copy.get(c++));
  }
Ejemplo n.º 23
0
  /** if some pages are too old, remove them */
  public void removeOldPages() {
    // the oldest page is in the front of the list, and the most recent page is in the tail of the
    // list
    int duration = curTime - pageStartTimes.get(0).start_time;
    int count = 0;

    // pay special attention to >=, if ==, still need to go ahead.
    while (duration >= Configuration.T_period) {
      count++;
      if (count >= pageStartTimes.size()) break;
      duration = curTime - pageStartTimes.get(count).start_time + 1;
    }

    // all previous data need to be erased.
    for (int i = 0; i < count - 1; i++) {
      m_pStorageManager.deleteByteArray(pageStartTimes.get(i).pageId);
    }

    // shifting, move all the data Item to the front of the list
    for (int j = count - 1; j >= 0 && j < pageStartTimes.size(); j++) {
      pageStartTimes.set(j - count + 1, pageStartTimes.get(j));
    }

    // erase the data at the tail after shifting
    for (int i = 0; i < count - 1; i++) {
      pageStartTimes.remove(pageStartTimes.size() - 1);
    }
  }
Ejemplo n.º 24
0
 public void drawOrbits(ArrayList alObjectsArchive) {
   //  println("SIZE:" + alObjectsArchive.size());
   //  ArrayList alObjectsArchive = timeline.getObjectStateArchive();
   ArrayList alPrevPos = new ArrayList();
   ArrayList alColors = new ArrayList();
   alColors.add(color(255, 0, 0));
   alColors.add(color(255, 255, 0));
   alColors.add(color(255, 0, 255));
   //  for (int i = timeline.getTimeIdx(); i >= 0 && i > (timeline.getTimeIdx() - 1 - 100); i--)
   for (int i = 0; i < alObjectsArchive.size(); i++) {
     ArrayList objects = (ArrayList) alObjectsArchive.get(i);
     for (int j = 0; j < objects.size(); j++) {
       CelestialObject obj = (CelestialObject) objects.get(j);
       //      CelestialObject obj = (CelestialObject)objects.get(1);
       PVector pos = obj.getPosition();
       //      stroke(0, 0, 255);
       stroke((Integer) alColors.get(j));
       if (alPrevPos.size() == objects.size()) {
         PVector prevPos = (PVector) alPrevPos.get(j);
         line(prevPos.x, prevPos.y, pos.x, pos.y);
         alPrevPos.set(j, pos);
       } else alPrevPos.add(pos);
     }
   }
 }
Ejemplo n.º 25
0
 public static void main(String[] args) throws IOException {
   // Use BufferedReader rather than RandomAccessFile; it's much faster
   BufferedReader f = new BufferedReader(new FileReader("badrand.in"));
   // input file name goes above
   PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("badrand.out")));
   // Use StringTokenizer vs. readLine/split -- lots faster
   StringTokenizer st = new StringTokenizer(f.readLine());
   // Get line, break into tokens
   int i1 = Integer.parseInt(st.nextToken()); // first integer
   ArrayList squares = new ArrayList<Integer>(10000);
   int mark = 0;
   i1 = middleSquare(i1);
   while (i1 > 0) {
     if (squares.contains(i1)) {
       squares.add(i1);
       squares.set(squares.indexOf(i1), 10000);
       mark = i1;
       i1 = 0;
     } else {
       squares.add(i1);
       i1 = middleSquare(i1);
     }
   }
   squares.add(10000);
   squares.add(0);
   out.println(squares.indexOf(mark) + 1);
   out.close(); // close the output file
   System.exit(0); // don't omit this!
 }
Ejemplo n.º 26
0
 public static void madLibber(Scanner inputText) {
   ArrayList<String> paragraph = new ArrayList<>();
   while (inputText.hasNextLine()) {
     paragraph.add(inputText.nextLine());
   }
   int index1 = 0;
   int index2 = 0;
   String word;
   String userWord;
   for (int i = 0; i < paragraph.size(); i++) {
     while (paragraph.get(i).indexOf("[") != -1) {
       index1 = paragraph.get(i).indexOf("[");
       index2 = paragraph.get(i).indexOf("]");
       word = paragraph.get(i).substring(index1 + 1, index2);
       System.out.print("Pick a(n) " + word + ":");
       userWord = input.next();
       paragraph.set(
           i,
           paragraph.get(i).substring(0, index1)
               + userWord
               + paragraph.get(i).substring(index2 + 1));
     }
     index1 = 0;
     index2 = 0;
   }
   System.out.println("\n---\n");
   for (int i = 0; i < paragraph.size(); i++) {
     System.out.println(paragraph.get(i));
   }
 }
Ejemplo n.º 27
0
    @Override
    public void reduce(Text key, Iterable<Text> values, Context context)
        throws IOException, InterruptedException {
      Hashtable<String, Integer> wordCounts = new Hashtable<String, Integer>();
      ArrayList docName = new ArrayList<String>();
      LinkedList wordName = new LinkedList<String>();
      while (values.iterator().hasNext()) {
        String[] items = values.iterator().next().toString().split("@");
        if (!wordName.contains(items[0])) {
          wordName.add(items[0]);
        }
        String[] keys = items[1].split(":|,");
        for (int i = 0; i < keys.length; i += 2) {
          if (!docName.contains(keys[i])) {
            docName.add(keys[i]);
            wordCounts.put(keys[i], 0);
          }
          int tmp = wordCounts.get(keys[i]);
          tmp += Integer.parseInt(keys[i + 1]);
          wordCounts.put(keys[i], tmp);
        }
      }

      for (int i = 0; i < docName.size() - 1; ++i) {
        for (int j = i + 1; j < docName.size(); ++j) {
          if (wordCounts.get(docName.get(i)) < wordCounts.get(docName.get(j))) {
            String stmp = docName.get(i).toString();
            docName.set(i, docName.get(j).toString());
            docName.set(j, stmp);
          }
        }
      }

      String retKey = wordName.get(0).toString();
      for (int i = 1; i < wordName.size(); ++i) {
        retKey += "," + wordName.get(i);
      }

      String retValue =
          ""; // ="\n" + docName.get(0).toString() + ":" +
              // wordCounts.get(docName.get(0).toString());
      for (int i = 0; i < docName.size(); ++i) {
        retValue +=
            "\n" + docName.get(i).toString() + ": " + wordCounts.get(docName.get(i).toString());
      }
      context.write(new Text(retKey), new Text(retValue));
    }
Ejemplo n.º 28
0
  // Derives QFunctions for the given value function and simulates the
  // greedy policy for the given number of trials and steps per trial.
  // Returns final value of every trial.
  public ArrayList simulate(int trials, int steps, long rand_seed) {
    ArrayList values = new ArrayList();
    _r = new Random(rand_seed);

    for (int trial = 1; trial <= trials; trial++) {

      System.out.println("\n -----------\n   Trial " + trial + "\n -----------");

      // Initialize state
      _state = new ArrayList();
      _nVars = _mdp._alVars.size();
      for (int c = 0; c < (_nVars << 1); c++) {
        _state.add("-");
      }
      Iterator i = _mdp._alVars.iterator();
      _vars = new TreeSet();
      while (i.hasNext()) {
        String s = (String) i.next();
        if (!s.endsWith("\'")) {
          Integer gid = (Integer) _mdp._tmVar2ID.get(s);
          _vars.add(gid);

          // Note: assign level (level is gid-1 b/c gids in order)
          _state.set(gid.intValue() - 1, _r.nextBoolean() ? TRUE : FALSE);
        }
      }
      // System.out.println(_mdp._context.printNode(_mdp._valueDD) + "\n" + _state);
      double reward = _mdp._context.evaluate(_mdp._rewardDD, _state);
      System.out.print(" " + PrintState(_state) + "  " + MDP._df.format(reward));

      // Run steps
      for (int step = 1; step <= steps; step++) {

        // Get action
        Action a;
        if (_bUseBasis) {
          a = getBasisAction();
        } else {
          a = getAction();
        }

        // Execute action
        executeAction(a);

        // Update reward
        reward =
            (_mdp._bdDiscount.doubleValue() * reward)
                + _mdp._context.evaluate(_mdp._rewardDD, _state);

        System.out.println(", a=" + a._sName);
        System.out.print(
            " " + PrintState(_state) + "  " + MDP._df.format(reward) + ": " + "Step " + step);
      }
      values.add(new Double(reward));
      System.out.println();
    }

    return values;
  }
Ejemplo n.º 29
0
 /**
  * Returns the indices of all scopes called by the given one.
  *
  * @param node source node index
  * @return destination node indices
  * @throws QueryException if a variable directly calls itself
  */
 private int[] adjacentTo(final int node) throws QueryException {
   int[] adj = adjacent.get(node);
   if (adj == null) {
     adj = neighbors(scopes.get(node));
     adjacent.set(node, adj);
   }
   return adj;
 }
 public ShardIterator preferNodeActiveInitializingShardsIt(String nodeId) {
   ArrayList<ShardRouting> ordered =
       new ArrayList<>(activeShards.size() + allInitializingShards.size());
   // fill it in a randomized fashion
   for (ShardRouting shardRouting : shuffler.shuffle(activeShards)) {
     ordered.add(shardRouting);
     if (nodeId.equals(shardRouting.currentNodeId())) {
       // switch, its the matching node id
       ordered.set(ordered.size() - 1, ordered.get(0));
       ordered.set(0, shardRouting);
     }
   }
   if (!allInitializingShards.isEmpty()) {
     ordered.addAll(allInitializingShards);
   }
   return new PlainShardIterator(shardId, ordered);
 }