Module org.cicirello.jpt
Package org.cicirello.sequences

Interface SequenceSampler

All Known Implementing Classes:
SequenceCompositeSampler, SequenceInsertionSampler, SequencePoolSampler, SequenceReservoirSampler
public interface SequenceSampler
An implementation of the SequenceSampler interface is used for generating random samples of array elements, without replacement.

  • Method Summary

    Modifier and Type
    Method
    Description
    default byte[]
    nextSample(byte[] source, double p)
    Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
    byte[]
    nextSample(byte[] source, int k, byte[] target)
    Generates a random sample of k elements, without replacement, from a given source array.
    default char[]
    nextSample(char[] source, double p)
    Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
    char[]
    nextSample(char[] source, int k, char[] target)
    Generates a random sample of k elements, without replacement, from a given source array.
    default double[]
    nextSample(double[] source, double p)
    Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
    double[]
    nextSample(double[] source, int k, double[] target)
    Generates a random sample of k elements, without replacement, from a given source array.
    default float[]
    nextSample(float[] source, double p)
    Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
    float[]
    nextSample(float[] source, int k, float[] target)
    Generates a random sample of k elements, without replacement, from a given source array.
    default int[]
    nextSample(int[] source, double p)
    Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
    int[]
    nextSample(int[] source, int k, int[] target)
    Generates a random sample of k elements, without replacement, from a given source array.
    default long[]
    nextSample(long[] source, double p)
    Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
    long[]
    nextSample(long[] source, int k, long[] target)
    Generates a random sample of k elements, without replacement, from a given source array.
    default short[]
    nextSample(short[] source, double p)
    Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
    short[]
    nextSample(short[] source, int k, short[] target)
    Generates a random sample of k elements, without replacement, from a given source array.
    default char[]
    nextSample(String source, double p)
    Generates a random sample, without replacement, from a given source String with a specified probability of an element's inclusion in the sample.
    char[]
    nextSample(String source, int k, char[] target)
    Generates a random sample of k elements, without replacement, from a given source String.
    default <T> T[]
    nextSample(T[] source, double p)
    Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
    <T> T[]
    nextSample(T[] source, int k, T[] target)
    Generates a random sample of k elements, without replacement, from a given source array.
    static byte[]
    sample(byte[] source, double p)
    Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
    static byte[]
    sample(byte[] source, int k, byte[] target)
    Generates a random sample of k elements, without replacement, from a given source array.
    static char[]
    sample(char[] source, double p)
    Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
    static char[]
    sample(char[] source, int k, char[] target)
    Generates a random sample of k elements, without replacement, from a given source array.
    static double[]
    sample(double[] source, double p)
    Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
    static double[]
    sample(double[] source, int k, double[] target)
    Generates a random sample of k elements, without replacement, from a given source array.
    static float[]
    sample(float[] source, double p)
    Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
    static float[]
    sample(float[] source, int k, float[] target)
    Generates a random sample of k elements, without replacement, from a given source array.
    static int[]
    sample(int[] source, double p)
    Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
    static int[]
    sample(int[] source, int k, int[] target)
    Generates a random sample of k elements, without replacement, from a given source array.
    static long[]
    sample(long[] source, double p)
    Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
    static long[]
    sample(long[] source, int k, long[] target)
    Generates a random sample of k elements, without replacement, from a given source array.
    static short[]
    sample(short[] source, double p)
    Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
    static short[]
    sample(short[] source, int k, short[] target)
    Generates a random sample of k elements, without replacement, from a given source array.
    static char[]
    sample(String source, double p)
    Generates a random sample, without replacement, from a given String with a specified probability of a character's inclusion in the sample.
    static char[]
    sample(String source, int k, char[] target)
    Generates a random sample of k chars, without replacement, from a given source String.
    static <T> T[]
    sample(T[] source, double p)
    Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
    static <T> T[]
    sample(T[] source, int k, T[] target)
    Generates a random sample of k elements, without replacement, from a given source array.

  • Method Details

    • nextSample

      int[] nextSample(int[] source, int k, int[] target)
      Generates a random sample of k elements, without replacement, from a given source array. All n choose k combinations are equally likely, where n is the length of the source array.
      Parameters:
      source - The source array to sample.
      k - The number of random samples (must be no greater than source.length).
      target - An array to hold the result. If target is null or target.length is less than k, then this method will construct a new array for the result.
      Returns:
      An array containing the random sample.

    • nextSample

      short[] nextSample(short[] source, int k, short[] target)
      Generates a random sample of k elements, without replacement, from a given source array. All n choose k combinations are equally likely, where n is the length of the source array.
      Parameters:
      source - The source array to sample.
      k - The number of random samples (must be no greater than source.length).
      target - An array to hold the result. If target is null or target.length is less than k, then this method will construct a new array for the result.
      Returns:
      An array containing the random sample.

    • nextSample

      long[] nextSample(long[] source, int k, long[] target)
      Generates a random sample of k elements, without replacement, from a given source array. All n choose k combinations are equally likely, where n is the length of the source array.
      Parameters:
      source - The source array to sample.
      k - The number of random samples (must be no greater than source.length).
      target - An array to hold the result. If target is null or target.length is less than k, then this method will construct a new array for the result.
      Returns:
      An array containing the random sample.

    • nextSample

      byte[] nextSample(byte[] source, int k, byte[] target)
      Generates a random sample of k elements, without replacement, from a given source array. All n choose k combinations are equally likely, where n is the length of the source array.
      Parameters:
      source - The source array to sample.
      k - The number of random samples (must be no greater than source.length).
      target - An array to hold the result. If target is null or target.length is less than k, then this method will construct a new array for the result.
      Returns:
      An array containing the random sample.

    • nextSample

      char[] nextSample(char[] source, int k, char[] target)
      Generates a random sample of k elements, without replacement, from a given source array. All n choose k combinations are equally likely, where n is the length of the source array.
      Parameters:
      source - The source array to sample.
      k - The number of random samples (must be no greater than source.length).
      target - An array to hold the result. If target is null or target.length is less than k, then this method will construct a new array for the result.
      Returns:
      An array containing the random sample.

    • nextSample

      char[] nextSample(String source, int k, char[] target)
      Generates a random sample of k elements, without replacement, from a given source String. All n choose k combinations are equally likely, where n is the length of the source String.
      Parameters:
      source - The source String to sample.
      k - The number of random samples (must be no greater than source.length).
      target - An array to hold the result. If target is null or target.length is less than k, then this method will construct a new array for the result.
      Returns:
      An array containing the random sample.

    • nextSample

      double[] nextSample(double[] source, int k, double[] target)
      Generates a random sample of k elements, without replacement, from a given source array. All n choose k combinations are equally likely, where n is the length of the source array.
      Parameters:
      source - The source array to sample.
      k - The number of random samples (must be no greater than source.length).
      target - An array to hold the result. If target is null or target.length is less than k, then this method will construct a new array for the result.
      Returns:
      An array containing the random sample.

    • nextSample

      float[] nextSample(float[] source, int k, float[] target)
      Generates a random sample of k elements, without replacement, from a given source array. All n choose k combinations are equally likely, where n is the length of the source array.
      Parameters:
      source - The source array to sample.
      k - The number of random samples (must be no greater than source.length).
      target - An array to hold the result. If target is null or target.length is less than k, then this method will construct a new array for the result.
      Returns:
      An array containing the random sample.

    • nextSample

      <T> T[] nextSample(T[] source, int k, T[] target)
      Generates a random sample of k elements, without replacement, from a given source array. All n choose k combinations are equally likely, where n is the length of the source array.
      Type Parameters:
      T - The type of array elements.
      Parameters:
      source - The source array to sample.
      k - The number of random samples (must be no greater than source.length).
      target - An array to hold the result. If target is null or target.length is less than k, then this method will construct a new array for the result.
      Returns:
      An array containing the random sample.

    • nextSample

      default int[] nextSample(int[] source, double p)
      Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
      Parameters:
      source - The array from which to sample.
      p - The probability that element is included in the sample. The expected sample size is source.length * p.
      Returns:
      An array containing the sample, whose sample size is simply the length of the array.

    • nextSample

      default long[] nextSample(long[] source, double p)
      Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
      Parameters:
      source - The array from which to sample.
      p - The probability that element is included in the sample. The expected sample size is source.length * p.
      Returns:
      An array containing the sample, whose sample size is simply the length of the array.

    • nextSample

      default short[] nextSample(short[] source, double p)
      Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
      Parameters:
      source - The array from which to sample.
      p - The probability that element is included in the sample. The expected sample size is source.length * p.
      Returns:
      An array containing the sample, whose sample size is simply the length of the array.

    • nextSample

      default byte[] nextSample(byte[] source, double p)
      Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
      Parameters:
      source - The array from which to sample.
      p - The probability that element is included in the sample. The expected sample size is source.length * p.
      Returns:
      An array containing the sample, whose sample size is simply the length of the array.

    • nextSample

      default double[] nextSample(double[] source, double p)
      Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
      Parameters:
      source - The array from which to sample.
      p - The probability that element is included in the sample. The expected sample size is source.length * p.
      Returns:
      An array containing the sample, whose sample size is simply the length of the array.

    • nextSample

      default float[] nextSample(float[] source, double p)
      Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
      Parameters:
      source - The array from which to sample.
      p - The probability that element is included in the sample. The expected sample size is source.length * p.
      Returns:
      An array containing the sample, whose sample size is simply the length of the array.

    • nextSample

      default char[] nextSample(char[] source, double p)
      Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
      Parameters:
      source - The array from which to sample.
      p - The probability that element is included in the sample. The expected sample size is source.length * p.
      Returns:
      An array containing the sample, whose sample size is simply the length of the array.

    • nextSample

      default char[] nextSample(String source, double p)
      Generates a random sample, without replacement, from a given source String with a specified probability of an element's inclusion in the sample.
      Parameters:
      source - The String from which to sample.
      p - The probability that element is included in the sample. The expected sample size is source.length() * p.
      Returns:
      An array containing the sample, whose sample size is simply the length of the array.

    • nextSample

      default <T> T[] nextSample(T[] source, double p)
      Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.
      Type Parameters:
      T - The type of array elements.
      Parameters:
      source - The array from which to sample.
      p - The probability that element is included in the sample. The expected sample size is source.length * p.
      Returns:
      An array containing the sample, whose sample size is simply the length of the array.

    • sample

      static byte[] sample(byte[] source, double p)
      Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.

      This method chooses among the SequencePoolSampler, SequenceReservoirSampler, and SequenceInsertionSampler classes based on the values of n and p.

      This approach combining reservoir sampling, pool sampling, and insertion sampling was described in: Vincent A. Cicirello. 2022. Cycle Mutation: Evolving Permutations via Cycle Induction, Applied Sciences, 12(11), Article 5506 (June 2022). doi:10.3390/app12115506

      This method uses ThreadLocalRandom as the pseudorandom number generator, and is thus safe, and efficient (i.e., non-blocking), for use with threads.

      Parameters:
      source - The array from which to sample.
      p - The probability that element is included in the sample. The expected sample size is source.length * p.
      Returns:
      An array containing the sample, whose sample size is simply the length of the array.

    • sample

      static char[] sample(char[] source, double p)
      Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.

      This method chooses among the SequencePoolSampler, SequenceReservoirSampler, and SequenceInsertionSampler classes based on the values of n and p.

      This approach combining reservoir sampling, pool sampling, and insertion sampling was described in: Vincent A. Cicirello. 2022. Cycle Mutation: Evolving Permutations via Cycle Induction, Applied Sciences, 12(11), Article 5506 (June 2022). doi:10.3390/app12115506

      This method uses ThreadLocalRandom as the pseudorandom number generator, and is thus safe, and efficient (i.e., non-blocking), for use with threads.

      Parameters:
      source - The array from which to sample.
      p - The probability that element is included in the sample. The expected sample size is source.length * p.
      Returns:
      An array containing the sample, whose sample size is simply the length of the array.

    • sample

      static double[] sample(double[] source, double p)
      Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.

      This method chooses among the SequencePoolSampler, SequenceReservoirSampler, and SequenceInsertionSampler classes based on the values of n and p.

      This approach combining reservoir sampling, pool sampling, and insertion sampling was described in: Vincent A. Cicirello. 2022. Cycle Mutation: Evolving Permutations via Cycle Induction, Applied Sciences, 12(11), Article 5506 (June 2022). doi:10.3390/app12115506

      This method uses ThreadLocalRandom as the pseudorandom number generator, and is thus safe, and efficient (i.e., non-blocking), for use with threads.

      Parameters:
      source - The array from which to sample.
      p - The probability that element is included in the sample. The expected sample size is source.length * p.
      Returns:
      An array containing the sample, whose sample size is simply the length of the array.

    • sample

      static float[] sample(float[] source, double p)
      Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.

      This method chooses among the SequencePoolSampler, SequenceReservoirSampler, and SequenceInsertionSampler classes based on the values of n and p.

      This approach combining reservoir sampling, pool sampling, and insertion sampling was described in: Vincent A. Cicirello. 2022. Cycle Mutation: Evolving Permutations via Cycle Induction, Applied Sciences, 12(11), Article 5506 (June 2022). doi:10.3390/app12115506

      This method uses ThreadLocalRandom as the pseudorandom number generator, and is thus safe, and efficient (i.e., non-blocking), for use with threads.

      Parameters:
      source - The array from which to sample.
      p - The probability that element is included in the sample. The expected sample size is source.length * p.
      Returns:
      An array containing the sample, whose sample size is simply the length of the array.

    • sample

      static int[] sample(int[] source, double p)
      Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.

      This method chooses among the SequencePoolSampler, SequenceReservoirSampler, and SequenceInsertionSampler classes based on the values of n and p.

      This approach combining reservoir sampling, pool sampling, and insertion sampling was described in: Vincent A. Cicirello. 2022. Cycle Mutation: Evolving Permutations via Cycle Induction, Applied Sciences, 12(11), Article 5506 (June 2022). doi:10.3390/app12115506

      This method uses ThreadLocalRandom as the pseudorandom number generator, and is thus safe, and efficient (i.e., non-blocking), for use with threads.

      Parameters:
      source - The array from which to sample.
      p - The probability that element is included in the sample. The expected sample size is source.length * p.
      Returns:
      An array containing the sample, whose sample size is simply the length of the array.

    • sample

      static long[] sample(long[] source, double p)
      Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.

      This method chooses among the SequencePoolSampler, SequenceReservoirSampler, and SequenceInsertionSampler classes based on the values of n and p.

      This approach combining reservoir sampling, pool sampling, and insertion sampling was described in: Vincent A. Cicirello. 2022. Cycle Mutation: Evolving Permutations via Cycle Induction, Applied Sciences, 12(11), Article 5506 (June 2022). doi:10.3390/app12115506

      This method uses ThreadLocalRandom as the pseudorandom number generator, and is thus safe, and efficient (i.e., non-blocking), for use with threads.

      Parameters:
      source - The array from which to sample.
      p - The probability that element is included in the sample. The expected sample size is source.length * p.
      Returns:
      An array containing the sample, whose sample size is simply the length of the array.

    • sample

      static short[] sample(short[] source, double p)
      Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.

      This method chooses among the SequencePoolSampler, SequenceReservoirSampler, and SequenceInsertionSampler classes based on the values of n and p.

      This approach combining reservoir sampling, pool sampling, and insertion sampling was described in: Vincent A. Cicirello. 2022. Cycle Mutation: Evolving Permutations via Cycle Induction, Applied Sciences, 12(11), Article 5506 (June 2022). doi:10.3390/app12115506

      This method uses ThreadLocalRandom as the pseudorandom number generator, and is thus safe, and efficient (i.e., non-blocking), for use with threads.

      Parameters:
      source - The array from which to sample.
      p - The probability that element is included in the sample. The expected sample size is source.length * p.
      Returns:
      An array containing the sample, whose sample size is simply the length of the array.

    • sample

      static char[] sample(String source, double p)
      Generates a random sample, without replacement, from a given String with a specified probability of a character's inclusion in the sample.

      This method chooses among the SequencePoolSampler, SequenceReservoirSampler, and SequenceInsertionSampler classes based on the values of n and p.

      This approach combining reservoir sampling, pool sampling, and insertion sampling was described in: Vincent A. Cicirello. 2022. Cycle Mutation: Evolving Permutations via Cycle Induction, Applied Sciences, 12(11), Article 5506 (June 2022). doi:10.3390/app12115506

      This method uses ThreadLocalRandom as the pseudorandom number generator, and is thus safe, and efficient (i.e., non-blocking), for use with threads.

      Parameters:
      source - The String from which to sample.
      p - The probability that a character is included in the sample. The expected sample size is source.length() * p.
      Returns:
      An array containing the sample, whose sample size is simply the length of the array.

    • sample

      static <T> T[] sample(T[] source, double p)
      Generates a random sample, without replacement, from a given source array with a specified probability of an element's inclusion in the sample.

      This method chooses among the SequencePoolSampler, SequenceReservoirSampler, and SequenceInsertionSampler classes based on the values of n and p.

      This approach combining reservoir sampling, pool sampling, and insertion sampling was described in: Vincent A. Cicirello. 2022. Cycle Mutation: Evolving Permutations via Cycle Induction, Applied Sciences, 12(11), Article 5506 (June 2022). doi:10.3390/app12115506

      This method uses ThreadLocalRandom as the pseudorandom number generator, and is thus safe, and efficient (i.e., non-blocking), for use with threads.

      Type Parameters:
      T - The type of array elements.
      Parameters:
      source - The array from which to sample.
      p - The probability that element is included in the sample. The expected sample size is source.length * p.
      Returns:
      An array containing the sample, whose sample size is simply the length of the array.

    • sample

      static int[] sample(int[] source, int k, int[] target)
      Generates a random sample of k elements, without replacement, from a given source array. All n choose k combinations are equally likely, where n is the length of the source array.

      This method chooses among the SequencePoolSampler, SequenceReservoirSampler, and SequenceInsertionSampler classes based on the values of n and k.

      This approach combining reservoir sampling, pool sampling, and insertion sampling was described in: Vincent A. Cicirello. 2022. Cycle Mutation: Evolving Permutations via Cycle Induction, Applied Sciences, 12(11), Article 5506 (June 2022). doi:10.3390/app12115506

      The runtime is O(min(n, k2)) and it generates O(min(k, n-k)) random numbers.

      This method uses ThreadLocalRandom as the pseudorandom number generator, and is thus safe, and efficient (i.e., non-blocking), for use with threads.

      Parameters:
      source - The source array to sample.
      k - The number of random samples (must be no greater than source.length).
      target - An array to hold the result. If target is null or target.length is less than k, then this method will construct a new array for the result.
      Returns:
      An array containing the random sample.
      Throws:
      IllegalArgumentException - if k > source.length
      NegativeArraySizeException - if k < 0

    • sample

      static long[] sample(long[] source, int k, long[] target)
      Generates a random sample of k elements, without replacement, from a given source array. All n choose k combinations are equally likely, where n is the length of the source array.

      This method chooses among the SequencePoolSampler, SequenceReservoirSampler, and SequenceInsertionSampler classes based on the values of n and k.

      This approach combining reservoir sampling, pool sampling, and insertion sampling was described in: Vincent A. Cicirello. 2022. Cycle Mutation: Evolving Permutations via Cycle Induction, Applied Sciences, 12(11), Article 5506 (June 2022). doi:10.3390/app12115506

      The runtime is O(min(n, k2)) and it generates O(min(k, n-k)) random numbers.

      This method uses ThreadLocalRandom as the pseudorandom number generator, and is thus safe, and efficient (i.e., non-blocking), for use with threads.

      Parameters:
      source - The source array to sample.
      k - The number of random samples (must be no greater than source.length).
      target - An array to hold the result. If target is null or target.length is less than k, then this method will construct a new array for the result.
      Returns:
      An array containing the random sample.
      Throws:
      IllegalArgumentException - if k > source.length
      NegativeArraySizeException - if k < 0

    • sample

      static short[] sample(short[] source, int k, short[] target)
      Generates a random sample of k elements, without replacement, from a given source array. All n choose k combinations are equally likely, where n is the length of the source array.

      This method chooses among the SequencePoolSampler, SequenceReservoirSampler, and SequenceInsertionSampler classes based on the values of n and k.

      This approach combining reservoir sampling, pool sampling, and insertion sampling was described in: Vincent A. Cicirello. 2022. Cycle Mutation: Evolving Permutations via Cycle Induction, Applied Sciences, 12(11), Article 5506 (June 2022). doi:10.3390/app12115506

      The runtime is O(min(n, k2)) and it generates O(min(k, n-k)) random numbers.

      This method uses ThreadLocalRandom as the pseudorandom number generator, and is thus safe, and efficient (i.e., non-blocking), for use with threads.

      Parameters:
      source - The source array to sample.
      k - The number of random samples (must be no greater than source.length).
      target - An array to hold the result. If target is null or target.length is less than k, then this method will construct a new array for the result.
      Returns:
      An array containing the random sample.
      Throws:
      IllegalArgumentException - if k > source.length
      NegativeArraySizeException - if k < 0

    • sample

      static byte[] sample(byte[] source, int k, byte[] target)
      Generates a random sample of k elements, without replacement, from a given source array. All n choose k combinations are equally likely, where n is the length of the source array.

      This method chooses among the SequencePoolSampler, SequenceReservoirSampler, and SequenceInsertionSampler classes based on the values of n and k.

      This approach combining reservoir sampling, pool sampling, and insertion sampling was described in: Vincent A. Cicirello. 2022. Cycle Mutation: Evolving Permutations via Cycle Induction, Applied Sciences, 12(11), Article 5506 (June 2022). doi:10.3390/app12115506

      The runtime is O(min(n, k2)) and it generates O(min(k, n-k)) random numbers.

      This method uses ThreadLocalRandom as the pseudorandom number generator, and is thus safe, and efficient (i.e., non-blocking), for use with threads.

      Parameters:
      source - The source array to sample.
      k - The number of random samples (must be no greater than source.length).
      target - An array to hold the result. If target is null or target.length is less than k, then this method will construct a new array for the result.
      Returns:
      An array containing the random sample.
      Throws:
      IllegalArgumentException - if k > source.length
      NegativeArraySizeException - if k < 0

    • sample

      static char[] sample(char[] source, int k, char[] target)
      Generates a random sample of k elements, without replacement, from a given source array. All n choose k combinations are equally likely, where n is the length of the source array.

      This method chooses among the SequencePoolSampler, SequenceReservoirSampler, and SequenceInsertionSampler classes based on the values of n and k.

      This approach combining reservoir sampling, pool sampling, and insertion sampling was described in: Vincent A. Cicirello. 2022. Cycle Mutation: Evolving Permutations via Cycle Induction, Applied Sciences, 12(11), Article 5506 (June 2022). doi:10.3390/app12115506

      The runtime is O(min(n, k2)) and it generates O(min(k, n-k)) random numbers.

      This method uses ThreadLocalRandom as the pseudorandom number generator, and is thus safe, and efficient (i.e., non-blocking), for use with threads.

      Parameters:
      source - The source array to sample.
      k - The number of random samples (must be no greater than source.length).
      target - An array to hold the result. If target is null or target.length is less than k, then this method will construct a new array for the result.
      Returns:
      An array containing the random sample.
      Throws:
      IllegalArgumentException - if k > source.length
      NegativeArraySizeException - if k < 0

    • sample

      static char[] sample(String source, int k, char[] target)
      Generates a random sample of k chars, without replacement, from a given source String. All n choose k combinations are equally likely, where n is the length of the source String.

      This method chooses among the SequencePoolSampler, SequenceReservoirSampler, and SequenceInsertionSampler classes based on the values of n and k.

      This approach combining reservoir sampling, pool sampling, and insertion sampling was described in: Vincent A. Cicirello. 2022. Cycle Mutation: Evolving Permutations via Cycle Induction, Applied Sciences, 12(11), Article 5506 (June 2022). doi:10.3390/app12115506

      The runtime is O(min(n, k2)) and it generates O(min(k, n-k)) random numbers.

      This method uses ThreadLocalRandom as the pseudorandom number generator, and is thus safe, and efficient (i.e., non-blocking), for use with threads.

      Parameters:
      source - The source array to sample.
      k - The number of random samples (must be no greater than source.length()).
      target - An array to hold the result. If target is null or target.length is less than k, then this method will construct a new array for the result.
      Returns:
      An array containing the random sample.
      Throws:
      IllegalArgumentException - if k > source.length()
      NegativeArraySizeException - if k < 0

    • sample

      static double[] sample(double[] source, int k, double[] target)
      Generates a random sample of k elements, without replacement, from a given source array. All n choose k combinations are equally likely, where n is the length of the source array.

      This method chooses among the SequencePoolSampler, SequenceReservoirSampler, and SequenceInsertionSampler classes based on the values of n and k.

      This approach combining reservoir sampling, pool sampling, and insertion sampling was described in: Vincent A. Cicirello. 2022. Cycle Mutation: Evolving Permutations via Cycle Induction, Applied Sciences, 12(11), Article 5506 (June 2022). doi:10.3390/app12115506

      The runtime is O(min(n, k2)) and it generates O(min(k, n-k)) random numbers.

      This method uses ThreadLocalRandom as the pseudorandom number generator, and is thus safe, and efficient (i.e., non-blocking), for use with threads.

      Parameters:
      source - The source array to sample.
      k - The number of random samples (must be no greater than source.length).
      target - An array to hold the result. If target is null or target.length is less than k, then this method will construct a new array for the result.
      Returns:
      An array containing the random sample.
      Throws:
      IllegalArgumentException - if k > source.length
      NegativeArraySizeException - if k < 0

    • sample

      static float[] sample(float[] source, int k, float[] target)
      Generates a random sample of k elements, without replacement, from a given source array. All n choose k combinations are equally likely, where n is the length of the source array.

      This method chooses among the SequencePoolSampler, SequenceReservoirSampler, and SequenceInsertionSampler classes based on the values of n and k.

      This approach combining reservoir sampling, pool sampling, and insertion sampling was described in: Vincent A. Cicirello. 2022. Cycle Mutation: Evolving Permutations via Cycle Induction, Applied Sciences, 12(11), Article 5506 (June 2022). doi:10.3390/app12115506

      The runtime is O(min(n, k2)) and it generates O(min(k, n-k)) random numbers.

      This method uses ThreadLocalRandom as the pseudorandom number generator, and is thus safe, and efficient (i.e., non-blocking), for use with threads.

      Parameters:
      source - The source array to sample.
      k - The number of random samples (must be no greater than source.length).
      target - An array to hold the result. If target is null or target.length is less than k, then this method will construct a new array for the result.
      Returns:
      An array containing the random sample.
      Throws:
      IllegalArgumentException - if k > source.length
      NegativeArraySizeException - if k < 0

    • sample

      static <T> T[] sample(T[] source, int k, T[] target)
      Generates a random sample of k elements, without replacement, from a given source array. All n choose k combinations are equally likely, where n is the length of the source array.

      This method chooses among the SequencePoolSampler, SequenceReservoirSampler, and SequenceInsertionSampler classes based on the values of n and k.

      This approach combining reservoir sampling, pool sampling, and insertion sampling was described in: Vincent A. Cicirello. 2022. Cycle Mutation: Evolving Permutations via Cycle Induction, Applied Sciences, 12(11), Article 5506 (June 2022). doi:10.3390/app12115506

      The runtime is O(min(n, k2)) and it generates O(min(k, n-k)) random numbers.

      This method uses ThreadLocalRandom as the pseudorandom number generator, and is thus safe, and efficient (i.e., non-blocking), for use with threads.

      Type Parameters:
      T - The type of array elements.
      Parameters:
      source - The source array to sample.
      k - The number of random samples (must be no greater than source.length).
      target - An array to hold the result. If target is null or target.length is less than k, then this method will construct a new array for the result.
      Returns:
      An array containing the random sample.
      Throws:
      IllegalArgumentException - if k > source.length
      NegativeArraySizeException - if k < 0