Rostislav Krasny created MATH-1306:
--------------------------------------

             Summary: 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 < bytes.length) {
                                        random >>>= 8;
                                } else {
                                        break;
                                }
                        }
                }
        }
{code}



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)

Reply via email to