Doubles.constrainToRange(double,double,double) and Floats.constrainToRange(float,float,float) both cause unnecessary boxing of their arguments. Both call Preconditions.checkArgument(boolean, String, **Object**, **Object**) which causes the boxing.

Can be easily fixed by introducing an overloaded version of checkArgument for floats and doubles. For ints and longs these versions already exist:
Preconditions.checkArgument(boolean, String, **int**, **int**)
Preconditions.checkArgument(boolean, String, **long**, **long**)
which is also why constrainToRange does not have the same problem in the Ints, Shorts & Longs packages.
@CanIgnoreReturnValue
  static int checkNoConflictInKeyBucket(
      Object key, Entry<?, ?> entry, @Nullable ImmutableMapEntry<?, ?> keyBucketHead) {
    int bucketSize = 0;
    for (; keyBucketHead != null; keyBucketHead = keyBucketHead.getNextInKeyBucket()) {
      checkNoConflict(!key.equals(keyBucketHead.getKey()), "key", entry, keyBucketHead);
      bucketSize++;
    }
    return bucketSize;
  }
  @Override
  public V get(@Nullable Object key) {
    return get(key, table, mask);
  }
  static <V> @Nullable V get(
      @Nullable Object key, ImmutableMapEntry<?, V> @Nullable [] keyTable, int mask) {
    if (key == null || keyTable == null) {
      return null;
    }
    int index = Hashing.smear(key.hashCode()) & mask;
    for (ImmutableMapEntry<?, V> entry = keyTable[index];
        entry != null;
        entry = entry.getNextInKeyBucket()) {
      Object candidateKey = entry.getKey();
      /*
       * Assume that equals uses the == optimization when appropriate, and that
       * it would check hash codes as an optimization when appropriate. If we
       * did these things, it would just make things worse for the most
       * performance-conscious users.
       */