}
                }
            }
        }
    }

    void noBuildTriggered(int waitSeconds = 3) {
        // TODO - change this general strategy to positively detect changes we are ignoring instead of asserting that a build doesn't happen in some time frame
        try {
            ConcurrentTestUtil.poll(waitSeconds, 0.5) {

    auto x_data_flat = (*x_datas)[x_idx].flat<X_T>();
    const int64_t x_size = x_shapes[x_idx].num_elements();

    // Compute the numeric Jacobian one column at a time by perturbing each
    // element of 'x_data' (positively and negatively) by 'delta', and
    // updating the jacobian with the centered difference. When x_data is
    // complex-valued, we perturb its real and complex parts separately.
    for (int r = 0; r < x_size; ++r) {

Build authors do not need to worry about keeping task dependencies in sync with configuration changes.
3. *Improved Build Performance:* Avoids resource-intensive work during configuration, impacting build performance positively.

    for (int i = 0; i < numInsertions * 2; i += 2) {
      assertTrue(bf.mightContain(Integer.toString(i)));
    }

    // Now we check for known false positives using a set of known false positives.
    // (These are all of the false positives under 900.)
    ImmutableSet<Integer> falsePositives =
        ImmutableSet.of(
            49, 51, 59, 163, 199, 321, 325, 363, 367, 469, 545, 561, 727, 769, 773, 781);

   * @param expectedInsertions the number of expected insertions to the constructed {@code
   *     BloomFilter}; must be positive
   * @param fpp the desired false positive probability (must be positive and less than 1.0)
   * @return a {@code Collector} generating a {@code BloomFilter} of the received elements
   * @since 23.0
   */

 * @author Louis Wasserman
 */
public class IntMathRoundingBenchmark {
  private static final int[] positive = new int[ARRAY_SIZE];
  private static final int[] nonzero = new int[ARRAY_SIZE];
  private static final int[] ints = new int[ARRAY_SIZE];

  @BeforeExperiment
  void setUp() {
    for (int i = 0; i < ARRAY_SIZE; i++) {
      positive[i] = randomPositiveBigInteger(Integer.SIZE - 2).intValue();

  private static final long[] positive = new long[ARRAY_SIZE];
  private static final long[] nonnegative = new long[ARRAY_SIZE];
  private static final long[] longs = new long[ARRAY_SIZE];

  @BeforeExperiment
  void setUp() {
    for (int i = 0; i < ARRAY_SIZE; i++) {
      exponents[i] = randomExponent();
      positive[i] = randomPositiveBigInteger(Long.SIZE - 1).longValue();

  private static final BigInteger[] nonzero2 = new BigInteger[ARRAY_SIZE];
  private static final BigInteger[] positive = new BigInteger[ARRAY_SIZE];

  @Param({"DOWN", "UP", "FLOOR", "CEILING", "HALF_EVEN", "HALF_UP", "HALF_DOWN"})
  RoundingMode mode;

  @BeforeExperiment
  void setUp() {
    for (int i = 0; i < ARRAY_SIZE; i++) {
      positive[i] = randomPositiveBigInteger(1024);
      nonzero1[i] = randomNonZeroBigInteger(1024);

import org.jetbrains.kotlin.psi.KtAnnotated
import org.jetbrains.kotlin.psi.KtElement

/**
 * A service to match declarations with their annotations and vice versa.
 *
 * N.B. This service can produce both false positives and false negatives from time to time, since it might not be allowed to use
 * full-blown resolve to understand the true FqName of used annotation.
 *
 * The next statement should be `true` for any `annotation`:
 * ```

  private static final BigInteger[] nonzero2 = new BigInteger[ARRAY_SIZE];
  private static final BigInteger[] positive = new BigInteger[ARRAY_SIZE];

  @Param({"DOWN", "UP", "FLOOR", "CEILING", "HALF_EVEN", "HALF_UP", "HALF_DOWN"})
  RoundingMode mode;

  @BeforeExperiment
  void setUp() {
    for (int i = 0; i < ARRAY_SIZE; i++) {
      positive[i] = randomPositiveBigInteger(1024);
      nonzero1[i] = randomNonZeroBigInteger(1024);