public String getInfo() {
   if (crossValidationResults != null) {
     return crossValidationResults.getInfo();
   } else {
     StringBuffer result = new StringBuffer();
     if (oneVsAllMode != OneVsAllMode.None) {
       Multiset<Float> cs = HashMultiset.create();
       Multiset<KernelFunction> kernels = HashMultiset.create();
       for (BinaryModel<L, P> binaryModel : oneVsAllModels.values()) {
         cs.add(binaryModel.param.C);
         kernels.add(binaryModel.param.kernel);
       }
       result.append("OneVsAll:C=" + cs + "; gamma=" + kernels + "   ");
     }
     if (allVsAllMode != AllVsAllMode.None) {
       Multiset<Float> cs = HashMultiset.create();
       Multiset<KernelFunction> kernels = HashMultiset.create();
       for (BinaryModel<L, P> binaryModel : oneVsOneModels.values()) {
         cs.add(binaryModel.param.C);
         kernels.add(binaryModel.param.kernel);
       }
       result.append("AllVsAll:C=" + cs + "; gamma=" + kernels + "   ");
     }
     return result.toString();
   }
   // return "";
 }
  private void computeViolationsPerRules(DecoratorContext context) {
    Map<RulePriority, Multiset<Rule>> rulesPerSeverity = Maps.newHashMap();
    for (Violation violation : context.getViolations()) {
      Multiset<Rule> rulesBag = initRules(rulesPerSeverity, violation.getSeverity());
      rulesBag.add(violation.getRule());
    }

    for (RulePriority severity : RulePriority.values()) {
      Metric metric = SeverityUtils.severityToViolationMetric(severity);

      Collection<Measure> children = context.getChildrenMeasures(MeasuresFilters.rules(metric));
      for (Measure child : children) {
        RuleMeasure childRuleMeasure = (RuleMeasure) child;
        Rule rule = childRuleMeasure.getRule();
        if (rule != null && MeasureUtils.hasValue(childRuleMeasure)) {
          Multiset<Rule> rulesBag = initRules(rulesPerSeverity, severity);
          rulesBag.add(rule, childRuleMeasure.getIntValue());
        }
      }

      Multiset<Rule> rulesBag = rulesPerSeverity.get(severity);
      if (rulesBag != null) {
        for (Multiset.Entry<Rule> entry : rulesBag.entrySet()) {
          RuleMeasure measure =
              RuleMeasure.createForRule(metric, entry.getElement(), (double) entry.getCount());
          measure.setSeverity(severity);
          context.saveMeasure(measure);
        }
      }
    }
  }
Esempio n. 3
0
 private void loadTestData(Multiset<String> m) {
   m.add("a");
   m.add("a");
   m.add("b");
   m.add("c");
   m.add("a");
   m.add("-1");
 }
Esempio n. 4
0
  public static void main(String args[]) {

    // create a multiset collection
    Multiset<String> multiset = HashMultiset.create();

    multiset.add("a");
    multiset.add("b");
    multiset.add("c");
    multiset.add("d");
    multiset.add("a");
    multiset.add("b");
    multiset.add("c");
    multiset.add("b");
    multiset.add("b");
    multiset.add("b");

    // print the occurrence of an element
    System.out.println("Occurrence of 'b' : " + multiset.count("b"));

    // print the total size of the multiset
    System.out.println("Total Size : " + multiset.size());

    // get the distinct elements of the multiset as set
    Set<String> set = multiset.elementSet();

    // display the elements of the set
    System.out.println("Set [");

    for (String s : set) {
      System.out.println(s);
    }

    System.out.println("]");

    // display all the elements of the multiset using iterator
    Iterator<String> iterator = multiset.iterator();
    System.out.println("MultiSet [");

    while (iterator.hasNext()) {
      System.out.println(iterator.next());
    }

    System.out.println("]");

    // display the distinct elements of the multiset with their occurrence count
    System.out.println("MultiSet [");

    for (Multiset.Entry<String> entry : multiset.entrySet()) {
      System.out.println("Element: " + entry.getElement() + ", Occurrence(s): " + entry.getCount());
    }
    System.out.println("]");

    // remove extra occurrences
    multiset.remove("b", 2);

    // print the occurrence of an element
    System.out.println("Occurence of 'b' : " + multiset.count("b"));
  }
Esempio n. 5
0
 @Test
 public void multisetTest() {
   Multiset<String> multiset = HashMultiset.create();
   multiset.add("123");
   multiset.add("123");
   multiset.add("123");
   multiset.add("1234");
   System.out.println(multiset.count("123"));
   System.out.println(multiset);
 }
Esempio n. 6
0
  /**
   * From A to B
   *
   * @param from
   * @param to
   */
  public void addOneWayConnection(int from, int to) {
    addNode(from);
    addNode(to);

    Multiset<Integer> outSet = nodeOutEdges.get(from);
    outSet.add(to);

    Multiset<Integer> inSet = nodeInEdges.get(to);
    inSet.add(from);
  }
Esempio n. 7
0
  private static <T> int checkCounts(Collection<T> original) {
    Multiset<T> hashCounts = HashMultiset.create();
    for (T v : original) {
      hashCounts.add(v);
    }

    Multiset<Integer> countCounts = HashMultiset.create();
    for (T hash : hashCounts) {
      countCounts.add(hashCounts.count(hash));
    }

    return original.size() - countCounts.count(1);
  }
  @Test
  public void whenGetTopUsingMultiSet_thenCorrect() {
    final Multiset<String> names = HashMultiset.create();
    names.add("John");
    names.add("Adam", 5);
    names.add("Jane");
    names.add("Tom", 2);

    final Set<String> sorted = Multisets.copyHighestCountFirst(names).elementSet();
    final List<String> topTwo = Lists.newArrayList(sorted).subList(0, 2);
    assertEquals(2, topTwo.size());
    assertEquals("Adam", topTwo.get(0));
    assertEquals("Tom", topTwo.get(1));
  }
  @Test
  public void whenInsertDuplicatesInMultiSet_thenInserted() {
    final Multiset<String> names = HashMultiset.create();
    names.add("John");
    names.add("Adam", 3);
    names.add("John");

    assertEquals(2, names.count("John"));
    names.remove("John");
    assertEquals(1, names.count("John"));

    assertEquals(3, names.count("Adam"));
    names.remove("Adam", 2);
    assertEquals(1, names.count("Adam"));
  }
 private void initializeForFile(CounterInitializationContext context) {
   String language = context.getLeaf().getFileAttributes().getLanguageKey();
   Optional<Measure> ncloc = context.getMeasure(CoreMetrics.NCLOC_KEY);
   if (ncloc.isPresent()) {
     multiset.add(language == null ? UNKNOWN_LANGUAGE_KEY : language, ncloc.get().getIntValue());
   }
 }
Esempio n. 11
0
  /**
   * Populate the FeatureVector with Bag of Words.
   *
   * @param c
   * @param fv
   */
  protected void populateFV(String text, FeatureVector<E> fv) {
    List<String> unnormalized = tokenizer.tokenize(text);

    Multiset<String> terms = HashMultiset.create();
    for (String token : unnormalized) {
      String norm = Util.normalize(token);
      if (!norm.isEmpty()) {
        terms.add(norm);
      }
    }

    // sparse representation... no need to put in 0's
    for (String term : terms.elementSet()) {
      // rare words don't get included, so check first
      if (!integerFeatureNames && train.getMetadata().containsKey(term)) {
        DoubleFeature bagFeat = new DoubleFeature(term, (double) terms.count(term));
        fv.put(term, bagFeat);
      } else if (integerFeatureNames
          && train.getMetadata().containsKey(String.valueOf(wordIndexMap.get(term)))) {
        String featureName = String.valueOf(wordIndexMap.get(term));
        DoubleFeature bagFeat = new DoubleFeature(featureName, (double) terms.count(term));
        fv.put(featureName, bagFeat);
      }
    }
  }
Esempio n. 12
0
  private void restoreTimers(DataInputView in) throws IOException {
    int numWatermarkTimers = in.readInt();
    watermarkTimers = new HashSet<>(numWatermarkTimers);
    watermarkTimersQueue = new PriorityQueue<>(Math.max(numWatermarkTimers, 1));
    for (int i = 0; i < numWatermarkTimers; i++) {
      K key = keySerializer.deserialize(in);
      W window = windowSerializer.deserialize(in);
      long timestamp = in.readLong();
      Timer<K, W> timer = new Timer<>(timestamp, key, window);
      watermarkTimers.add(timer);
      watermarkTimersQueue.add(timer);
    }

    int numProcessingTimeTimers = in.readInt();
    processingTimeTimersQueue = new PriorityQueue<>(Math.max(numProcessingTimeTimers, 1));
    processingTimeTimers = new HashSet<>();
    for (int i = 0; i < numProcessingTimeTimers; i++) {
      K key = keySerializer.deserialize(in);
      W window = windowSerializer.deserialize(in);
      long timestamp = in.readLong();
      Timer<K, W> timer = new Timer<>(timestamp, key, window);
      processingTimeTimersQueue.add(timer);
      processingTimeTimers.add(timer);
    }

    int numProcessingTimeTimerTimestamp = in.readInt();
    processingTimeTimerTimestamps = HashMultiset.create();
    for (int i = 0; i < numProcessingTimeTimerTimestamp; i++) {
      long timestamp = in.readLong();
      int count = in.readInt();
      processingTimeTimerTimestamps.add(timestamp, count);
    }
  }
 private static void validateAnalyzerMessage(
     Map<IssueAttribute, String> attrs, AnalyzerMessage analyzerMessage) {
   Double effortToFix = analyzerMessage.getCost();
   if (effortToFix != null) {
     assertEquals(Integer.toString(effortToFix.intValue()), attrs, IssueAttribute.EFFORT_TO_FIX);
   }
   AnalyzerMessage.TextSpan textSpan = analyzerMessage.primaryLocation();
   assertEquals(normalizeColumn(textSpan.startCharacter), attrs, IssueAttribute.START_COLUMN);
   assertEquals(Integer.toString(textSpan.endLine), attrs, IssueAttribute.END_LINE);
   assertEquals(normalizeColumn(textSpan.endCharacter), attrs, IssueAttribute.END_COLUMN);
   if (attrs.containsKey(IssueAttribute.SECONDARY_LOCATIONS)) {
     List<AnalyzerMessage> secondaryLocations = analyzerMessage.secondaryLocations;
     Multiset<String> actualLines = HashMultiset.create();
     for (AnalyzerMessage secondaryLocation : secondaryLocations) {
       actualLines.add(Integer.toString(secondaryLocation.getLine()));
     }
     List<String> expected =
         Lists.newArrayList(
             Splitter.on(",")
                 .omitEmptyStrings()
                 .trimResults()
                 .split(attrs.get(IssueAttribute.SECONDARY_LOCATIONS)));
     List<String> unexpected = new ArrayList<>();
     for (String actualLine : actualLines) {
       if (expected.contains(actualLine)) {
         expected.remove(actualLine);
       } else {
         unexpected.add(actualLine);
       }
     }
     if (!expected.isEmpty() || !unexpected.isEmpty()) {
       Fail.fail("Secondary locations: expected: " + expected + " unexpected:" + unexpected);
     }
   }
 }
  private static void logStats(Collection<PsiFile> otherFiles, long start) {
    long time = System.currentTimeMillis() - start;

    final Multiset<String> stats = HashMultiset.create();
    for (PsiFile file : otherFiles) {
      stats.add(
          StringUtil.notNullize(file.getViewProvider().getVirtualFile().getExtension())
              .toLowerCase());
    }

    List<String> extensions = ContainerUtil.newArrayList(stats.elementSet());
    Collections.sort(
        extensions,
        new Comparator<String>() {
          @Override
          public int compare(String o1, String o2) {
            return stats.count(o2) - stats.count(o1);
          }
        });

    String message =
        "Search in "
            + otherFiles.size()
            + " files with unknown types took "
            + time
            + "ms.\n"
            + "Mapping their extensions to an existing file type (e.g. Plain Text) might speed up the search.\n"
            + "Most frequent non-indexed file extensions: ";
    for (int i = 0; i < Math.min(10, extensions.size()); i++) {
      String extension = extensions.get(i);
      message += extension + "(" + stats.count(extension) + ") ";
    }
    LOG.info(message);
  }
  private Integer transferResource(ResourceStock buyer, Resource outResource) {
    while (true) {
      int wanted = buying.count(buyer);
      int available = externalRepository.count(outResource);
      int transfer = Math.min(available, wanted);

      if (transfer == 0) {
        return 0;
      }

      boolean procured = externalRepository.setCount(outResource, available, available - transfer);
      if (procured) {
        boolean sent = buying.setCount(buyer, wanted, wanted - transfer);
        if (sent) {
          try {
            buyer.add(transfer);
          } catch (RuntimeException e) {
            buying.remove(buyer, transfer);
            continue;
          }
          myLogTransfer(buyer, transfer, outResource);
          return transfer;
        } else {

          externalRepository.add(outResource, transfer);
        }
      }
    }
  }
 KVariable newDotVariable(Sort sort) {
   KVariable newLabel;
   do {
     newLabel = KVariable("_" + (counter++), Att().add("sort", sort));
   } while (vars.contains(newLabel));
   vars.add(newLabel);
   return newLabel;
 }
 @Override
 public void visitNode(Tree tree) {
   if (tree.is(Tree.Kind.RETURN_STATEMENT)) {
     returnStatementCounter.add(methods.peek());
   } else {
     methods.push(tree);
   }
 }
 @Test
 public void should_pass_if_actual_contains_value_number_of_times_expected() {
   // given
   Multiset<String> actual = HashMultiset.create();
   actual.add("test", 2);
   // when
   assertThat(actual).containsAtMost(2, "test");
   // then pass
 }
  protected String fixIndexedParameters(String name, Multiset<String> indexes) {
    if (name.contains("[]")) {
      String newName = name.replace("[]", "[" + (indexes.count(name)) + "]");
      indexes.add(name);
      logger.debug("{} was renamed to {}", name, newName);

      return newName;
    }
    return name;
  }
 private void initializeForOtherLeaf(CounterInitializationContext context) {
   Optional<Measure> measure = context.getMeasure(NCLOC_LANGUAGE_DISTRIBUTION_KEY);
   if (measure.isPresent()) {
     Map<String, Integer> parse =
         KeyValueFormat.parse(
             measure.get().getData(), newStringConverter(), newIntegerConverter());
     for (Map.Entry<String, Integer> entry : parse.entrySet()) {
       multiset.add(entry.getKey(), entry.getValue());
     }
   }
 }
  @Override
  public void reorderChilds(Iterable<CreatedOutput> outDesc) {
    final Multiset<TreeItemMapping> subMappings = LinkedHashMultiset.create();
    final Map<EObject, CreatedOutput> outputToItem = Maps.newHashMap();
    for (CreatedOutput createdOutput : outDesc) {
      EObject createdElement = createdOutput.getCreatedElement();
      outputToItem.put(createdElement, createdOutput);
      if (createdElement instanceof DTreeItem) {
        DTreeItem createdDTreeItem = (DTreeItem) createdElement;
        TreeItemMapping actualMapping = createdDTreeItem.getActualMapping();
        subMappings.add(actualMapping);
      }
    }

    // Counts subMappings to correctly sort tree items regarding mapping
    // order (items have been created regarding the semantic candidates
    // order)
    int startIndex = 0;
    final Map<TreeItemMapping, Integer> startIndexes = Maps.newHashMap();
    for (TreeItemMapping itemMapping : subMappings) {
      startIndexes.put(itemMapping, startIndex);
      startIndex += subMappings.count(itemMapping);
    }

    // Pre-compute the new indices
    final Map<DTreeItem, Integer> newIndices = Maps.newHashMap();
    for (DTreeItem treeItem : container.getOwnedTreeItems()) {
      // init with element count : elements with unknown mapping
      // will be placed at the end.
      int index = outputToItem.size();
      TreeItemMapping itemMapping = treeItem.getActualMapping();
      if (itemMapping != null && startIndexes.containsKey(itemMapping)) {
        index = startIndexes.get(itemMapping);
      }

      CreatedOutput createdOutput = outputToItem.get(treeItem);
      if (createdOutput != null) {
        index = index + createdOutput.getNewIndex();
      } else {
        index = -1;
      }

      newIndices.put(treeItem, index);
    }

    ECollections.sort(
        container.getOwnedTreeItems(),
        new Comparator<DTreeItem>() {
          @Override
          public int compare(DTreeItem o1, DTreeItem o2) {
            return newIndices.get(o1).compareTo(newIndices.get(o2));
          }
        });
  }
Esempio n. 22
0
  /**
   * Create the Bag of Words features.
   *
   * @param citations
   */
  public void createFeatures(Collection<String> documents) {
    Multiset<String> terms = HashMultiset.create();

    for (String s : documents) {
      List<String> unnormalized = tokenizer.tokenize(s);

      // normalize them
      for (int i = 0; i < unnormalized.size(); i++) {
        String u = unnormalized.get(i);
        String norm = Util.normalize(u);
        if (!norm.isEmpty()) {
          terms.add(norm);
        }

        if (bigrams && (i < unnormalized.size() - 1)) {
          String second = unnormalized.get(i + 1);
          String normSecond = Util.normalize(second);
          if (!normSecond.isEmpty()) {
            terms.add(norm + "_" + normSecond);
          }
        }
      }
    }

    int i = 0;
    for (String term : terms.elementSet()) {
      if (terms.count(term) >= minOccurs // don't count infreq. words
          && term.length() >= minLength) { // or super short words
        if (!integerFeatureNames) {
          train.getMetadata().put(term, "boolean");
        } else {
          wordIndexMap.put(term, i++);
          train.getMetadata().put(String.valueOf(i), "boolean");
        }
      }
    }
  }
Esempio n. 23
0
  @Override
  public Multiset<Edge> getEdgesAt(int vertex) {

    if (vertex >= getNoOfVertices()) {
      throw new VertexNotInGraphException();
    }

    Multiset<Edge> edgesAt = HashMultiset.create();

    for (int i = 0; i < getNoOfVertices(); i++) {
      Edge e = new Edge(i, vertex);
      edgesAt.add(e, getMatrix()[vertex][i]);
    }
    return edgesAt;
  }
Esempio n. 24
0
  private void computeViolationsPerSeverities(DecoratorContext context) {
    Multiset<RulePriority> severitiesBag = HashMultiset.create();
    for (Violation violation : context.getViolations()) {
      severitiesBag.add(violation.getSeverity());
    }

    for (RulePriority severity : RulePriority.values()) {
      Metric metric = SeverityUtils.severityToViolationMetric(severity);
      if (context.getMeasure(metric) == null) {
        Collection<Measure> children = context.getChildrenMeasures(MeasuresFilters.metric(metric));
        int sum = MeasureUtils.sum(true, children).intValue() + severitiesBag.count(severity);
        context.saveMeasure(metric, (double) sum);
      }
    }
  }
Esempio n. 25
0
  @Override
  public Multiset<Edge> getEdges() {
    Multiset<Edge> edges = HashMultiset.create();

    for (int i = 0; i < getNoOfVertices(); i++) {
      for (int j = 0;
          j <= i;
          j++) { // we consider only the lower half of the matrix to avoid duplicate edges
        Edge e = new Edge(i, j);
        edges.add(e, getMatrix()[i][j]);
      }
    }

    return edges;
  }
 @Test
 public void should_fail_if_actual_contains_value_more_times_than_expected() {
   // given
   Multiset<String> actual = HashMultiset.create();
   actual.add("test", 2);
   // expect
   expectException(
       AssertionError.class,
       "%nExpecting:%n"
           + "  <[\"test\", \"test\"]>%n"
           + "to contain:%n"
           + "  <\"test\">%n"
           + "at most 1 times but was found 2 times.");
   // when
   assertThat(actual).containsAtMost(1, "test");
 }
Esempio n. 27
0
  public void testHashFloat() {
    Multiset<Integer> violations = HashMultiset.create();
    for (int k = 0; k < 1000; k++) {
      List<Float> original = Lists.newArrayList();

      Random gen = RandomUtils.getRandom();
      for (int i = 0; i < 10000; i++) {
        float x = (float) gen.nextDouble();
        original.add(x);
      }

      violations.add(checkCounts(original) <= 12 ? 0 : 1);
    }
    // the hashes for floats don't really have 32 bits of entropy so the test
    // only succeeds at better than about 99% rate.
    assertTrue(violations.count(0) >= 985);
  }
  private void checkAttributeNamesForDuplicates(ValueType type, Protoclass protoclass) {
    if (!type.attributes.isEmpty()) {
      Multiset<String> attributeNames = HashMultiset.create(type.attributes.size());
      for (ValueAttribute attribute : type.attributes) {
        attributeNames.add(attribute.name());
      }

      List<String> duplicates = Lists.newArrayList();
      for (Multiset.Entry<String> entry : attributeNames.entrySet()) {
        if (entry.getCount() > 1) {
          duplicates.add(entry.getElement());
        }
      }

      if (!duplicates.isEmpty()) {
        protoclass
            .report()
            .error(
                "Duplicate attribute names %s. You should check if correct @Value.Style applied",
                duplicates);
      }
    }
  }
Esempio n. 29
0
 public static Integer[] getIDs(boolean check) {
   if (check) {
     List<World> allWorlds = Lists.newArrayList(weakWorldMap.keySet());
     allWorlds.removeAll(worlds.values());
     for (ListIterator<World> li = allWorlds.listIterator(); li.hasNext(); ) {
       World w = li.next();
       leakedWorlds.add(System.identityHashCode(w));
     }
     for (World w : allWorlds) {
       int leakCount = leakedWorlds.count(System.identityHashCode(w));
       if (leakCount == 5) {
         FMLLog.fine(
             "The world %x (%s) may have leaked: first encounter (5 occurences).\n",
             System.identityHashCode(w), w.getWorldInfo().getWorldName());
       } else if (leakCount % 5 == 0) {
         FMLLog.fine(
             "The world %x (%s) may have leaked: seen %d times.\n",
             System.identityHashCode(w), w.getWorldInfo().getWorldName(), leakCount);
       }
     }
   }
   return getIDs();
 }
Esempio n. 30
0
  @Test
  public void testMultiset() {
    // Multiset is also known as a bag
    // From Daniel Hinojosa's examples

    Multiset<String> worldCupChampionships = HashMultiset.<String>create();
    worldCupChampionships.add("Brazil");
    worldCupChampionships.add("Brazil");
    worldCupChampionships.add("Brazil");
    worldCupChampionships.add("Brazil");
    worldCupChampionships.add("Brazil");
    worldCupChampionships.add("Italy");
    worldCupChampionships.add("Italy");
    worldCupChampionships.add("Italy");
    worldCupChampionships.add("Italy");
    worldCupChampionships.add("Germany", 3); // explicitly add count

    assertEquals(5, worldCupChampionships.count("Brazil"));
    assertEquals(4, worldCupChampionships.count("Italy"));
    assertEquals(3, worldCupChampionships.count("Germany"));

    // This doesn't give an exception... just says its in there zero times
    assertEquals(0, worldCupChampionships.count("United States"));
  }