Java LongMath類代碼示例

import com.google.common.math.LongMath; //導入依賴的package包/類
static int bitsForNumElementsWithLoadFactor(long numElements) {
    if (numElements == 0) {
        return 1;
    }

    int candidateBits = Long.bitCount(numElements) == 1 ?
            Math.max(1, Long.numberOfTrailingZeros(numElements)) :
            Long.numberOfTrailingZeros(Long.highestOneBit(numElements) << 1L);

    //May need an extra bit due to load factor
    if (((long) (LongMath.pow(2, candidateBits) * 0.75)) < numElements) {
        candidateBits++;
    }

    return candidateBits;
}
 

import com.google.common.math.LongMath; //導入依賴的package包/類
/**
 * Returns a {@link Stream} containing the elements of the first stream, followed by the elements
 * of the second stream, and so on.
 *
 * <p>This is equivalent to {@code Stream.of(streams).flatMap(stream -> stream)}, but the returned
 * stream may perform better.
 *
 * @see Stream#concat(Stream, Stream)
 */
@SafeVarargs
public static <T> Stream<T> concat(Stream<? extends T>... streams) {
  // TODO(lowasser): consider an implementation that can support SUBSIZED
  boolean isParallel = false;
  int characteristics = Spliterator.ORDERED | Spliterator.SIZED | Spliterator.NONNULL;
  long estimatedSize = 0L;
  ImmutableList.Builder<Spliterator<? extends T>> splitrsBuilder =
      new ImmutableList.Builder<>(streams.length);
  for (Stream<? extends T> stream : streams) {
    isParallel |= stream.isParallel();
    Spliterator<? extends T> splitr = stream.spliterator();
    splitrsBuilder.add(splitr);
    characteristics &= splitr.characteristics();
    estimatedSize = LongMath.saturatedAdd(estimatedSize, splitr.estimateSize());
  }
  return StreamSupport.stream(
      CollectSpliterators.flatMap(
          splitrsBuilder.build().spliterator(),
          splitr -> (Spliterator<T>) splitr,
          characteristics,
          estimatedSize),
      isParallel);
}
 

import com.google.common.math.LongMath; //導入依賴的package包/類
/**
 * @param alphabet the alphabet of legal characters for IDs generated by this generator
 * @param perturb whether or not to perturb generated IDs by a random perturbation to avoid
 *                collisions in distributed key generation. Pass {@code false} if this generator
 *                is used to generate a sort key that is a secondary key where ordering
 *                conflicts can be deterministically resolved by the primary key. This setting
 *                only applies to the {@code generate...} methods.
 */
public IdGenerator(IdAlphabet alphabet, boolean perturb) {
    mAlphabet = alphabet;
    mPerturb = perturb;

    // Find the maximum number of digits we'd need to encode an unsigned long if the radix were
    // uniform for the entire string.
    // ceil(log_RADIX(Long.MAX + 1))
    mLongUniformRadixLength = (int) Math.ceil(LOG_LONG / Math.log(alphabet.radix()));
    mMostSignificantUnit = LongMath.pow(alphabet.radix(), mLongUniformRadixLength - 1);

    mMaxSafeMostSignificantDigit = (int) (Long.MAX_VALUE / mMostSignificantUnit);
    mMaxSafeMostSignificantValue = mMaxSafeMostSignificantDigit * mMostSignificantUnit;

    // The first character may have additional restrictions, so we have less chars to work with
    // for the first digit. If we still have enough digits, we'll proceed and just use a special
    // mapping for the leading digit. Otherwise, we'll pad by a leading zero, thus making the
    // remaining encoding the common case.

    // So, what most-significant digit do we need to encode the max unsigned value?
    PartialDivisionResult div = transformToSignedDivision(-1);
    int maxMostSignficantDigit = div.partialMostSignificantDigit +
            (int) (div.partialRemainder / mMostSignificantUnit);
    mLongEncodedLength = maxMostSignficantDigit < alphabet.leadingRadix() ?
            mLongUniformRadixLength : mLongUniformRadixLength + 1;
}
 

import com.google.common.math.LongMath; //導入依賴的package包/類
private static Long toL(String value) {
	if (null == value) {
		return 0L;
	}
	
	int idxSep = value.indexOf(SEPARATOR_CHAR);
	if (idxSep > -1) {
		value = value.substring(idxSep + 1);
	}
	
	long r = 0;
	int length = value.length();
	for (int i = 0; i < length; i++) {
		long val = LongMath.pow(RADIX, (length - i - 1));
		char c = value.charAt(i);
		int tmp = KEYS.indexOf(c);
		r += (tmp * val);
	}

	return r;
}
 

import com.google.common.math.LongMath; //導入依賴的package包/類
@Override
final long reserveEarliestAvailable(int requiredPermits, long nowMicros) {
  resync(nowMicros);
  long returnValue = nextFreeTicketMicros;
  double storedPermitsToSpend = min(requiredPermits, this.storedPermits);
  double freshPermits = requiredPermits - storedPermitsToSpend;
  long waitMicros = storedPermitsToWaitTime(this.storedPermits, storedPermitsToSpend)
      + (long) (freshPermits * stableIntervalMicros);

  try {
    this.nextFreeTicketMicros = LongMath.checkedAdd(nextFreeTicketMicros, waitMicros);
  } catch (ArithmeticException e) {
    this.nextFreeTicketMicros = Long.MAX_VALUE;
  }
  this.storedPermits -= storedPermitsToSpend;
  return returnValue;
}
 

import com.google.common.math.LongMath; //導入依賴的package包/類
public static Long incrementMisReplicatedIndex(final int increment)
    throws IOException {
  return (Long) new LightWeightRequestHandler(
      HDFSOperationType.INCREMENT_MIS_REPLICATED_FILES_INDEX) {
    @Override
    public Object performTask() throws IOException {

      return handleVariableWithWriteLock(new Handler() {
        @Override
        public Object handle(VariableDataAccess<Variable, Variable.Finder> vd)
            throws StorageException {
          LongVariable var = (LongVariable) vd
              .getVariable(Variable.Finder.MisReplicatedFilesIndex);
          long oldValue = var == null ? 0 : var.getValue();
          long newValue = increment == 0 ? 0 : LongMath.checkedAdd
              (oldValue, increment);
          vd.setVariable(new LongVariable(Variable.Finder.MisReplicatedFilesIndex,
              newValue));
          return newValue;
        }
      });
    }
  }.handle();
}
 

import com.google.common.math.LongMath; //導入依賴的package包/類
/**
 * Expand a polynomial power with the multinomial theorem. See
 * <a href= "http://en.wikipedia.org/wiki/Multinomial_theorem">Wikipedia - Multinomial theorem</a>
 * 
 * @param plusAST
 * @param n
 *            <code>n &ge; 0</code>
 * @return
 */
private IExpr expandPower(final IAST plusAST, final int n) {
	if (n == 1) {
		IExpr temp = expandPlus(plusAST);
		if (temp.isPresent()) {
			return temp;
		}
		addExpanded(plusAST);
		return plusAST;
	}
	if (n == 0) {
		return F.C1;
	}

	int k = plusAST.argSize();
	long numberOfTerms = LongMath.binomial(n + k - 1, n);
	if (numberOfTerms > Integer.MAX_VALUE) {
		throw new ArithmeticException("");
	}
	final IASTAppendable expandedResult = F.ast(F.Plus, (int) numberOfTerms, false);
	Expand.NumberPartititon part = new Expand.NumberPartititon(plusAST, n, expandedResult);
	part.partition();
	return PlusOp.plus(expandedResult);
}
 

import com.google.common.math.LongMath; //導入依賴的package包/類
public static LongObjectMap<float[]> loadPartialY(int partition,
                                                int numPartitions,
                                                String prefix,
                                                Configuration conf) throws IOException {
  LongObjectMap<float[]> result = new LongObjectMap<float[]>();
  AvroFileSource<MatrixRow> records = new AvroFileSource<MatrixRow>(
      Namespaces.toPath(prefix),
      (AvroType<MatrixRow>) ALSTypes.DENSE_ROW_MATRIX);
  for (MatrixRow record : records.read(conf)) {
    long id = record.getRowId();
    if (LongMath.mod(id, numPartitions) == partition) {
      result.put(id, record.getValues());
    }
  }
  return result;
}
 

import com.google.common.math.LongMath; //導入依賴的package包/類
protected static byte[] getBytes(long sum, int arraySize) {
    final byte[] b = new byte[arraySize];
    for (int i = 0; i < b.length; i++) {
        final int reverseIndex = b.length - 1 - i;
        final long factor = LongMath.pow(256, reverseIndex);
        final long base = sum / factor;
        b[i] = UnsignedBytes.checkedCast(base);
        sum = sum - (base * factor);
    }
    return b;
}
 

import com.google.common.math.LongMath; //導入依賴的package包/類
protected static long getLong(byte[] b) {
    long sum = 0;
    for (int i = 0; i < b.length; i++) {
        final int reverseIndex = b.length - 1 - i;
        final long factor = LongMath.pow(256, reverseIndex);
        final int base = UnsignedBytes.toInt(b[i]);
        sum += base * factor;
    }
    return sum;
}
 

import com.google.common.math.LongMath; //導入依賴的package包/類
@Override
final long reserveEarliestAvailable(int requiredPermits, long nowMicros) {
  resync(nowMicros);
  long returnValue = nextFreeTicketMicros;
  double storedPermitsToSpend = min(requiredPermits, this.storedPermits);
  double freshPermits = requiredPermits - storedPermitsToSpend;
  long waitMicros =
      storedPermitsToWaitTime(this.storedPermits, storedPermitsToSpend)
          + (long) (freshPermits * stableIntervalMicros);

  this.nextFreeTicketMicros = LongMath.saturatedAdd(nextFreeTicketMicros, waitMicros);
  this.storedPermits -= storedPermitsToSpend;
  return returnValue;
}
 

import com.google.common.math.LongMath; //導入依賴的package包/類
@AndroidIncompatible // slow
public void testBitSize() {
  double fpp = 0.03;
  for (int i = 1; i < 10000; i++) {
    long numBits = BloomFilter.optimalNumOfBits(i, fpp);
    int arraySize = Ints.checkedCast(LongMath.divide(numBits, 64, RoundingMode.CEILING));
    assertEquals(
        arraySize * Long.SIZE,
        BloomFilter.create(Funnels.unencodedCharsFunnel(), i, fpp).bitSize());
  }
}
 

import com.google.common.math.LongMath; //導入依賴的package包/類
public static void run() throws Exception {
  Job job = new JobDetail(); // 創建Job
  executorService = Executors.newFixedThreadPool(N_THRESHOLDS); // 新建固定大小線程的池子
  for (int i = 0; i < N_THRESHOLDS; i++) {
    executorService.submit(new Worker(job)); // 提交線程到池子中
  }
  // 還需要一個線程，用於周期檢查執行時間是否到達
  final ScheduledExecutorService scheduledExcutor = Executors.newSingleThreadScheduledExecutor();
  scheduledExcutor.scheduleAtFixedRate(new Runnable() {
    public void run() {
      if (totalTime.decrementAndGet() == 0) { // 執行時間遞減到0
        runnning = false; // 告訴線程，時間到了，所有線程不再執行
        scheduledExcutor.shutdownNow();
      }
    }
  }, 1L, 1L, TimeUnit.SECONDS);

  // 主線程等到所有的線程都退出，則開始統計
  countDownLatch.await();

  long totalExeCount = totalExecCount.get();
  System.out.println(N_THRESHOLDS + " 個線程，" + TIME_THRESHOLDS + " 秒內總共執行的事物數量：" + totalExeCount);

  long tps = LongMath.divide(totalExeCount, TIME_THRESHOLDS, RoundingMode.HALF_EVEN);

  System.out.println("OKHttp執行的TPS: " + tps);

  executorService.shutdownNow(); // 關閉線程池


}
 

import com.google.common.math.LongMath; //導入依賴的package包/類
@Override
public Long evaluate(Input<Integer>... args) {
    long millis = DateTimeUtils.currentTimeMillis();
    if (args.length == 1) {
        Integer precision = args[0].value();
        if (precision == null) {
            throw new IllegalArgumentException(String.format(Locale.ENGLISH,
                    "NULL precision not supported for %s", NAME));
        }
        int factor;
        switch (precision) {
            case 0:
                factor = 1000;
                break;
            case 1:
                factor = 100;
                break;
            case 2:
                factor = 10;
                break;
            case 3:
                factor = 1;
                break;
            default:
                throw new IllegalArgumentException("Precision must be between 0 and 3");
        }
        millis = LongMath.divide(millis, factor, RoundingMode.DOWN) * factor;
    }
    return millis;
}
 

import com.google.common.math.LongMath; //導入依賴的package包/類
public static long kCombinationCount(int n, int k) {
    long result;
    if(k > n) {
        result = 0;
    } else {
      //result = LongMath.factorial(n) / LongMath.factorial(n - k);

//The formula below should be equal to the one above
        long combinationCount = LongMath.binomial(n, k);
        long permutationCount = LongMath.factorial(k);
        result = combinationCount * permutationCount;
    }
    return result;
}