commons-issues mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Rostislav Krasny (JIRA)" <j...@apache.org>
Subject [jira] [Updated] (MATH-1306) Add public void nextBytes(byte[] bytes, int position, int length) method into the RandomGenerator interface
Date Wed, 23 Dec 2015 20:58:46 GMT

     [ 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)

Mime
View raw message