Java UniformIntegerDistribution类代码示例

import org.apache.commons.math3.distribution.UniformIntegerDistribution; //导入依赖的package包/类
@Test
public void testWithInitialCapacity() {

    ResizableDoubleArray eDA2 = new ResizableDoubleArray(2);
    Assert.assertEquals("Initial number of elements should be 0", 0, eDA2.getNumElements());

    final IntegerDistribution randomData = new UniformIntegerDistribution(100, 1000);
    final int iterations = randomData.sample();

    for( int i = 0; i < iterations; i++) {
        eDA2.addElement( i );
    }

    Assert.assertEquals("Number of elements should be equal to " + iterations, iterations, eDA2.getNumElements());

    eDA2.addElement( 2.0 );

    Assert.assertEquals("Number of elements should be equals to " + (iterations +1),
            iterations + 1 , eDA2.getNumElements() );
}
 

import org.apache.commons.math3.distribution.UniformIntegerDistribution; //导入依赖的package包/类
private static <T> Iterable<T> sampleUniqueUsingIndexSet(final Collection<? extends T> collection,
                                                         final int n, final RandomGenerator rng) {
    final UniformIntegerDistribution distribution =
            new UniformIntegerDistribution(rng, 0, collection.size() - 1);
    final LinkedHashSet<Integer> indexSet = Sets.newLinkedHashSet();
    while (indexSet.size() != n) {
        indexSet.add(distribution.sample());
    }

    return Iterables.transform(indexSet, new Function<Integer, T>() {
        @Nullable
        @Override
        public T apply(final Integer input) {
            return Iterables.get(collection, input);
        }
    });
}
 

import org.apache.commons.math3.distribution.UniformIntegerDistribution; //导入依赖的package包/类
@Override
public String get() {

    if (loremIpsumImage == null) {
        synchronized (LoremExtractGenerator.class) {
            if (loremIpsumImage == null) {
                CharBuffer image= loadLoremIpsum();
                loremIpsumImage = image;
            }
            sizeDistribution = new UniformIntegerDistribution(rng, minsize, maxsize);
            positionDistribution = new UniformIntegerDistribution(rng, 1, loremIpsumImage.limit() - maxsize);
        }
    }

    int offset = positionDistribution.sample();
    int length = sizeDistribution.sample();
    String sub = null;
    try {
        sub = loremIpsumImage.subSequence(offset, offset + length).toString();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    return sub;
}
 

import org.apache.commons.math3.distribution.UniformIntegerDistribution; //导入依赖的package包/类
@Override
public RandomNumberDistribution<Integer> getUniformInteger(
		final RandomNumberStream rng, final Number lower, final Number upper)
{
	final IntegerDistribution dist = new UniformIntegerDistribution(
			RandomNumberStream.Util.asCommonsRandomGenerator(rng),
			lower.intValue(), upper.intValue());
	return new RandomNumberDistribution<Integer>()
	{
		@Override
		public Integer draw()
		{
			return dist.sample();
		}
	};
}
 

import org.apache.commons.math3.distribution.UniformIntegerDistribution; //导入依赖的package包/类
/**
 * Generate records in BED format.
 *
 * @param bedFile output BED file, if any
 * @param n number of BED records to generate, must be at least zero
 * @param size chromosome size, must be at least zero
 * @param chrom chromosome name, must not be null
 * @param random random generator, must not be null
 * @param length length distribution, must not be null
 */
public GenerateBed(final File bedFile, final int n, final int size, final String chrom, final RandomGenerator random, final RealDistribution length) {
    checkArgument(n >= 0, "n must be at least zero");
    checkArgument(size >= 0, "size must be at least zero");
    checkNotNull(chrom);
    checkNotNull(random);
    checkNotNull(length);
    this.bedFile = bedFile;
    this.n = n;
    this.size = size;
    this.chrom = chrom;
    this.random = random;
    this.length = length;

    int flanking = (int) (length.getNumericalMean() + length.getNumericalVariance());
    location = new UniformIntegerDistribution(this.random, 1 - flanking, size + flanking);
}
 

import org.apache.commons.math3.distribution.UniformIntegerDistribution; //导入依赖的package包/类
static BenchmarkData generate(int param, int howMany, int smallType, int bigType) {
  IntegerDistribution ud = new UniformIntegerDistribution(new Well19937c(param + 17),
      Short.MIN_VALUE, Short.MAX_VALUE);
  ClusteredDataGenerator cd = new ClusteredDataGenerator();
  IntegerDistribution p = new UniformIntegerDistribution(new Well19937c(param + 123),
      SMALLEST_ARRAY, BIGGEST_ARRAY / param);
  BenchmarkContainer[] smalls = new BenchmarkContainer[howMany];
  BenchmarkContainer[] bigs = new BenchmarkContainer[howMany];
  for (int i = 0; i < howMany; i++) {
    int smallSize = p.sample();
    int bigSize = smallSize * param;
    short[] small =
        smallType == 0 ? generateUniform(ud, smallSize) : generateClustered(cd, smallSize);
    short[] big = bigType == 0 ? generateUniform(ud, bigSize) : generateClustered(cd, bigSize);
    smalls[i] = new BenchmarkContainer(small);
    bigs[i] = new BenchmarkContainer(big);
  }
  return new BenchmarkData(smalls, bigs);
}
 

import org.apache.commons.math3.distribution.UniformIntegerDistribution; //导入依赖的package包/类
public RandomLineToString(String filename, MersenneTwister rng) {
    this.rng = rng;
    this.filename = filename;
    this.lines = ResourceFinder.readDataFileLines(filename);
    this.lines = ResourceFinder.readDataFileLines(filename);
    itemDistribution= new UniformIntegerDistribution(rng, 0, lines.size()-2);
}
 

import org.apache.commons.math3.distribution.UniformIntegerDistribution; //导入依赖的package包/类
public RandomFileExtractToString(String fileName, int minsize, int maxsize, long seed) {
    this.fileName = fileName;
    this.minsize = minsize;
    this.maxsize = maxsize;
    loadData();
    this.rng = new MersenneTwister(seed);
    this.sizeDistribution = new UniformIntegerDistribution(rng, minsize, maxsize);
    this.positionDistribution = new UniformIntegerDistribution(rng, 1, fileDataImage.limit() - maxsize);
}
 

import org.apache.commons.math3.distribution.UniformIntegerDistribution; //导入依赖的package包/类
/**
 * Select random Float value from the input with uniform distribution.
 *
 */
private void calculateUniformDistributedValue() {
	//		https://commons.apache.org/proper/commons-math/javadocs/api-3.2/org/apache/commons/math3/distribution/UniformIntegerDistribution.html
	String userInput = this.getInputOrDefault();
	if (!userInput.contains(";")) {
		this.value = Float.parseFloat(userInput);
		return;
	}
	String[] possibleValues = this.getInputOrDefault().split(";");
	UniformIntegerDistribution uniformIntegerDistribution = new UniformIntegerDistribution(0, possibleValues.length - 1);
	this.value = Float.parseFloat(possibleValues[uniformIntegerDistribution.sample()]);
}
 

import org.apache.commons.math3.distribution.UniformIntegerDistribution; //导入依赖的package包/类
public void prepare(WorkerTopologyContext context, GlobalStreamId stream, List<Integer> targetTasks) {
  this.targetTasks = targetTasks;
  int numTasks = targetTasks.size();
  if (numTasks % numShards != 0)
    throw new IllegalArgumentException("Number of tasks ("+numTasks+") should be a multiple of the number of shards ("+numShards+")!");

  this.tasksPerShard = numTasks/numShards;
  this.random = new UniformIntegerDistribution(0, tasksPerShard-1);

  CompositeIdRouter docRouter =  new CompositeIdRouter();
  this.ranges = docRouter.partitionRange(numShards, docRouter.fullRange());
}
 

import org.apache.commons.math3.distribution.UniformIntegerDistribution; //导入依赖的package包/类
public void prepare(WorkerTopologyContext context, GlobalStreamId stream, List<Integer> targetTasks) {
  this.targetTasks = targetTasks;
  int numTasks = targetTasks.size();
  int numShards = initShardInfo(); // setup for doing shard to task mapping 
  if (numTasks % numShards != 0)
    throw new IllegalArgumentException("Number of tasks ("+numTasks+") should be a multiple of the number of shards ("+numShards+")!");

  this.tasksPerShard = numTasks/numShards;
  this.random = new UniformIntegerDistribution(0, tasksPerShard-1);
}
 

import org.apache.commons.math3.distribution.UniformIntegerDistribution; //导入依赖的package包/类
/**
 * Generates a random sample of double values.
 * Sample size is random, between 10 and 100 and values are
 * uniformly distributed over [-100, 100].
 *
 * @return array of random double values
 */
private double[] generateSample() {
    final IntegerDistribution size = new UniformIntegerDistribution(10, 100);
    final RealDistribution randomData = new UniformRealDistribution(-100, 100);
    final int sampleSize = size.sample();
    final double[] out = randomData.sample(sampleSize);
    return out;
}
 

import org.apache.commons.math3.distribution.UniformIntegerDistribution; //导入依赖的package包/类
/**
 * Generates a partition of <sample> into up to 5 sequentially selected
 * subsamples with randomly selected partition points.
 *
 * @param sample array to partition
 * @return rectangular array with rows = subsamples
 */
private double[][] generatePartition(double[] sample) {
    final int length = sample.length;
    final double[][] out = new double[5][];
    int cur = 0;          // beginning of current partition segment
    int offset = 0;       // end of current partition segment
    int sampleCount = 0;  // number of segments defined 
    for (int i = 0; i < 5; i++) {
        if (cur == length || offset == length) {
            break;
        }
        final int next;
        if (i == 4 || cur == length - 1) {
            next = length - 1;
        } else {
            next = (new UniformIntegerDistribution(cur, length - 1)).sample();
        }
        final int subLength = next - cur + 1;
        out[i] = new double[subLength];
        System.arraycopy(sample, offset, out[i], 0, subLength);
        cur = next + 1;
        sampleCount++;
        offset += subLength;
    }
    if (sampleCount < 5) {
        double[][] out2 = new double[sampleCount][];
        for (int j = 0; j < sampleCount; j++) {
            final int curSize = out[j].length;
            out2[j] = new double[curSize];
            System.arraycopy(out[j], 0, out2[j], 0, curSize);
        }
        return out2;
    } else {
        return out;
    }
}
 

import org.apache.commons.math3.distribution.UniformIntegerDistribution; //导入依赖的package包/类
/**
 * Generate next generation sequencing (NGS/HTS) reads.
 *
 * @param reference reference, must not be null
 * @param variant FASTQ variant, must not be null
 * @param random random, must not be null
 * @param length length distribution, must not be null
 * @param quality quality strategy, must not be null
 * @param coverage coverage strategy, must not be null
 * @param mutationRate mutation rate, must be between <code>0.0</code> and <code>1.0</code>, inclusive
 * @param mutation mutation strategy, must not be null
 * @param appendable appendable, must not be null
 * @param writer FASTQ writer, must not be null
 */
public GenerateReads(final Sequence reference,
                              final FastqVariant variant,
                              final RandomGenerator random,
                              final RealDistribution length,
                              final QualityStrategy quality,
                              final CoverageStrategy coverage,
                              final double mutationRate,
                              final MutationStrategy mutation,
                              final Appendable appendable,
                              final FastqWriter writer) {

    checkNotNull(reference, "reference must not be null");
    checkNotNull(variant, "variant must not be null");
    checkNotNull(random, "random must not be null");
    checkNotNull(length, "length must not be null");
    checkNotNull(quality, "quality must not be null");
    checkNotNull(coverage, "coverage must not be null");
    checkArgument(mutationRate >= 0.0d, "mutationRate must be greater than or equal to 0.0d");
    checkArgument(mutationRate <= 1.0d, "mutationRate must be less than or equal to 1.0d");
    checkNotNull(mutation, "mutation must not be null");
    checkNotNull(appendable, "appendable must not be null");
    checkNotNull(writer, "writer must not be null");

    this.reference = reference;
    this.variant = variant;
    this.random = random;
    this.length = length;
    this.quality = quality;
    this.coverage = coverage;
    this.mutationRate = mutationRate;
    this.mutation = mutation;
    this.appendable = appendable;
    this.writer = writer;

    int flanking = (int) (length.getNumericalMean() + length.getNumericalVariance());
    location = new UniformIntegerDistribution(this.random, 1 - flanking, this.reference.length() + flanking);
}
 

import org.apache.commons.math3.distribution.UniformIntegerDistribution; //导入依赖的package包/类
/** Generate some disjoint itemsets as background noise */
public static HashMap<Itemset, Double> generateBackgroundItemsets(
		final int noItemsets, final double p, final int noItems,
		final double mu, final double sigma) {

	final HashMap<Itemset, Double> backgroundItemsets = Maps.newHashMap();

	final GeometricDistribution sizeDist = new GeometricDistribution(
			new Well19937c(1), p);
	final UniformIntegerDistribution itemDist = new UniformIntegerDistribution(
			20, 20 + noItems - 1);
	final LogNormalDistribution probDist = new LogNormalDistribution(
			new Well19937c(1), mu, sigma);

	while (backgroundItemsets.size() < noItemsets) {
		final int len = sizeDist.sample() + 1; // use shifted geometric
		final Itemset set = new Itemset();
		for (int i = 0; i < len; i++) {
			final int samp = itemDist.sample();
			set.add(samp);
		}
		final double num = probDist.sample();
		backgroundItemsets.put(set, num);
	}

	return backgroundItemsets;
}