[
https://issues.apache.org/jira/browse/MATH-1306?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Rostislav Krasny updated MATH-1306:
-----------------------------------
Description:
I propose to add {{public void nextBytes(byte[] bytes, int position, int
length)}} method into the {{RandomGenerator}} interface.
Rationality: to improve performance and memory usage in cases when one needs to
fill only a specified region of a byte array. Today to do that you need to use
a temporary byte array and copy it by yourself into the specified region of the
destination byte array.
I propose the following code, based on the code of {{BitsStreamGenerator}}
commited in MATH-1305
{code:java}
@Override
public void nextBytes(byte[] bytes) {
nextBytesFill(bytes, 0, bytes.length);
}
// TODO add this method into RandomGenerator interface
//@Override
public void nextBytes(byte[] bytes, int position, int length) {
if (position < 0 || position > bytes.length - 1) {
throw new
OutOfRangeException(LocalizedFormats.OUT_OF_RANGE_SIMPLE, position, 0,
bytes.length - 1);
}
if (length < 0 || length > bytes.length - position) {
throw new
OutOfRangeException(LocalizedFormats.OUT_OF_RANGE_SIMPLE, length, 0,
bytes.length - position);
}
nextBytesFill(bytes, position, length);
}
private void nextBytesFill(byte[] bytes, int position, int length) {
int index = position;
// Position plus multiple 4 part of length (i.e. length with
two least significant bits unset).
final int indexLoopLimit = position + (length & 0x7ffffffc);
// Start filling in the byte array, 4 bytes at a time.
while (index < indexLoopLimit) {
final int random = next(32);
bytes[index++] = (byte) random;
bytes[index++] = (byte) (random >>> 8);
bytes[index++] = (byte) (random >>> 16);
bytes[index++] = (byte) (random >>> 24);
}
final int indexLimit = position + length;
// Fill in the remaining bytes.
if (index < indexLimit) {
int random = next(32);
while (true) {
bytes[index++] = (byte) random;
if (index < indexLimit) {
random >>>= 8;
} else {
break;
}
}
}
}
{code}
was:
I propose to add {{public void nextBytes(byte[] bytes, int position, int
length)}} method into the {{RandomGenerator}} interface.
Rationality: to improve performance and memory usage in cases when one needs to
fill only a specified region of a byte array. Today to do that you need to use
a temporary byte array and copy it by yourself into the specified region of the
destination byte array.
I propose the following code, based on the code of {{BitsStreamGenerator}}
commited in MATH-1305
{code:java}
@Override
public void nextBytes(byte[] bytes) {
nextBytesFill(bytes, 0, bytes.length);
}
// TODO add this method into RandomGenerator interface
//@Override
public void nextBytes(byte[] bytes, int position, int length) {
if (position < 0 || position > bytes.length - 1) {
throw new
OutOfRangeException(LocalizedFormats.OUT_OF_RANGE_SIMPLE, position, 0,
bytes.length - 1);
}
if (length < 0 || length > bytes.length - position) {
throw new
OutOfRangeException(LocalizedFormats.OUT_OF_RANGE_SIMPLE, length, 0,
bytes.length - position);
}
nextBytesFill(bytes, position, length);
}
private void nextBytesFill(byte[] bytes, int position, int length) {
int index = position;
// Position plus multiple 4 part of length (i.e. length with
two least significant bits unset).
final int indexLoopLimit = position + (length & 0x7ffffffc);
// Start filling in the byte array, 4 bytes at a time.
while (index < indexLoopLimit) {
final int random = next(32);
bytes[index++] = (byte) random;
bytes[index++] = (byte) (random >>> 8);
bytes[index++] = (byte) (random >>> 16);
bytes[index++] = (byte) (random >>> 24);
}
final int indexLimit = position + length;
// Fill in the remaining bytes.
if (index < indexLimit) {
int random = next(32);
while (true) {
bytes[index++] = (byte) random;
if (index < bytes.length) {
random >>>= 8;
} else {
break;
}
}
}
}
{code}
> Add public void nextBytes(byte[] bytes, int position, int length) method into
> the RandomGenerator interface
> -----------------------------------------------------------------------------------------------------------
>
> Key: MATH-1306
> URL: https://issues.apache.org/jira/browse/MATH-1306
> Project: Commons Math
> Issue Type: Improvement
> Affects Versions: 3.5
> Reporter: Rostislav Krasny
>
> I propose to add {{public void nextBytes(byte[] bytes, int position, int
> length)}} method into the {{RandomGenerator}} interface.
> Rationality: to improve performance and memory usage in cases when one needs
> to fill only a specified region of a byte array. Today to do that you need to
> use a temporary byte array and copy it by yourself into the specified region
> of the destination byte array.
> I propose the following code, based on the code of {{BitsStreamGenerator}}
> commited in MATH-1305
> {code:java}
> @Override
> public void nextBytes(byte[] bytes) {
> nextBytesFill(bytes, 0, bytes.length);
> }
> // TODO add this method into RandomGenerator interface
> //@Override
> public void nextBytes(byte[] bytes, int position, int length) {
> if (position < 0 || position > bytes.length - 1) {
> throw new
> OutOfRangeException(LocalizedFormats.OUT_OF_RANGE_SIMPLE, position, 0,
> bytes.length - 1);
> }
> if (length < 0 || length > bytes.length - position) {
> throw new
> OutOfRangeException(LocalizedFormats.OUT_OF_RANGE_SIMPLE, length, 0,
> bytes.length - position);
> }
> nextBytesFill(bytes, position, length);
> }
> private void nextBytesFill(byte[] bytes, int position, int length) {
> int index = position;
> // Position plus multiple 4 part of length (i.e. length with
> two least significant bits unset).
> final int indexLoopLimit = position + (length & 0x7ffffffc);
> // Start filling in the byte array, 4 bytes at a time.
> while (index < indexLoopLimit) {
> final int random = next(32);
> bytes[index++] = (byte) random;
> bytes[index++] = (byte) (random >>> 8);
> bytes[index++] = (byte) (random >>> 16);
> bytes[index++] = (byte) (random >>> 24);
> }
> final int indexLimit = position + length;
>
> // Fill in the remaining bytes.
> if (index < indexLimit) {
> int random = next(32);
> while (true) {
> bytes[index++] = (byte) random;
> if (index < indexLimit) {
> random >>>= 8;
> } else {
> break;
> }
> }
> }
> }
> {code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
