public void testBuilderAddAllMultiset() {
   Multiset<String> a = HashMultiset.create(asList("a", "b", "b"));
   Multiset<String> b = HashMultiset.create(asList("c", "b"));
   ImmutableMultiset<String> multiset =
       new ImmutableMultiset.Builder<String>().addAll(a).addAll(b).build();
   assertEquals(HashMultiset.create(asList("a", "b", "b", "b", "c")), multiset);
 }
 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 "";
 }
  /**
   * Sorts lookups based on their dependencies with each other. Non-lookups (i.e. everything except
   * #match, #setChoice, and #mapChoice) are in no particular order in this ordering, since they can
   * always be inferred later to occur at the final step after all other variables are bound.
   *
   * @return
   */
  private Stream<KApply> getSortedLookups() {
    List<Tuple2<KApply, KApply>> edges = new ArrayList<>();
    for (KApply k1 : state) {
      Multiset<KVariable> rhsVars = HashMultiset.create();
      if (k1.klabel().name().equals("Set:in")) {
        continue;
      }
      gatherVars(k1.klist().items().get(1), rhsVars);
      for (KApply k2 : state) {
        Multiset<KVariable> lhsVars = HashMultiset.create();
        if (k2.klabel().name().equals("Set:in")) {
          continue;
        }
        gatherVars(k2.klist().items().get(0), lhsVars);
        for (KVariable var : rhsVars) {
          if (lhsVars.contains(var)) {
            if (k1 != k2) {
              edges.add(Tuple2.apply(k2, k1));
              break;
            }
          }
        }
      }
    }

    List<KApply> topologicalSorted = mutable(TopologicalSort.tsort(immutable(edges)).toList());
    return state
        .stream()
        .sorted((k1, k2) -> (topologicalSorted.indexOf(k1) - topologicalSorted.indexOf(k2)));
  }
Esempio n. 4
0
 public void testConstrainedMapLegal() {
   Map<String, Integer> map = Maps.newLinkedHashMap();
   Map<String, Integer> constrained = MapConstraints.constrainedMap(map, TEST_CONSTRAINT);
   map.put(TEST_KEY, TEST_VALUE);
   constrained.put("foo", 1);
   map.putAll(ImmutableMap.of("bar", 2));
   constrained.putAll(ImmutableMap.of("baz", 3));
   assertTrue(map.equals(constrained));
   assertTrue(constrained.equals(map));
   assertEquals(map.entrySet(), constrained.entrySet());
   assertEquals(map.keySet(), constrained.keySet());
   assertEquals(HashMultiset.create(map.values()), HashMultiset.create(constrained.values()));
   assertFalse(map.values() instanceof Serializable);
   assertEquals(map.toString(), constrained.toString());
   assertEquals(map.hashCode(), constrained.hashCode());
   ASSERT
       .that(map.entrySet())
       .has()
       .allOf(
           Maps.immutableEntry(TEST_KEY, TEST_VALUE),
           Maps.immutableEntry("foo", 1),
           Maps.immutableEntry("bar", 2),
           Maps.immutableEntry("baz", 3))
       .inOrder();
 }
 public void testBuilderAddAllMultiset() {
   Multiset<String> a = HashMultiset.create(asList("a", "b", "b"));
   Multiset<String> b = HashMultiset.create(asList("c", "b"));
   ImmutableSortedMultiset<String> multiset =
       ImmutableSortedMultiset.<String>naturalOrder().addAll(a).addAll(b).build();
   assertEquals(HashMultiset.create(asList("a", "b", "b", "b", "c")), multiset);
 }
Esempio n. 6
0
 /** Returns {@code true} if the second list is a permutation of the first. */
 private static boolean isPermutation(List<?> first, List<?> second) {
   if (first.size() != second.size()) {
     return false;
   }
   Multiset<?> firstMultiset = HashMultiset.create(first);
   Multiset<?> secondMultiset = HashMultiset.create(second);
   return firstMultiset.equals(secondMultiset);
 }
Esempio n. 7
0
  public void addNode(int node) {
    maxVNum = Math.max(maxVNum, node);

    if (!nodeOutEdges.containsKey(node)) {
      nodeOutEdges.put(node, HashMultiset.<Integer>create());
      nodeInEdges.put(node, HashMultiset.<Integer>create());
    }
  }
Esempio n. 8
0
  @Override
  public boolean matchesSafely(final Iterable<? super K> actual) {
    final Multiset<?> comparisonMultiSet = HashMultiset.create(comparisonIterable);
    final Multiset<?> actualMultiSet = HashMultiset.create(actual);

    for (final Object key : actualMultiSet.elementSet()) {
      if (!comparisonMultiSet.contains(key)
          || comparisonMultiSet.count(key) < actualMultiSet.count(key)) {
        return false;
      }
    }
    return true;
  }
Esempio n. 9
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);
  }
Esempio n. 10
0
  private Iterable<?> notRepeated(
      Iterable<? super K> actual, Iterable<? super K> comparisonIterable) {
    final Multiset<?> comparisonMultiSet = HashMultiset.create(comparisonIterable);
    final Multiset<?> actualMultiSet = HashMultiset.create(actual);

    final Set<Object> notRepeated = newHashSet();
    for (final Object key : actualMultiSet.elementSet()) {
      if (!comparisonMultiSet.contains(key)
          || comparisonMultiSet.count(key) < actualMultiSet.count(key)) {
        notRepeated.add(key);
      }
    }
    return notRepeated;
  }
 public void testCreation_arrayOfArray() {
   String[] array = new String[] {"a"};
   Multiset<String[]> multiset = ImmutableMultiset.<String[]>of(array);
   Multiset<String[]> expected = HashMultiset.create();
   expected.add(array);
   assertEquals(expected, multiset);
 }
  public void upload(
      @Observes ControllerFound event,
      MutableRequest request,
      MultipartConfig config,
      Validator validator) {

    if (!ServletFileUpload.isMultipartContent(request)) {
      return;
    }

    logger.info("Request contains multipart data. Try to parse with commons-upload.");

    final Multiset<String> indexes = HashMultiset.create();
    final Multimap<String, String> params = LinkedListMultimap.create();

    ServletFileUpload uploader = createServletFileUpload(config);

    UploadSizeLimit uploadSizeLimit =
        event.getMethod().getMethod().getAnnotation(UploadSizeLimit.class);
    uploader.setSizeMax(
        uploadSizeLimit != null ? uploadSizeLimit.sizeLimit() : config.getSizeLimit());
    uploader.setFileSizeMax(
        uploadSizeLimit != null ? uploadSizeLimit.fileSizeLimit() : config.getFileSizeLimit());
    logger.debug(
        "Setting file sizes: total={}, file={}", uploader.getSizeMax(), uploader.getFileSizeMax());

    try {
      final List<FileItem> items = uploader.parseRequest(request);
      logger.debug(
          "Found {} attributes in the multipart form submission. Parsing them.", items.size());

      for (FileItem item : items) {
        String name = item.getFieldName();
        name = fixIndexedParameters(name, indexes);

        if (item.isFormField()) {
          logger.debug("{} is a field", name);
          params.put(name, getValue(item, request));

        } else if (isNotEmpty(item)) {
          logger.debug("{} is a file", name);
          processFile(item, name, request);

        } else {
          logger.debug("A file field is empty: {}", item.getFieldName());
        }
      }

      for (String paramName : params.keySet()) {
        Collection<String> paramValues = params.get(paramName);
        request.setParameter(paramName, paramValues.toArray(new String[paramValues.size()]));
      }

    } catch (final SizeLimitExceededException e) {
      reportSizeLimitExceeded(e, validator);

    } catch (FileUploadException e) {
      reportFileUploadException(e, validator);
    }
  }
Esempio n. 13
0
 /**
  * Map Corresponding Multiset Supports null elements HashMap HashMultiset Yes TreeMap TreeMultiset
  * Yes (if the comparator does) LinkedHashMap LinkedHashMultiset Yes ConcurrentHashMap
  * ConcurrentHashMultiset No ImmutableMap ImmutableMultiset No
  */
 @Test
 public void testHashMultiset() {
   Multiset<String> m = HashMultiset.create();
   loadTestData(m);
   System.out.println(m);
   // [b, -1, c, a x 3]
 }
Esempio n. 14
0
  @SuppressWarnings("unchecked")
  @Override
  public final void open() throws Exception {
    super.open();

    timestampedCollector = new TimestampedCollector<>(output);

    if (inputSerializer == null) {
      throw new IllegalStateException("Input serializer was not set.");
    }

    // these could already be initialized from restoreState()
    if (watermarkTimers == null) {
      watermarkTimers = new HashSet<>();
      watermarkTimersQueue = new PriorityQueue<>(100);
    }
    if (processingTimeTimers == null) {
      processingTimeTimers = new HashSet<>();
      processingTimeTimerTimestamps = HashMultiset.create();
      processingTimeTimersQueue = new PriorityQueue<>(100);
    }

    // ScheduledFutures are not checkpointed
    processingTimeTimerFutures = new HashMap<>();

    context = new Context(null, null);

    if (windowAssigner instanceof MergingWindowAssigner) {
      mergingWindowsByKey = new HashMap<>();
    }

    currentWatermark = Long.MIN_VALUE;
  }
  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 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);
     }
   }
 }
Esempio n. 17
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. 18
0
 public void testCreateWithSize() {
   Multiset<String> multiset = HashMultiset.create(50);
   multiset.add("foo", 2);
   multiset.add("bar");
   assertEquals(3, multiset.size());
   assertEquals(2, multiset.count("foo"));
 }
Esempio n. 19
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);
    }
  }
 public void testCopyOf_multisetContainingNull() {
   Multiset<String> c = HashMultiset.create(asList("a", null, "b"));
   try {
     ImmutableMultiset.copyOf(c);
     fail();
   } catch (NullPointerException expected) {
   }
 }
Esempio n. 21
0
 @GwtIncompatible // SerializableTester
 public void testSerializationContainingSelf() {
   Multiset<Multiset<?>> multiset = HashMultiset.create();
   multiset.add(multiset, 2);
   Multiset<Multiset<?>> copy = SerializableTester.reserialize(multiset);
   assertEquals(2, copy.size());
   assertSame(copy, copy.iterator().next());
 }
Esempio n. 22
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"));
  }
 public void testBuilderSetCount() {
   ImmutableSortedMultiset<String> multiset =
       ImmutableSortedMultiset.<String>naturalOrder()
           .add("a")
           .setCount("a", 2)
           .setCount("b", 3)
           .build();
   assertEquals(HashMultiset.create(asList("a", "a", "b", "b", "b")), multiset);
 }
 @Test
 public void should_fail_if_expected_is_negative() {
   // given
   Multiset<String> actual = HashMultiset.create();
   // expect
   expectException(IllegalArgumentException.class, "The maximum count should not be negative.");
   // when
   assertThat(actual).containsAtMost(-1, "test");
 }
Esempio n. 25
0
 private Multiset<Rule> initRules(
     Map<RulePriority, Multiset<Rule>> rulesPerSeverity, RulePriority severity) {
   Multiset<Rule> rulesBag = rulesPerSeverity.get(severity);
   if (rulesBag == null) {
     rulesBag = HashMultiset.create();
     rulesPerSeverity.put(severity, rulesBag);
   }
   return rulesBag;
 }
 @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
 }
Esempio n. 27
0
 @GwtIncompatible // SerializableTester
 public void testSerializationIndirectSelfReference() {
   Multiset<MultisetHolder> multiset = HashMultiset.create();
   MultisetHolder holder = new MultisetHolder(multiset);
   multiset.add(holder, 2);
   Multiset<MultisetHolder> copy = SerializableTester.reserialize(multiset);
   assertEquals(2, copy.size());
   assertSame(copy, copy.iterator().next().member);
 }
 public void testBuilderAddCopies() {
   ImmutableMultiset<String> multiset =
       new ImmutableMultiset.Builder<String>()
           .addCopies("a", 2)
           .addCopies("b", 3)
           .addCopies("c", 0)
           .build();
   assertEquals(HashMultiset.create(asList("a", "a", "b", "b", "b")), multiset);
 }
Esempio n. 29
0
 @Override
 public List<List<List<TPlayer>>> generateMatchups(
     List<TPlayer> players, int numRoles, int numMatches) {
   List<List<List<TPlayer>>> results = Lists.newArrayList();
   Multiset<Set<TPlayer>> matchupsSoFar = HashMultiset.create();
   for (int round = 0; round < numMatches; round++) {
     results.add(getNonFixedSumPlayerGroups(players, numRoles, matchupsSoFar));
   }
   return results;
 }
Esempio n. 30
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);
 }