[
https://issues.apache.org/jira/browse/RNG-54?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=16627374#comment-16627374
]
Alex D Herbert commented on RNG-54:
-----------------------------------
{quote}I like the idea of a StringSampler interface
{quote}
{code:java}
public interface StringSampler {
String nextString(UniformRandomProvider rng, int length);
}
{code}
This passes {{rng}} into the sample method in contrast to all the other
samplers in {{rng-sampling}}.
I played with the idea of:
{code:java}
public interface StringSampler {
String nextString(int length);
}
{code}
But it does require that a {{char[]}} of the correct length is allocated each
time inside the implementing sampler.
Since {{String}} copies the array in its constructor:
{code:java}
char[] chars = ...;
new String(chars);
{code}
You have the situation where you create a new {{char[]}} for each call to the
interface method which is then copied by String and then discarded. Effectively
a double allocation of {{char[]}}. The constructor for {{String}} which does
not copy the array is package private to {{java.lang}}. It is used by
{{Integer.toString(), Long.toString() and StringBuffer}} among others, but not
{{StringBuilder}}.
This allows the caller to control the size and removes allocation overhead from
the implementation:
{code:java}
public interface StringSampler {
void nextChars(char[] chars);
}
{code}
It is also a match to the current {{nextBytes(byte[])}} method. So ...
{code:java}
UniformRandomProvider rng = ...;
StringSampler sampler = ...; // construct using rng
int length = 100;
char[] chars = new char[length];
for (int i=0; i<10; i++) {
sample.nextChars(chars);
String string = new String(chars); // Single char array copy
// verses this with 2 char array copies
String string = sample.nextString(length);
}
{code}
The first method will be faster. However the second method is cleaner.
Also note that raw {{char[]}} are appended using a simple {{arraycopy}} to a
{{StringBuilder}} in constrast to {{String}} which does some checks to support
null and delegates the {{arraycopy}} to {{String}} which does index checks.
So raw {{char[]}} is more flexible as an API.
I do not see why you could not have both:
{code:java}
public interface StringSampler {
void nextChars(char[] chars);
String nextString(int length);
}
{code}
The default implementation is easy enough:
{code:java}
public String nextString(int length) {
final char[] chars = new char[length];
nextChars(chars);
return new String(chars);
}
{code}
> StringSampler
> -------------
>
> Key: RNG-54
> URL: https://issues.apache.org/jira/browse/RNG-54
> Project: Commons RNG
> Issue Type: Improvement
> Components: sampling
> Affects Versions: 1.1
> Reporter: Alex D Herbert
> Priority: Minor
>
> There is currently no equivalent for the function
> {{org.apache.commons.math3.random.RandomDataGenerator.nextHexString(int)}}.
> Here is the original version adapted to use the {{UniformRandomProvider:}}
> {code:java}
> public String nextHexStringOriginal(UniformRandomProvider ran, int len) {
> // Initialize output buffer
> StringBuilder outBuffer = new StringBuilder();
> // Get int(len/2)+1 random bytes
> byte[] randomBytes = new byte[(len / 2) + 1];
> ran.nextBytes(randomBytes);
> // Convert each byte to 2 hex digits
> for (int i = 0; i < randomBytes.length; i++) {
> Integer c = Integer.valueOf(randomBytes[i]);
> /*
> * Add 128 to byte value to make interval 0-255 before doing hex
> conversion.
> * This guarantees <= 2 hex digits from toHexString() toHexString
> would
> * otherwise add 2^32 to negative arguments.
> */
> String hex = Integer.toHexString(c.intValue() + 128);
> // Make sure we add 2 hex digits for each byte
> if (hex.length() == 1) {
> hex = "0" + hex;
> }
> outBuffer.append(hex);
> }
> return outBuffer.toString().substring(0, len);
> }
> {code}
> Note: I removed the length check to make the speed test (see below) fair.
> This makes use of {{StringBuider}} and is not very efficient. I have created
> a version based on the Hex encoding within
> {{org.apache.commons.codec.digest.DigestUtils}} and
> {{org.apache.commons.codec.binary.Hex}}. This uses a direct look-up of the
> hex character using the index from successive 4 bits of a byte array to form
> an index from 0-15.
> Here's the function without details of how the {{byte[]}} is correctly sized:
> {code:java}
> private static final char[] DIGITS_LOWER = {
> '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd',
> 'e', 'f' };
> private static String nextHexString(UniformRandomProvider rng, byte[] bytes,
> int length) {
> rng.nextBytes(bytes);
> // Use the upper and lower 4 bits of each byte as an
> // index in the range 0-15 for each hex character.
> final char[] out = new char[length];
> // Run the loop without checking index j by producing characters
> // up to the size below the desired length.
> final int loopLimit = length / 2;
> int i = 0, j = 0;
> while (i < loopLimit) {
> final byte b = bytes[i];
> // 0x0F == 0x01 | 0x02 | 0x04 | 0x08
> out[j++] = DIGITS_LOWER[(b >>> 4) & 0x0F];
> out[j++] = DIGITS_LOWER[b & 0x0F];
> i++;
> }
> // The final character
> if (j < length)
> out[j++] = DIGITS_LOWER[(bytes[i] >>> 4) & 0x0F];
> return new String(out);
> }
> {code}
> I've compared this to the original function and a modified one below that
> computes the exact same strings:
> {code:java}
> public String nextHexStringModified(UniformRandomProvider ran, int len) {
> // Initialize output buffer
> StringBuilder outBuffer = new StringBuilder();
> // byte[] randomBytes = new byte[(len/2) + 1]; // ORIGINAL
> byte[] randomBytes = new byte[(len + 1) / 2];
> ran.nextBytes(randomBytes);
> // Convert each byte to 2 hex digits
> for (int i = 0; i < randomBytes.length; i++) {
> // ORIGINAL
> // Integer c = Integer.valueOf(randomBytes[i]);
> // String hex = Integer.toHexString(c.intValue() + 128);
> String hex = Integer.toHexString(randomBytes[i] & 0xff);
> // Make sure we add 2 hex digits for each byte
> if (hex.length() == 1) {
> outBuffer.append('0');
> }
> outBuffer.append(hex);
> }
> return outBuffer.toString().substring(0, len);
> }
> {code}
> The timings are:
>
> ||Name||Time||Relative||
> |StringSampler|316103|0.073|
> |nextHexStringModified|3708104|0.853|
> |nextHexStringOriginal|4348063|1.000|
> This is not using JMH but the results show the method performs better.
> The full {{StringSampler}} class supports a radix of 2, 8, and 16 for binary,
> octal and hex strings.
> JUnit tests show: the sampler computes the same values as
> {{nextHexStringModified(int);}} edges cases are handled with exceptions; and
> the output strings are uniform for each of the supported character sets
> (using a Chi Squared test).
> Can I create a PR for a {{org.apache.commons.rng.sampling.StringSampler}}?
>
--
This message was sent by Atlassian JIRA
(v7.6.3#76005)