/**
  * Returns a collection of multiset entries representing the counts of the distinct elements, in
  * sorted order. Does not check for null.
  */
 public static <E> Collection<Multiset.Entry<E>> sortedCounts(
     Comparator<? super E> comparator, Iterable<E> elements) {
   if (elements instanceof Multiset) {
     Multiset<E> multiset = (Multiset<E>) elements;
     if (hasSameComparator(comparator, elements)) {
       return multiset.entrySet();
     }
     List<Multiset.Entry<E>> entries = Lists.newArrayList(multiset.entrySet());
     Collections.sort(
         entries,
         Ordering.from(comparator)
             .onResultOf(
                 new Function<Multiset.Entry<E>, E>() {
                   @Override
                   public E apply(Entry<E> entry) {
                     return entry.getElement();
                   }
                 }));
     return entries;
   } else if (elements instanceof Set) { // known distinct
     Collection<E> sortedElements;
     if (hasSameComparator(comparator, elements)) {
       sortedElements = (Collection<E>) elements;
     } else {
       List<E> list = Lists.newArrayList(elements);
       Collections.sort(list, comparator);
       sortedElements = list;
     }
     return singletonEntries(sortedElements);
   } else if (hasSameComparator(comparator, elements)) {
     E current = null;
     int currentCount = 0;
     List<Multiset.Entry<E>> sortedEntries = Lists.newArrayList();
     for (E e : elements) {
       if (currentCount > 0) {
         if (comparator.compare(current, e) == 0) {
           currentCount++;
         } else {
           sortedEntries.add(Multisets.immutableEntry(current, currentCount));
           current = e;
           currentCount = 1;
         }
       } else {
         current = e;
         currentCount = 1;
       }
     }
     if (currentCount > 0) {
       sortedEntries.add(Multisets.immutableEntry(current, currentCount));
     }
     return sortedEntries;
   }
   TreeMultiset<E> multiset = TreeMultiset.create(comparator);
   Iterables.addAll(multiset, elements);
   return multiset.entrySet();
 }
 @Override
 public SampleElements<Multiset.Entry<E>> samples() {
   SampleElements<E> samples = gen.samples();
   return new SampleElements<Multiset.Entry<E>>(
       Multisets.immutableEntry(samples.e0, 3),
       Multisets.immutableEntry(samples.e1, 4),
       Multisets.immutableEntry(samples.e2, 1),
       Multisets.immutableEntry(samples.e3, 5),
       Multisets.immutableEntry(samples.e4, 2));
 }
Exemple #3
0
  public String getResultsComparison(int precision) {
    List<List<Object>> controlResults = controlResult.getResults();
    List<List<Object>> testResults = testResult.getResults();

    if (valid() || (controlResults == null) || (testResults == null)) {
      return "";
    }

    Multiset<List<Object>> control =
        ImmutableSortedMultiset.copyOf(rowComparator(precision), controlResults);
    Multiset<List<Object>> test =
        ImmutableSortedMultiset.copyOf(rowComparator(precision), testResults);

    try {
      Iterable<ChangedRow> diff =
          ImmutableSortedMultiset.<ChangedRow>naturalOrder()
              .addAll(
                  Iterables.transform(
                      Multisets.difference(control, test),
                      row -> new ChangedRow(Changed.REMOVED, row, precision)))
              .addAll(
                  Iterables.transform(
                      Multisets.difference(test, control),
                      row -> new ChangedRow(Changed.ADDED, row, precision)))
              .build();
      diff = Iterables.limit(diff, 100);

      StringBuilder sb = new StringBuilder();

      sb.append(format("Control %s rows, Test %s rows%n", control.size(), test.size()));
      if (verboseResultsComparison) {
        Joiner.on("\n").appendTo(sb, diff);
      } else {
        sb.append("RESULTS DO NOT MATCH\n");
      }

      return sb.toString();
    } catch (TypesDoNotMatchException e) {
      return e.getMessage();
    }
  }
Exemple #4
0
 /**
  * Adds each element of {@code elements} to the {@code ImmutableMultiset}.
  *
  * @param elements the {@code Iterable} to add to the {@code ImmutableMultiset}
  * @return this {@code Builder} object
  * @throws NullPointerException if {@code elements} is null or contains a null element
  */
 @Override
 public Builder<E> addAll(Iterable<? extends E> elements) {
   if (elements instanceof Multiset) {
     Multiset<? extends E> multiset = Multisets.cast(elements);
     for (Entry<? extends E> entry : multiset.entrySet()) {
       addCopies(entry.getElement(), entry.getCount());
     }
   } else {
     super.addAll(elements);
   }
   return this;
 }
  @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));
  }
Exemple #6
0
  /**
   * Returns an immutable multiset containing the given elements.
   *
   * <p>The multiset is ordered by the first occurrence of each element. For example, {@code
   * ImmutableMultiset.copyOf(Arrays.asList(2, 3, 1, 3))} yields a multiset with elements in the
   * order {@code 2, 3, 3, 1}.
   *
   * <p>Despite the method name, this method attempts to avoid actually copying the data when it is
   * safe to do so. The exact circumstances under which a copy will or will not be performed are
   * undocumented and subject to change.
   *
   * <p><b>Note:</b> Despite what the method name suggests, if {@code elements} is an {@code
   * ImmutableMultiset}, no copy will actually be performed, and the given multiset itself will be
   * returned.
   *
   * @throws NullPointerException if any of {@code elements} is null
   */
  public static <E> ImmutableMultiset<E> copyOf(Iterable<? extends E> elements) {
    if (elements instanceof ImmutableMultiset) {
      @SuppressWarnings("unchecked") // all supported methods are covariant
      ImmutableMultiset<E> result = (ImmutableMultiset<E>) elements;
      if (!result.isPartialView()) {
        return result;
      }
    }

    Multiset<? extends E> multiset =
        (elements instanceof Multiset)
            ? Multisets.cast(elements)
            : LinkedHashMultiset.create(elements);

    return copyOfInternal(multiset);
  }
  @Override
  public String toString() {
    final StringBuffer buf = new StringBuffer();
    for (final Entry<TSGNode, ConcurrentHashMultiset<TreeNode<TSGNode>>> rootEntry :
        grammar.entrySet()) {
      if (rootEntry.getValue().entrySet().isEmpty()) {
        continue;
      }
      final TSGNode root = rootEntry.getKey();
      buf.append("********\n");
      buf.append(treeFormat.getSymbol(root.nodeKey) + ":\n");
      for (final Multiset.Entry<TreeNode<TSGNode>> tree :
          Multisets.copyHighestCountFirst(rootEntry.getValue()).entrySet()) {
        final double prob = ((double) tree.getCount()) / rootEntry.getValue().size();
        buf.append("----------------------------------------\n");
        if (tree.getElement() != null) {
          if (tree.getElement().getData() != null) {
            buf.append(treeToString(tree.getElement()));
            buf.append("_________________________________\n");
            try {
              final TreeNode<Integer> intTree =
                  TreeNode.create(
                      tree.getElement().getData().nodeKey, tree.getElement().nProperties());
              TSGNode.copyChildren(intTree, tree.getElement());
              if (treeFormat.getSymbol(intTree.getData()).nodeType == AstNodeSymbol.MULTI_NODE) {
                treeFormat.printMultinode(buf, intTree);
              } else {
                buf.append(treeFormat.getCodeFromTree(intTree));
              }
            } catch (final Throwable e) {
              buf.append("Cannot get AST representation of rule");
            }
            buf.append("\n");
          } else {
            buf.append("null");
          }
        } else {
          buf.append("null");
        }

        buf.append(">Prob " + prob + " (" + tree.getCount() + ")\n");
      }
    }
    return buf.toString();
  }
Exemple #8
0
  private void identifyDuplicates(List<ModContainer> mods) {
    TreeMultimap<ModContainer, File> dupsearch =
        TreeMultimap.create(new ModIdComparator(), Ordering.arbitrary());
    for (ModContainer mc : mods) {
      if (mc.getSource() != null) {
        dupsearch.put(mc, mc.getSource());
      }
    }

    ImmutableMultiset<ModContainer> duplist = Multisets.copyHighestCountFirst(dupsearch.keys());
    SetMultimap<ModContainer, File> dupes = LinkedHashMultimap.create();
    for (Entry<ModContainer> e : duplist.entrySet()) {
      if (e.getCount() > 1) {
        FMLLog.severe(
            "Found a duplicate mod %s at %s",
            e.getElement().getModId(), dupsearch.get(e.getElement()));
        dupes.putAll(e.getElement(), dupsearch.get(e.getElement()));
      }
    }
    if (!dupes.isEmpty()) {
      throw new DuplicateModsFoundException(dupes);
    }
  }
Exemple #9
0
 @Override
 public String toString() {
   return Multisets.immutableEntry(getElement(), getCount()).toString();
 }
Exemple #10
0
 /**
  * Creates a new {@code HashMultiset} containing the specified elements.
  *
  * <p>This implementation is highly efficient when {@code elements} is itself a {@link Multiset}.
  *
  * @param elements the elements that the multiset should contain
  */
 public static <E> HashMultiset<E> create(Iterable<? extends E> elements) {
   HashMultiset<E> multiset = create(Multisets.inferDistinctElements(elements));
   Iterables.addAll(multiset, elements);
   return multiset;
 }
Exemple #11
0
  public void updateMapData(World par1World, Entity par2Entity, MapData par3MapData) {
    if (par1World.provider.dimensionId == par3MapData.dimension
        && par2Entity instanceof EntityPlayer) {
      int var4 = 1 << par3MapData.scale;
      int var5 = par3MapData.xCenter;
      int var6 = par3MapData.zCenter;
      int var7 = MathHelper.floor_double(par2Entity.posX - (double) var5) / var4 + 64;
      int var8 = MathHelper.floor_double(par2Entity.posZ - (double) var6) / var4 + 64;
      int var9 = 128 / var4;

      if (par1World.provider.hasNoSky) {
        var9 /= 2;
      }

      MapData.MapInfo var10 = par3MapData.func_82568_a((EntityPlayer) par2Entity);
      ++var10.field_82569_d;

      for (int var11 = var7 - var9 + 1; var11 < var7 + var9; ++var11) {
        if ((var11 & 15) == (var10.field_82569_d & 15)) {
          int var12 = 255;
          int var13 = 0;
          double var14 = 0.0D;

          for (int var16 = var8 - var9 - 1; var16 < var8 + var9; ++var16) {
            if (var11 >= 0 && var16 >= -1 && var11 < 128 && var16 < 128) {
              int var17 = var11 - var7;
              int var18 = var16 - var8;
              boolean var19 = var17 * var17 + var18 * var18 > (var9 - 2) * (var9 - 2);
              int var20 = (var5 / var4 + var11 - 64) * var4;
              int var21 = (var6 / var4 + var16 - 64) * var4;
              HashMultiset var22 = HashMultiset.create();
              Chunk var23 = par1World.getChunkFromBlockCoords(var20, var21);

              if (!var23.isEmpty()) {
                int var24 = var20 & 15;
                int var25 = var21 & 15;
                int var26 = 0;
                double var27 = 0.0D;
                int var29;

                if (par1World.provider.hasNoSky) {
                  var29 = var20 + var21 * 231871;
                  var29 = var29 * var29 * 31287121 + var29 * 11;

                  if ((var29 >> 20 & 1) == 0) {
                    var22.add(Blocks.dirt.getMapColor(0), 10);
                  } else {
                    var22.add(Blocks.stone.getMapColor(0), 100);
                  }

                  var27 = 100.0D;
                } else {
                  for (var29 = 0; var29 < var4; ++var29) {
                    for (int var30 = 0; var30 < var4; ++var30) {
                      int var31 = var23.getHeightValue(var29 + var24, var30 + var25) + 1;
                      Block var32 = Blocks.air;
                      int var33 = 0;

                      if (var31 > 1) {
                        do {
                          --var31;
                          var32 = var23.func_150810_a(var29 + var24, var31, var30 + var25);
                          var33 = var23.getBlockMetadata(var29 + var24, var31, var30 + var25);
                        } while (var32.getMapColor(var33) == MapColor.field_151660_b && var31 > 0);

                        if (var31 > 0 && var32.getMaterial().isLiquid()) {
                          int var34 = var31 - 1;
                          Block var35;

                          do {
                            var35 = var23.func_150810_a(var29 + var24, var34--, var30 + var25);
                            ++var26;
                          } while (var34 > 0 && var35.getMaterial().isLiquid());
                        }
                      }

                      var27 += (double) var31 / (double) (var4 * var4);
                      var22.add(var32.getMapColor(var33));
                    }
                  }
                }

                var26 /= var4 * var4;
                double var36 =
                    (var27 - var14) * 4.0D / (double) (var4 + 4)
                        + ((double) (var11 + var16 & 1) - 0.5D) * 0.4D;
                byte var39 = 1;

                if (var36 > 0.6D) {
                  var39 = 2;
                }

                if (var36 < -0.6D) {
                  var39 = 0;
                }

                MapColor var38 =
                    (MapColor)
                        Iterables.getFirst(
                            Multisets.copyHighestCountFirst(var22), MapColor.field_151660_b);

                if (var38 == MapColor.field_151662_n) {
                  var36 = (double) var26 * 0.1D + (double) (var11 + var16 & 1) * 0.2D;
                  var39 = 1;

                  if (var36 < 0.5D) {
                    var39 = 2;
                  }

                  if (var36 > 0.9D) {
                    var39 = 0;
                  }
                }

                var14 = var27;

                if (var16 >= 0
                    && var17 * var17 + var18 * var18 < var9 * var9
                    && (!var19 || (var11 + var16 & 1) != 0)) {
                  byte var37 = par3MapData.colors[var11 + var16 * 128];
                  byte var40 = (byte) (var38.colorIndex * 4 + var39);

                  if (var37 != var40) {
                    if (var12 > var16) {
                      var12 = var16;
                    }

                    if (var13 < var16) {
                      var13 = var16;
                    }

                    par3MapData.colors[var11 + var16 * 128] = var40;
                  }
                }
              }
            }
          }

          if (var12 <= var13) {
            par3MapData.setColumnDirty(var11, var12, var13);
          }
        }
      }
    }
  }
 /**
  * Returns an unmodifiable view of the union of the patterns, functions and variables multisets.
  *
  * @see org.kframework.kil.CollectionBuiltin#baseTerms
  */
 public Multiset<Term> baseTerms() {
   return Multisets.union(
       Multisets.union(collectionPatterns, collectionFunctions), collectionVariables);
 }