/**
   * Private helper method for performing fast intersection.
   *
   * @param <E>
   * @param sortedData
   * @param sortedQueries
   * @param result
   */
  private static <E extends Comparable<E>> void fastIntersect(
      List<E> sortedData, List<E> sortedQueries, SortedSet<E> result) {

    int medianQueryIndex = sortedQueries.size() / 2;
    E medianQuery = sortedQueries.get(medianQueryIndex);

    int index = Collections.binarySearch(sortedData, medianQuery);

    if (index >= 0) {
      result.add(medianQuery);
    } else {
      index = (-1 * index) + 1;
    }

    if (index - 1 >= 0 && medianQueryIndex - 1 >= 0) {
      fastIntersect(
          sortedData.subList(0, index), sortedQueries.subList(0, medianQueryIndex), result);
    }

    if (index + 1 < sortedData.size() && medianQueryIndex + 1 < sortedQueries.size()) {
      fastIntersect(
          sortedData.subList(index + 1, sortedData.size()),
          sortedQueries.subList(medianQueryIndex + 1, sortedQueries.size()),
          result);
    }
  }
Esempio n. 2
0
 @Override
 public void databaseChanged(DatabaseChangeEvent e) {
   synchronized (set) {
     int pos;
     switch (e.getType()) {
       case ADDED_ENTRY:
         pos = -Collections.binarySearch(set, e.getEntry(), comp) - 1;
         set.add(pos, e.getEntry());
         // addEntry(e.getEntry());
         // set.add(e.getEntry());
         // changed = true;
         // Collections.sort(set, comp);
         break;
       case REMOVED_ENTRY:
         set.remove(e.getEntry());
         changed = true;
         break;
       case CHANGED_ENTRY:
         // Entry changed. Resort list:
         // Collections.sort(set, comp);
         pos = Collections.binarySearch(set, e.getEntry(), comp);
         int posOld = set.indexOf(e.getEntry());
         if (pos < 0) {
           set.remove(posOld);
           set.add(-pos - 1, e.getEntry());
         }
         // changed = true;
         break;
     }
   }
 }
  public boolean insert(Record r, String tableName) {
    int tableSearchIndex = Collections.binarySearch(this.tableNames, tableName);
    if (tableSearchIndex < 0) {
      // make new table if necessary
      tableSearchIndex = -tableSearchIndex - 1;
      this.tableNames.add(tableSearchIndex, tableName);

      this.rowStorage.add(tableSearchIndex, new ArrayList<Record>());
      this.columnIDNumbers.add(tableSearchIndex, new ArrayList<IDNumber>());
      this.columnClientNames.add(tableSearchIndex, new ArrayList<ClientName>());
      this.columnPhoneNumbers.add(tableSearchIndex, new ArrayList<PhoneNumber>());

      this.inMemoryRow.add(tableSearchIndex, new ArrayList<Boolean>());
      this.inMemoryColumnIDN.add(tableSearchIndex, new ArrayList<Boolean>());
      this.inMemoryColumnCN.add(tableSearchIndex, new ArrayList<Boolean>());
      this.inMemoryColumnPN.add(tableSearchIndex, new ArrayList<Boolean>());
    }
    int binSearchIndex = -Collections.binarySearch(this.rowStorage.get(tableSearchIndex), r) - 1;
    if (binSearchIndex < 0) {
      // skip records with same ID
      return false;
    }
    this.rowStorage.get(tableSearchIndex).add(binSearchIndex, r);
    this.inMemoryRow.get(tableSearchIndex).add(binSearchIndex, new Boolean(false));

    this.columnIDNumbers.get(tableSearchIndex).add(binSearchIndex, r.id);
    this.inMemoryColumnIDN.get(tableSearchIndex).add(binSearchIndex, new Boolean(false));
    this.columnClientNames.get(tableSearchIndex).add(binSearchIndex, r.clientName);
    this.inMemoryColumnCN.get(tableSearchIndex).add(binSearchIndex, new Boolean(false));
    this.columnPhoneNumbers.get(tableSearchIndex).add(binSearchIndex, r.phoneNumber);
    this.inMemoryColumnPN.get(tableSearchIndex).add(binSearchIndex, new Boolean(false));
    return true;
  }
  @Override
  public boolean process() {
    uniqueRows = new ArrayList<K>(new HashSet<K>(rows));
    Collections.sort(uniqueRows);
    uniqueCols = new ArrayList<J>(new HashSet<J>(cols));
    Collections.sort(uniqueCols);

    final List<Assignment> assignments = new ArrayList<Assignment>(costs.length);
    for (int i = 0; i < costs.length; i++) {
      final K rowObj = rows.get(i);
      final J colObj = cols.get(i);
      final int r = Collections.binarySearch(uniqueRows, rowObj);
      final int c = Collections.binarySearch(uniqueCols, colObj);
      assignments.add(new Assignment(r, c, costs[i]));
    }
    Collections.sort(assignments);

    // Test we do not have duplicates.
    Assignment previousAssgn = assignments.get(0);
    for (int i = 1; i < assignments.size(); i++) {
      final Assignment assgn = assignments.get(i);
      if (assgn.equals(previousAssgn)) {
        errorMessage = BASE_ERROR_MESSAGE + "Found duplicate assignment at index: " + assgn + ".";
        return false;
      }
      previousAssgn = assgn;
    }

    final int nRows = uniqueRows.size();
    final int nCols = uniqueCols.size();
    final int[] kk = new int[costs.length];
    final int[] number = new int[nRows];
    final double[] cc = new double[costs.length];

    Assignment a = assignments.get(0);
    kk[0] = a.c;
    cc[0] = a.cost;
    int currentRow = a.r;
    int nOfEl = 0;
    for (int i = 1; i < assignments.size(); i++) {
      a = assignments.get(i);

      kk[i] = a.c;
      cc[i] = a.cost;
      nOfEl++;

      if (a.r != currentRow) {
        number[currentRow] = nOfEl;
        nOfEl = 0;
        currentRow = a.r;
      }
    }
    number[currentRow] = nOfEl + 1;

    scm = new SparseCostMatrix(cc, kk, number, nCols);

    alternativeCost = computeAlternativeCosts();

    return true;
  }
 public static void main(String[] args) {
   List numL = Arrays.asList(5, 10, -5, -10);
   Collections.sort(numL);
   int v1 = Collections.binarySearch(numL, 5);
   int v2 = Collections.binarySearch(numL, 4);
   System.out.println(v1 + v2);
 }
Esempio n. 6
0
    private void search(File currentDirectory) {
      FileTreeIterator iter = new FileTreeIterator(currentDirectory);
      while (iter.hasNext()) {
        File file = iter.next();
        boolean accept = fileFilter.accept(file);
        synchronized (FileList.this) {
          if (searchID == searchCounter.get()) {
            if (accept) {

              int i =
                  searchConstraints == null
                      ? Collections.binarySearch(fileList, file)
                      : Collections.binarySearch(fileList, file, searchConstraints);
              if (i >= 0) {
                // already exists? great
              } else {
                fileList.add(-i - 1, file);
              }
            }
          } else {
            return;
          }
        }
      }
    }
Esempio n. 7
0
  private void parseFile(String filename) throws IOException {
    BufferedReader fileIn = new BufferedReader(new FileReader(filename));
    String line;
    // some persistent loop variables
    int tempo = 120;
    int key = 0;
    int timesig = 4;
    int measure = 0;
    while ((line = fileIn.readLine()) != null) {
      // we assume that listOfNotes is sorted.
      if (line.charAt(0) == '#' || line.equals("")) continue;
      String[] lineTokens = line.split(" ");

      switch (lineTokens[0]) {
        case "tempo":
          tempo = Integer.valueOf(lineTokens[1]);
          continue;
        case "key":
          key = Integer.valueOf(lineTokens[1]);
          continue;
        case "timesig":
          timesig = Integer.valueOf(lineTokens[1]);
          // put timesig into the global list
          Vector<Integer> measureSig = new Vector<Integer>(2);
          measureSig.add(measure);
          measureSig.add(timesig);
          this.timesigChanges.add(
              measureSig); // note that this always preserves order, as measure is monotone
                           // increasing
          continue;
        case "measure":
          measure = Integer.valueOf(lineTokens[1]) - 1;
          continue;
      }
      // now assuming the note start duration format
      String noteVal = keyTransform(lineTokens[0], key);
      double start = Double.valueOf(lineTokens[1]) + measure * timesig;
      double end = start + Double.valueOf(lineTokens[2]);
      // create two new NoteBeat nodes for start and end in case we need them
      NoteBeat startNote = new NoteBeat(start, tempo);
      NoteBeat endNote = new NoteBeat(end, tempo);
      // look for the start and the end in the list of preexisting ones
      int startPosition = Collections.binarySearch(this.listOfBeats, startNote);
      // process them
      if (startPosition < 0) { // insert new node into arraylist
        startNote.addNoteOn(noteVal);
        this.listOfBeats.add(-startPosition - 1, startNote);
      } else { // add this note to the noteOn list in pre-existing node
        this.listOfBeats.get(startPosition).addNoteOn(noteVal);
      }

      int endPosition = Collections.binarySearch(this.listOfBeats, endNote);
      if (endPosition < 0) {
        endNote.addNoteOff(noteVal);
        this.listOfBeats.add(-endPosition - 1, endNote);
      } else {
        this.listOfBeats.get(endPosition).addNoteOff(noteVal);
      }
    }
  }
Esempio n. 8
0
 @SuppressWarnings({"rawtypes", "unchecked"})
 private void externalizeMap(LinkedHashMap map, ObjectOutput out) throws IOException {
   int keyType = 0, valueType = 1, size;
   Iterator<Entry> it;
   Iterator cit;
   Entry e;
   Object value;
   if (map == null) {
     out.writeInt(0);
     out.flush();
     return;
   }
   size = map.keySet().size();
   if (map.keySet().iterator().next().getClass().equals(String.class)) {
     keyType = 1;
   }
   cit = map.values().iterator();
   value = cit.next();
   if (((ArrayList) value).get(0).getClass().equals(Commit.class)) {
     valueType = 0;
   } else if (((ArrayList) value).get(0).getClass().equals(PersonFrequency.class)) {
     valueType = 2;
   }
   out.writeInt(size);
   out.writeInt(keyType);
   out.writeInt(valueType);
   it = map.entrySet().iterator();
   while (it.hasNext()) {
     e = it.next();
     out.writeInt(((ArrayList) e.getValue()).size());
     cit = ((ArrayList) e.getValue()).iterator();
     while (cit.hasNext()) {
       value = cit.next();
       switch (valueType) {
         case 0:
           out.writeInt(Collections.binarySearch(allCommits, ((Commit) value)));
           break;
         case 1:
           out.writeInt(((BranchRef) value).index);
           break;
         default:
           out.writeInt(((PersonFrequency) value).index);
           out.writeInt(((PersonFrequency) value).freq);
           out.writeLong(((PersonFrequency) value).since);
           out.writeLong(((PersonFrequency) value).until);
       }
     }
     switch (keyType) {
       case 0:
         out.writeInt(Collections.binarySearch(allCommits, (Commit) e.getKey()));
         break;
       case 1:
         out.writeUTF(((String) e.getKey()));
     }
   }
   out.flush();
 }
Esempio n. 9
0
  /* ************************************************************ */
  public List pesquisarEntreValores(
      List resultadoDaPesquisa,
      String nomeAtributoComparado,
      Comparator comparadorAtributo,
      Object valorInicial,
      Object valorFinal) {

    if (resultadoDaPesquisa != null) {

      // Configura o método get para obter os valores comparados
      String nomeMetodo =
          "get"
              + nomeAtributoComparado.substring(0, 1).toUpperCase()
              + nomeAtributoComparado.substring(1, nomeAtributoComparado.length());

      // Ordena o resultado da pesquisa em ordem crescente dos valores do
      // atributo comparado:
      List resultado = new ArrayList();
      resultado.addAll(resultadoDaPesquisa);
      Util.ordenarObjetos(resultado, comparadorAtributo);

      // Isola o conjunto de valores do atributo comparado em uma lista de
      // valores, que tem a mesma ordenação e tamanho da lista de objetos
      // do resultado da pesquisa:
      List valoresAtributoComparado = new ArrayList();
      for (int i = 0; i < resultado.size(); i++) {
        valoresAtributoComparado.add(Util.executarMetodo(resultado.get(i), nomeMetodo, null));
      }

      // Da lista de valores, recupera o primeiro que seja maior ou igual
      // a valorInicial:
      int indiceValorInicial = Collections.binarySearch(valoresAtributoComparado, valorInicial);
      if (indiceValorInicial < 0) {
        indiceValorInicial = -(indiceValorInicial + 1);
      }

      // Da lista de valores, recupera o último que seja menor ou igual a
      // valorFinal:
      int indiceValorFinal = Collections.binarySearch(valoresAtributoComparado, valorFinal);
      if (indiceValorFinal < 0) {
        indiceValorFinal = -(indiceValorFinal + 1);
      } else {
        indiceValorFinal++;
      }

      // Recupera os objetos entre indiceValorInicial e indiceValorFinal:
      resultado = resultado.subList(indiceValorInicial, indiceValorFinal);

      // Retorna os objetos que satisfazem aos critérios, caso existam
      if (resultado.size() > 0) {
        return resultado;
      }
    }
    return null;
  }
  public static <T> void select(Population<T> population) {
    ArrayList<Individual<T>> pop = population.getPop();
    ArrayList<Individual<T>> newPop = new ArrayList<Individual<T>>();
    ArrayList<Double> probabilities = new ArrayList<Double>();
    Individual<T> parent1;
    Individual<T> parent2;
    Individual<T> child1;
    Individual<T> child2;
    double totalFitness = 0;
    double rnd;
    int popSize = Config.POP_SIZE.getIntValue();
    int index;

    if (Config.MIN.isEnabled()) {
      Collections.sort(pop, Collections.reverseOrder());
    } else if (Config.MAX.isEnabled()) {
      Collections.sort(pop);
    }

    for (Individual<T> in : pop) {
      totalFitness += in.getFitness();
    }

    for (Individual<T> in : pop) {
      probabilities.add(in.getFitness() / totalFitness);
    }

    while (newPop.size() < popSize) {
      rnd = Math.random();
      index = Math.abs(Collections.binarySearch(probabilities, rnd)) - 1;
      if (index == probabilities.size()) {
        index -= 1;
      }
      parent1 = pop.get(index);

      rnd = Math.random();
      index = Math.abs(Collections.binarySearch(probabilities, rnd)) - 1;
      if (index == probabilities.size()) {
        index -= 1;
      }
      parent2 = pop.get(index);

      child1 = parent1.cross(parent2);
      child2 = parent2.cross(parent1);

      child1.mutate();
      child2.mutate();

      newPop.add(child1);
      newPop.add(child2);
    }

    population.setPop(newPop);
  }
 public Record retrieve(IDNumber id, String tableName) {
   int tableSearchIndex = Collections.binarySearch(this.tableNames, tableName);
   if (tableSearchIndex < 0) {
     return null;
   }
   int binSearchIndex = Collections.binarySearch(this.columnIDNumbers.get(tableSearchIndex), id);
   if (binSearchIndex < 0) {
     return null;
   }
   return this.rowStorage.get(tableSearchIndex).get(binSearchIndex);
 }
 private boolean alterCacheStatusRecordOnly(Record r, String tableName, boolean status) {
   int tableSearchIndex = Collections.binarySearch(this.tableNames, tableName);
   if (tableSearchIndex < 0) {
     return false;
   }
   int binSearchIndex = Collections.binarySearch(this.rowStorage.get(tableSearchIndex), r);
   if (binSearchIndex < 0) {
     return false;
   }
   this.inMemoryRow.get(tableSearchIndex).set(binSearchIndex, status);
   return true;
 }
 public boolean checkInStorage(Record r, String tableName) {
   //		return this.checkInStorage(r.id, tableName) && this.checkInStorage(r.clientName, tableName)
   // && this.checkInStorage(r.phoneNumber, tableName);
   int tableSearchIndex = Collections.binarySearch(this.tableNames, tableName);
   if (tableSearchIndex < 0) {
     return false;
   }
   int binSearchIndex = Collections.binarySearch(this.rowStorage.get(tableSearchIndex), r);
   if (binSearchIndex < 0) {
     return false;
   }
   return this.inMemoryRow.get(tableSearchIndex).get(binSearchIndex);
 }
Esempio n. 14
0
  /**
   * 由母库数据建立0层路网
   *
   * @param task
   * @param data
   * @throws Exception
   */
  public void fromDB() throws Exception {
    List<String> meshNos = DataManager.getMeshNos(this.taskData.task);
    TeleDao teleDao = new TeleDao();
    Session session =
        TeleHbSessionFactory.getOrgHbSession(this.taskData.task.getLevel()).getSession();
    List<NodeNew> meshBorderNodeList = new ArrayList<NodeNew>();
    for (String meshNo : meshNos) {
      List<Node> node_oList = teleDao.getNodeList(meshNo, session);
      List<NodeNew> nodeList = new ArrayList<NodeNew>(node_oList.size());
      // 读取关系节点
      for (Node node_o : node_oList) {
        NodeNew nodeNew = new NodeNew();
        nodeNew.convert(node_o);
        if (node_o.getByistaskborder() == NodeType.meshBorder) {
          meshBorderNodeList.add(nodeNew);
        }
        nodeList.add(nodeNew);
      }

      this.nodeList.addAll(nodeList);
      Collections.sort(nodeList, comparableNodeId);
      // 读取道路
      List<Road> roadList = teleDao.getRoadList(meshNo, session);
      for (Road road_O : roadList) {
        RoadNew road = new RoadNew();
        // 属性赋值,正规化计算
        road.convert(this, road_O);
        this.roadList.add(road);
        // 建立拓扑关系
        // add node to road
        int indexStart = Collections.binarySearch(nodeList, road.startNode, comparableNodeId);
        road.startNode = nodeList.get(indexStart);
        int indexEnd = Collections.binarySearch(nodeList, road.endNode, comparableNodeId);
        road.endNode = nodeList.get(indexEnd);
        // add road to node
        road.startNode.roads.add(road);
        road.endNode.roads.add(road);
      }
      // 读取复杂路口
      List<Intersection_O> intersectionList = teleDao.getIntersectionList(meshNo, session);
      for (Intersection_O intersection_O : intersectionList) {
        IntersectionNew intersection = new IntersectionNew();
        intersection.convert(this, intersection_O);
        this.intersectionList.add(intersection);
      }
    }
    // 建立mesh边界的拓扑关系
    this.makeBorderTopo(meshBorderNodeList);
    //
  }
    @Override
    protected void onPostExecute(SocialTwitterApi.GetRequest api) {
      super.onPostExecute(api);
      if (isDetached() || getActivity() == null) {
        return;
      }

      if (api.isSuccessful()) {
        ArrayList<FeedTwitterStatus> feed = api.getResponseObj().getStatusList();
        Collections.sort(feed);
        if (mTweetList.size() == 0) {
          // 新規取得
          mTweetList.addAll(feed);
        } else {
          FeedTwitterStatus latestTweet = mTweetList.get(0);
          // 取得済みの最新ツイートより新しいものを追加
          int index = Collections.binarySearch(feed, latestTweet);
          if (index > 0) {
            mTweetList.addAll(0, feed.subList(0, index));
          } else if (index < 0) {
            // indexが-1の時全部最新ツイート
            // -2以下の場合がないと想定
            Timber.d("onPostExecute: latestTweetIndex in new feed" + index);
            mTweetList.addAll(0, feed);
          } else {
            Timber.d("onPostExecute: already added");
          }
        }
        mAdapter.notifyDataSetChanged();
      }

      mSwipeRefreshLayout.setRefreshing(false);
    }
Esempio n. 16
0
 public static void main(String[] args) {
   ArrayList nums = new ArrayList();
   nums.add(2);
   nums.add(-5);
   nums.add(3);
   nums.add(0);
   // 输出:[2, -5, 3, 0]
   System.out.println(nums);
   // 输出最大元素,将输出3
   System.out.println(Collections.max(nums));
   // 输出最小元素,将输出-5
   System.out.println(Collections.min(nums));
   // 将nums中的0使用1来代替
   Collections.replaceAll(nums, 0, 1);
   // 输出:[2, -5, 3, 1]
   System.out.println(nums);
   // 判断-5 在List集合中出现的次数,返回1
   System.out.println(Collections.frequency(nums, -5));
   // 对nums集合排序
   Collections.sort(nums);
   // 输出:[-5, 1, 2, 3]
   System.out.println(nums);
   // 只有排序后的List集合才可用二分法查询,输出3
   System.out.println(Collections.binarySearch(nums, 3));
 }
Esempio n. 17
0
 @SuppressWarnings({"rawtypes", "unchecked"})
 private LinkedHashMap computePersonFreq(LinkedHashMap map) {
   if (map == null) return null;
   ArrayList<PersonFrequency> values;
   ArrayList ev;
   LinkedHashMap res = new LinkedHashMap<Object, ArrayList<PersonFrequency>>(map.size(), 1);
   Entry e;
   Set<Entry> es = map.entrySet();
   Iterator<Entry> esit = es.iterator();
   Iterator<Commit> evit;
   PersonFrequency p;
   long pTs;
   Commit c;
   int i;
   while (esit.hasNext()) {
     e = esit.next();
     ev = (ArrayList) e.getValue();
     evit = ev.iterator();
     values = new ArrayList<PersonFrequency>(ev.size());
     while (evit.hasNext()) {
       c = evit.next();
       pTs = c.getCommittingInfo().getWhen().getTime();
       i = Collections.binarySearch(allAuthors, c.getAuthoringInfo());
       p = new PersonFrequency(i);
       i = GitWorks.addUnique(values, p);
       p = values.get(i);
       p.freq++;
       if (p.since > pTs) p.since = pTs;
       if (p.until < pTs) p.until = pTs;
     }
     values.trimToSize();
     res.put(e.getKey(), values);
   }
   return res;
 }
  private Object[] getFromCache(RowMetaInterface keyMeta, Object[] keyData)
      throws KettleValueException {
    if (meta.isMemoryPreservationActive()) {
      if (meta.isUsingSortedList()) {
        KeyValue keyValue = new KeyValue(keyData, null);
        int idx = Collections.binarySearch(data.list, keyValue, data.comparator);
        if (idx < 0) return null; // nothing found

        keyValue = (KeyValue) data.list.get(idx);
        return keyValue.getValue();
      } else {
        if (meta.isUsingIntegerPair()) {
          Long value = data.longIndex.get(keyMeta.getInteger(keyData, 0));
          if (value == null) return null;
          return new Object[] {
            value,
          };
        } else {
          try {
            byte[] value = data.hashIndex.get(RowMeta.extractData(keyMeta, keyData));
            if (value == null) return null;
            return RowMeta.getRow(data.valueMeta, value);
          } catch (Exception e) {
            logError("Oops", e);
            throw new RuntimeException(e);
          }
        }
      }
    } else {
      return (Object[]) data.look.get(new RowMetaAndData(keyMeta, keyData));
    }
  }
  /** ************************ TEST ACCESS ******************************************* */
  @Test
  public void testSearchIterator() throws InterruptedException {
    final int perTreeSelections = 100;
    testRandomSelection(
        perThreadTrees,
        perTreeSelections,
        (test) -> {
          IndexedSearchIterator<Integer, Integer> iter1 = test.testAsSet.iterator();
          IndexedSearchIterator<Integer, Integer> iter2 = test.testAsList.iterator();
          return (key) -> {
            Integer found1 = iter1.hasNext() ? iter1.next(key) : null;
            Integer found2 = iter2.hasNext() ? iter2.next(key) : null;
            Assert.assertSame(found1, found2);
            if (found1 != null) Assert.assertEquals(iter1.indexOfCurrent(), iter2.indexOfCurrent());

            int index = Collections.binarySearch(test.canonicalList, key, test.comparator);
            if (index < 0) {
              Assert.assertNull(found1);
            } else {
              Assert.assertEquals(key, found1);
              Assert.assertEquals(index, iter1.indexOfCurrent());
            }

            // check that by advancing the same key again we get null, but only do it on one of the
            // two iterators
            // to ensure they both advance differently
            if (ThreadLocalRandom.current().nextBoolean()) Assert.assertNull(iter1.next(key));
            else Assert.assertNull(iter2.next(key));
          };
        });
  }
      /**
       * Sorts the rows of the table alphabetically.
       *
       * @param column index of the column to sort. In this table there are only 2 columns.
       */
      public void sort(int column) {
        // Orders the layer alphabetically according the Spanish
        // alphabetically rules
        switch (column) {
          case 0:
            stringComparator.setColumn(WFSLayerStringComparator.LAYER_NAME);
            break;
          case 1:
            stringComparator.setColumn(WFSLayerStringComparator.GEOMETRY_TYPE);
            break;
        }

        if (previousColumnSorted != column) stringComparator.setAscendingOrdering(true);

        previousColumnSorted = (short) column;

        WFSLayerNode layer = getSelectedValue();

        Collections.sort(layers, stringComparator);

        if (layer != null) {
          updatingSelection = true;
          unselectAllFeatures();
          int row = Collections.binarySearch(layers, layer, stringComparator);

          if (row != -1) {
            ListSelectionModel model = getSelectionModel();
            model.setLeadSelectionIndex(row);
          }

          updatingSelection = false;
        }
        stringComparator.setAscendingOrdering(!stringComparator.isAscendingOrdering());
      }
Esempio n. 21
0
  /**
   * Recalculate the prefix border following an i-extension
   *
   * @param prefixLastItemset last itemset of the previous prefix
   * @param prefixBorder the previous prefix border
   * @param item1 the last item
   * @param item2 the item that will be appended
   * @param willAddSecondItem if the item will be added to an itemset containing a single item
   * @return the updated border
   */
  private List<Position> recalculateBorderForIExtension(
      List<Integer> prefixLastItemset,
      List<Position> prefixBorder,
      int item1,
      int item2,
      boolean willAddSecondItem) {

    // Create the new border (a list of position)
    List<Position> newBorder = new ArrayList<Position>();

    // for each sequence where the prefix appeared
    for (Position previousPosition : prefixBorder) {
      int sid = previousPosition.sid;
      // get where the last two items of the prefix appeared
      int previousItemsetID = previousPosition.position;
      IEPositionList positionLists = iePositionList[sid];

      // find the position that is immediately larger or equal than the current one
      // by checking each position in the list of positions for the pair
      List<Short> listPositions = positionLists.getListForPair(item1, item2);
      if (listPositions != null) {
        // for each position
        loop:
        for (short pos : listPositions) {
          // if the position is larger or equal to the current one
          if (pos >= previousItemsetID) {
            // IMPORTANT:
            // if the prefix has two items in its last itemset,
            // then we also need to check that the full last itemset of prefix is at the current
            // position
            // This will not be done very optimally but it is it difficult to do a better solution.
            if (willAddSecondItem == false) {
              // We take the SE position list of the current sequence
              SEPositionList plists = sePositionList[sid];
              // For each item of the last itemset of the prefix
              for (int i = 0; i < prefixLastItemset.size() - 1; i++) {
                // We check if that item appears at that position
                Integer itemX = prefixLastItemset.get(i);
                List<Short> plistX = plists.getListForItem(itemX);
                int index = Collections.binarySearch(plistX, pos);
                // if not, then we stop considering this position
                if (index < 0) {
                  continue loop;
                }
              }
              // If the loop has finished, that means that all items from the last itemset of
              // the prefix have appeared at the position pos
            }
            // Then we add the position to the new border
            Position newPosition = new Position(sid, pos);
            newBorder.add(newPosition);
            // After that we will continue to the next sequence to continue creating the new border
            break;
          }
        }
      }
    }

    return newBorder;
  }
 void removeBreakpoint(Breakpoint breakpoint) {
   String templateName = breakpoint.getTemplateName();
   synchronized (templateDebugInfos) {
     TemplateDebugInfo tdi = findTemplateDebugInfo(templateName);
     if (tdi != null) {
       List breakpoints = tdi.breakpoints;
       int pos = Collections.binarySearch(breakpoints, breakpoint);
       if (pos >= 0) {
         breakpoints.remove(pos);
         for (Iterator iter = tdi.templates.iterator(); iter.hasNext(); ) {
           TemplateReference ref = (TemplateReference) iter.next();
           Template t = ref.getTemplate();
           if (t == null) {
             iter.remove();
           } else {
             removeDebugBreak(t, breakpoint);
           }
         }
       }
       if (tdi.isEmpty()) {
         templateDebugInfos.remove(templateName);
       }
     }
   }
 }
Esempio n. 23
0
 /**
  * Random selection ("sampling") of a record out of the sample
  *
  * @return index of the record selected
  * @throws ArrayIndexOutOfBoundsException internal error - returned index larger than number of
  *     records in sample
  */
 public int randomSample() throws ArrayIndexOutOfBoundsException {
   Random r = new Random();
   // generate random number for sampling
   int sampleThreshold = 1;
   if (maxThreshold == 0) {
     // TODO: need a good workaround for this or an assert
     // This occurs when all thresholds = 0 because of rounding. Usually this disappears
     // when the distribution (thresholds) are multiplied by 100 or 1000.
     System.out.println("Problem: maxThreshold = 0");
     //			return 0;
   } else {
     sampleThreshold = (int) maxThreshold;
   }
   long rand = (long) r.nextInt(sampleThreshold);
   // lookup index of element where random number falls within the boundaries
   int index = Collections.binarySearch(thresholdStore, rand);
   if (index < 0) index = (index + 1) * -1;
   assert index < thresholdStore.size()
       : "Array index too large; rand = "
           + rand
           + ", max threshold = "
           + maxThreshold
           + ", index = "
           + index
           + ", max index = "
           + thresholdStore.size();
   return index;
 }
Esempio n. 24
0
 private int searchSubregionTile(RouteSubregion subregion) {
   RoutingSubregionTile key = new RoutingSubregionTile(subregion);
   long now = System.nanoTime();
   int ind =
       Collections.binarySearch(
           subregionTiles,
           key,
           new Comparator<RoutingSubregionTile>() {
             @Override
             public int compare(RoutingSubregionTile o1, RoutingSubregionTile o2) {
               if (o1.subregion.left == o2.subregion.left) {
                 return 0;
               }
               return o1.subregion.left < o2.subregion.left ? 1 : -1;
             }
           });
   if (ind >= 0) {
     for (int i = ind; i <= subregionTiles.size(); i++) {
       if (i == subregionTiles.size() || subregionTiles.get(i).subregion.left > subregion.left) {
         ind = -i - 1;
         return ind;
       }
       if (subregionTiles.get(i).subregion == subregion) {
         return i;
       }
     }
   }
   timeToLoadHeaders += (System.nanoTime() - now);
   return ind;
 }
Esempio n. 25
0
 public Token getSuccessor(Token token) {
   List tokens = sortedTokens();
   int index = Collections.binarySearch(tokens, token);
   assert index >= 0
       : token + " not found in " + StringUtils.join(tokenToEndPointMap.keySet(), ", ");
   return (Token) ((index == (tokens.size() - 1)) ? tokens.get(0) : tokens.get(index + 1));
 }
Esempio n. 26
0
  public static void main(String args[]) {
    String os[] = {"GNU/Linux", "Windows 7", "Solaris", "Amiga OS", "FreeBSD", "Mac OS X"};

    LinkedList<String> al_operating_systems =
        new LinkedList<>(Arrays.asList(os)); // Lista di os
    Collections.sort(al_operating_systems); // ordina la collezione
    System.out.print("Collezione ordinata: ");
    System.out.println(al_operating_systems);

    int ix =
        Collections.binarySearch(
            al_operating_systems, "Be OS", null); // ricerca se presente l'elemento Be Os
    if (ix < 0) // se non è presente aggiungilo
    al_operating_systems.add(-(ix + 1), "Be OS");

    System.out.print("Collezione con elemento Be OS aggiunto: ");
    System.out.println(al_operating_systems);

    Collections.rotate(al_operating_systems, 3); // ruota gli elementi di 3 posizioni
    System.out.print("Collezione con elementi ruotati: ");
    System.out.println(al_operating_systems);

    System.out.print("Elemento della collezione minore: ["); // elemento più piccolo
    System.out.println(Collections.min(al_operating_systems) + "]");

    System.out.print("Elemento della collezione maggiore: ["); // elemento più grande
    System.out.println(Collections.max(al_operating_systems) + "]");
  }
Esempio n. 27
0
  @Override
  public void addSubattribute(Attribute attribute) {
    AttributeImpl attributeImpl = (AttributeImpl) attribute;

    // The attribute is bound and has to be removed from its parent (informationobject or parent
    // attribute
    if (attributeImpl.getInformationObject() != null
        || attributeImpl.getParentAttribute() != null) {
      if (attributeImpl.getParentAttribute() != null) {
        attributeImpl.getParentAttribute().removeSubattribute(attributeImpl);
      } else {
        attributeImpl.getInformationObject().removeAttribute(attributeImpl);
      }
    }

    attributeImpl.setParentAttribute(this);
    int index = Collections.binarySearch(subattributes, attributeImpl);
    if (index < 0) {
      subattributes.add(-index - 1, attributeImpl);
    } else {
      subattributes.add(index, attributeImpl);
    }
    if (parentAttribute != null) {
      ((AttributeImpl) parentAttribute).resortAttributes();
    }
    if (informationObject != null) {
      ((InformationObjectImpl) informationObject).resortAttributes();
    }
  }
 /**
  * Checks if this sensitivity equals another within the specified tolerance.
  *
  * <p>This returns true if the two instances have the same keys, with arrays of the same length,
  * where the {@code double} values are equal within the specified tolerance.
  *
  * @param other the other sensitivity
  * @param tolerance the tolerance
  * @return true if equal up to the tolerance
  */
 public boolean equalWithTolerance(CurveCurrencyParameterSensitivities other, double tolerance) {
   List<CurveCurrencyParameterSensitivity> mutable = new ArrayList<>(other.sensitivities);
   // for each sensitivity in this instance, find matching in other instance
   for (CurveCurrencyParameterSensitivity sens1 : sensitivities) {
     // list is already sorted so binary search is safe
     int index =
         Collections.binarySearch(mutable, sens1, CurveCurrencyParameterSensitivity::compareKey);
     if (index >= 0) {
       // matched, so must be equal
       CurveCurrencyParameterSensitivity sens2 = mutable.get(index);
       if (!DoubleArrayMath.fuzzyEquals(
           sens1.getSensitivity(), sens2.getSensitivity(), tolerance)) {
         return false;
       }
       mutable.remove(index);
     } else {
       // did not match, so must be zero
       if (!DoubleArrayMath.fuzzyEqualsZero(sens1.getSensitivity(), tolerance)) {
         return false;
       }
     }
   }
   // all that remain from other instance must be zero
   for (CurveCurrencyParameterSensitivity sens2 : mutable) {
     if (!DoubleArrayMath.fuzzyEqualsZero(sens2.getSensitivity(), tolerance)) {
       return false;
     }
   }
   return true;
 }
Esempio n. 29
0
 /**
  * Searches for the index of a given element
  *
  * @param e the element
  * @return the index or -1 if the list does not contain this element
  */
 public int indexOf(E e) {
   int index = Collections.binarySearch(_list, e, _comp);
   if (index < 0) {
     return -1;
   }
   return index;
 }
 /**
  * Returns the row index for a given key.
  *
  * @param key the key.
  * @return the row index.
  */
 public int getRowIndex(Comparable key) {
   if (this.sortRowKeys) {
     return Collections.binarySearch(this.rowKeys, key);
   } else {
     return this.rowKeys.indexOf(key);
   }
 }