Array Copy Utilities : Array Insert Remove « Collections Data Structure « Java






Array Copy Utilities

      
// Revised from marf

import java.util.Comparator;
import java.util.Vector;


/**
 * <p><code>marf.util.Arrays</code> is an extension of <code>java.util.Arrays</code>
 * to group a lot of commonly used arrays-related functionality in one place. This class
 * can do whatever <code>java.util.Arrays</code> can, plus allows copying array portions,
 * including cases when the source and destination arrays are of different types, and providing
 * array-to-Vector and array-to-delimited-String conversions. For the type-conversion
 * routines a proper casting to the destination type is performed when needed. It also
 * allows inheritance from the class, so that anyone wishing to extend it is welcome to
 * do so without the pain of re-wrapping the methods.</p>
 *
 * TODO: optimize.
 *
 * <p>NOTE: the <code>java.util.Arrays</code> compliance is true as of JDK 1.4.</p>
 *
 * <p>NOTE: it does not actually inherit (extend) from <code>java.util.Arrays</code>, but rather wraps
 * existing methods, plus adds the <code>copy()</code> wrappers of <code>System.arraycopy()</code>,
 * and <code>arrayToVector()</code> methods.</p>
 *
 * <p>$Id: Arrays.java,v 1.38 2006/09/09 17:26:58 mokhov Exp $</p>
 *
 * @author Serguei Mokhov
 * @author Shuxin Fan
 *
 * @version $Revision: 1.38 $
 * @since 0.3.0.1
 *
 * @see java.util.Arrays
 * @see System#arraycopy(Object, int, Object, int, int)
 */
public class Arrays
{
  /**
   * The protected default constructor is provided
   * to allow making extension of this class if
   * developers desire to do so. Normally, you would
   * not need to instantiate this class, but in order
   * not to re-wrap our calls in possible extensions
   * this constructor is available.
   */
  protected Arrays()
  {
  }

  /*
   * -------
   * Copying
   * -------
   */

  /**
   * Generic <code>copy()</code> routine is based on <code>System.arraycopy()</code>.
   *
   * @param poDestination destination array of copy
   * @param piDestinationStartIndex where in the destination array start placing the values
   * @param poSource source of elements
   * @param piSourceStartIndex where in the source array start copying the values from
   * @param piHowMany how many elements should be copied from the source to destination
   */
  public static void copy
  (
    Object poDestination,
    final int piDestinationStartIndex,
    Object poSource,
    final int piSourceStartIndex,
    final int piHowMany
  )
  {
    System.arraycopy
    (
      poSource,
      piSourceStartIndex,
      poDestination,
      piDestinationStartIndex,
      piHowMany
    );
  }

  /**
   * Generic <code>copy()</code> routine is based on <code>System.arraycopy()</code>
   * for Object arrays.
   *
   * @param paoDestination destination array of objects to copy to
   * @param piDestinationStartIndex where in the destination array start placing the values
   * @param paoSource source of Object elements
   * @param piSourceStartIndex where in the source array start copying the values from
   * @param piHowMany how many elements should be copied from the source to destination
   */
  public static void copy
  (
    Object[] paoDestination,
    final int piDestinationStartIndex,
    Object[] paoSource,
    final int piSourceStartIndex,
    final int piHowMany
  )
  {
    System.arraycopy
    (
      paoSource,
      piSourceStartIndex,
      paoDestination,
      piDestinationStartIndex,
      piHowMany
    );
  }

  /**
   * Copies N boolean elements from source to destination starting at certain index in the <b>destination</b>.
   * A wrapper call to <code>System.arraycopy()</code>.
   *
   * @param pabDestination array to copy to
   * @param piDestinationStartIndex starting index in the destination to start copying to
   * @param pabSource array of booleans to copy from
   * @param piSourceStartIndex starting index in the source to start copying from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy
  (
    boolean[] pabDestination,
    final int piDestinationStartIndex,
    boolean[] pabSource,
    final int piSourceStartIndex,
    final int piHowMany
  )
  {
    System.arraycopy
    (
      pabSource,
      piSourceStartIndex,
      pabDestination,
      piDestinationStartIndex,
      piHowMany
    );
  }

  /**
   * Copies N byte elements from source to destination starting at certain index in the <b>destination</b>.
   * A wrapper call to <code>System.arraycopy()</code>.
   *
   * @param patDestination array to copy to
   * @param piDestinationStartIndex starting index in the destination to start copying to
   * @param patSource array of bytes to copy from
   * @param piSourceStartIndex starting index in the source to start copying from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy
  (
    byte[] patDestination,
    final int piDestinationStartIndex,
    byte[] patSource,
    final int piSourceStartIndex,
    final int piHowMany
  )
  {
    System.arraycopy
    (
      patSource,
      piSourceStartIndex,
      patDestination,
      piDestinationStartIndex,
      piHowMany
    );
  }

  /**
   * Copies N character elements from source to destination starting at certain index in the <b>destination</b>.
   * A wrapper call to <code>System.arraycopy()</code>.
   *
   * @param pacDestination array to copy to
   * @param piDestinationStartIndex starting index in the destination to start copying to
   * @param pacSource array of characters to copy from
   * @param piSourceStartIndex starting index in the source to start copying from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy
  (
    char[] pacDestination,
    final int piDestinationStartIndex,
    char[] pacSource,
    final int piSourceStartIndex,
    final int piHowMany
  )
  {
    System.arraycopy
    (
      pacSource,
      piSourceStartIndex,
      pacDestination,
      piDestinationStartIndex,
      piHowMany
    );
  }

  /**
   * Copies N integer elements from source to destination starting at certain index in the <b>destination</b>.
   * A wrapper call to <code>System.arraycopy()</code>.
   *
   * @param paiDestination array to copy to
   * @param piDestinationStartIndex starting index in the destination to start copying to
   * @param paiSource array of integers to copy from
   * @param piSourceStartIndex starting index in the source to start copying from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy
  (
    int[] paiDestination,
    final int piDestinationStartIndex,
    int[] paiSource,
    final int piSourceStartIndex,
    final int piHowMany
  )
  {
    System.arraycopy
    (
      paiSource,
      piSourceStartIndex,
      paiDestination,
      piDestinationStartIndex,
      piHowMany
    );
  }

  /**
   * Copies N short elements from source to destination starting at certain index in the <b>destination</b>.
   * A wrapper call to <code>System.arraycopy()</code>.
   *
   * @param pasDestination array to copy to
   * @param piDestinationStartIndex starting index in the destination to start copying to
   * @param pasSource array of shorts to copy from
   * @param piSourceStartIndex starting index in the source to start copying from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy
  (
    short[] pasDestination,
    final int piDestinationStartIndex,
    short[] pasSource,
    final int piSourceStartIndex,
    final int piHowMany
  )
  {
    System.arraycopy
    (
      pasSource,
      piSourceStartIndex,
      pasDestination,
      piDestinationStartIndex,
      piHowMany
    );
  }

  /**
   * Copies N long elements from source to destination starting at certain index in the <b>destination</b>.
   * A wrapper call to <code>System.arraycopy()</code>.
   *
   * @param palDestination array to copy to
   * @param piDestinationStartIndex starting index in the destination to start copying to
   * @param palSource array of longs to copy from
   * @param piSourceStartIndex starting index in the source to start copying from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy
  (
    long[] palDestination,
    final int piDestinationStartIndex,
    long[] palSource,
    final int piSourceStartIndex,
    final int piHowMany
  )
  {
    System.arraycopy
    (
      palSource,
      piSourceStartIndex,
      palDestination,
      piDestinationStartIndex,
      piHowMany
    );
  }

  /**
   * Copies N float elements from source to destination starting at certain index in the <b>destination</b>.
   * A wrapper call to <code>System.arraycopy()</code>.
   *
   * @param pafDestination array to copy to
   * @param piDestinationStartIndex starting index in the destination to start copying to
   * @param pafSource array of float to copy from
   * @param piSourceStartIndex starting index in the source to start copying from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy
  (
    float[] pafDestination,
    final int piDestinationStartIndex,
    float[] pafSource,
    final int piSourceStartIndex,
    final int piHowMany
  )
  {
    System.arraycopy
    (
      pafSource,
      piSourceStartIndex,
      pafDestination,
      piDestinationStartIndex,
      piHowMany
    );
  }

  /**
   * Copies N double elements from source to destination starting at certain index in the <b>destination</b>.
   * A wrapper call to <code>System.arraycopy()</code>.
   *
   * @param padDestination array to copy to
   * @param piDestinationStartIndex starting index in the destination to start copying to
   * @param padSource array of doubles to copy from
   * @param piSourceStartIndex starting index in the source to start copying from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   *
   * @throws ArrayIndexOutOfBoundsException if one of the indices is out of range
   */
  public static void copy
  (
    double[] padDestination,
    final int piDestinationStartIndex,
    double[] padSource,
    final int piSourceStartIndex,
    final int piHowMany
  )
  {
    System.arraycopy
    (
      padSource,
      piSourceStartIndex,
      padDestination,
      piDestinationStartIndex,
      piHowMany
    );
  }

  /**
   * Generic <code>copy()</code> routine is based on <code>System.arraycopy()</code>.
   *
   * @param poDestination destination array of copy
   * @param piStartIndex where in the destination array start placing the values
   * @param poSource source of elements
   * @param piHowMany how many elements should be copied from the source to destination
   */
  public static void copy(Object poDestination, final int piStartIndex, Object poSource, final int piHowMany)
  {
    copy(poDestination, piStartIndex, poSource, 0, piHowMany);
  }

  /**
   * Generic <code>copy()</code> routine is based on <code>System.arraycopy()</code>
   * for Object arrays.
   *
   * @param paoDestination destination array of objects to copy to
   * @param piStartIndex where in the destination array start placing the values
   * @param paoSource source of Object elements
   * @param piHowMany how many elements should be copied from the source to destination
   */
  public static void copy(Object[] paoDestination, final int piStartIndex, Object[] paoSource, final int piHowMany)
  {
    copy(paoDestination, piStartIndex, paoSource, 0, piHowMany);
  }

  /**
   * Copies N character elements from source to destination starting at certain index in the <b>destination</b>.
   *
   * @param pacDestination array to copy to
   * @param piStartIndex starting index in the destination to start copying to
   * @param pacSource array of characters to copy from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy(char[] pacDestination, final int piStartIndex, char[] pacSource, final int piHowMany)
  {
    copy(pacDestination, piStartIndex, pacSource, 0, piHowMany);
  }

  /**
   * Copies N boolean elements from source to destination starting at certain index in the <b>destination</b>.
   *
   * @param pabDestination array to copy to
   * @param piStartIndex starting index in the destination to start copying to
   * @param pabSource array of booleans to copy from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy(boolean[] pabDestination, final int piStartIndex, boolean[] pabSource, final int piHowMany)
  {
    copy(pabDestination, piStartIndex, pabSource, 0, piHowMany);
  }

  /**
   * Copies N byte elements from source to destination starting at certain index in the <b>destination</b>.
   *
   * @param patDestination array to copy to
   * @param piStartIndex starting index in the destination to start copying to
   * @param patSource array of bytes to copy from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy(byte[] patDestination, final int piStartIndex, byte[] patSource, final int piHowMany)
  {
    copy(patDestination, piStartIndex, patSource, 0, piHowMany);
  }

  /**
   * Copies N integer elements from source to destination starting at certain index in the <b>destination</b>.
   *
   * @param paiDestination array to copy to
   * @param piStartIndex starting index in the destination to start copying to
   * @param paiSource array of integers to copy from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy(int[] paiDestination, final int piStartIndex, int[] paiSource, final int piHowMany)
  {
    copy(paiDestination, piStartIndex, paiSource, 0, piHowMany);
  }

  /**
   * Copies N short elements from source to destination starting at certain index in the <b>destination</b>.
   *
   * @param pasDestination array to copy to
   * @param piStartIndex starting index in the destination to start copying to
   * @param pasSource array of shorts to copy from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy(short[] pasDestination, final int piStartIndex, short[] pasSource, final int piHowMany)
  {
    copy(pasDestination, piStartIndex, pasSource, 0, piHowMany);
  }

  /**
   * Copies N long elements from source to destination starting at certain index in the <b>destination</b>.
   *
   * @param palDestination array to copy to
   * @param piStartIndex starting index in the destination to start copying to
   * @param palSource array of longs to copy from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy(long[] palDestination, final int piStartIndex, long[] palSource, final int piHowMany)
  {
    copy(palDestination, piStartIndex, palSource, 0, piHowMany);
  }

  /**
   * Copies N float elements from source to destination starting at certain index in the <b>destination</b>.
   *
   * @param pafDestination array to copy to
   * @param piStartIndex starting index in the destination to start copying to
   * @param pafSource array of floats to copy from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy(float[] pafDestination, final int piStartIndex, float[] pafSource, final int piHowMany)
  {
    copy(pafDestination, piStartIndex, pafSource, 0, piHowMany);
  }

  /**
   * Copies N double elements from source to destination starting at certain index in the <b>destination</b>.
   *
   * @param padDestination array to copy to
   * @param piStartIndex starting index in the destination to start copying to
   * @param padSource array of doubles to copy from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy(double[] padDestination, final int piStartIndex, double[] padSource, final int piHowMany)
  {
    copy(padDestination, piStartIndex, padSource, 0, piHowMany);
  }

  /**
   * Generic <code>copy()</code> routine is based on <code>System.arraycopy()</code>
   * for Object arrays.
   *
   * @param paoDestination destination array of objects to copy to
   * @param piStartIndex starting index in the destination to start copying to
   * @param paoSource source of object elements
   */
  public static void copy(Object[] paoDestination, final int piStartIndex, Object[] paoSource)
  {
    copy(paoDestination, piStartIndex, paoSource, paoSource.length);
  }

  /**
   * Copies source to destination starting at certain index in the <b>destination</b>.
   *
   * @param pabDestination array to copy to
   * @param piStartIndex starting index in the destination to start copying to
   * @param pabSource array of booleans to copy from
   */
  public static void copy(boolean[] pabDestination, final int piStartIndex, boolean[] pabSource)
  {
    copy(pabDestination, piStartIndex, pabSource, pabSource.length);
  }

  /**
   * Copies source to destination starting at certain index in the <b>destination</b>.
   *
   * @param patDestination array to copy to
   * @param piStartIndex starting index in the destination to start copying to
   * @param patSource array of bytes to copy from
   */
  public static void copy(byte[] patDestination, final int piStartIndex, byte[] patSource)
  {
    copy(patDestination, piStartIndex, patSource, patSource.length);
  }

  /**
   * Copies source to destination starting at certain index in the <b>destination</b>.
   *
   * @param pacDestination array to copy to
   * @param piStartIndex starting index in the destination to start copying to
   * @param pacSource array of characters to copy from
   */
  public static void copy(char[] pacDestination, final int piStartIndex, char[] pacSource)
  {
    copy(pacDestination, piStartIndex, pacSource, pacSource.length);
  }

  /**
   * Copies source to destination starting at certain index in the <b>destination</b>.
   *
   * @param paiDestination array to copy to
   * @param piStartIndex starting index in the destination to start copying to
   * @param paiSource array of integers to copy from
   */
  public static void copy(int[] paiDestination, final int piStartIndex, int[] paiSource)
  {
    copy(paiDestination, piStartIndex, paiSource, paiSource.length);
  }

  /**
   * Copies source to destination starting at certain index in the <b>destination</b>.
   *
   * @param pasDestination array to copy to
   * @param piStartIndex starting index in the destination to start copying to
   * @param pasSource array of shorts to copy from
   */
  public static void copy(short[] pasDestination, final int piStartIndex, short[] pasSource)
  {
    copy(pasDestination, piStartIndex, pasSource, pasSource.length);
  }

  /**
   * Copies source to destination starting at certain index in the <b>destination</b>.
   *
   * @param palDestination array to copy to
   * @param piStartIndex starting index in the destination to start copying to
   * @param palSource array of longs to copy from
   */
  public static void copy(long[] palDestination, final int piStartIndex, long[] palSource)
  {
    copy(palDestination, piStartIndex, palSource, palSource.length);
  }

  /**
   * Copies source to destination starting at certain index in the <b>destination</b>.
   *
   * @param pafDestination array to copy to
   * @param piStartIndex starting index in the destination to start copying to
   * @param pafSource array of floats to copy from
   */
  public static void copy(float[] pafDestination, final int piStartIndex, float[] pafSource)
  {
    copy(pafDestination, piStartIndex, pafSource, pafSource.length);
  }

  /**
   * Copies source to destination starting at certain index in the <b>destination</b>.
   *
   * @param padDestination array to copy to
   * @param piStartIndex starting index in the destination to start copying to
   * @param padSource array of doubles to copy from
   */
  public static void copy(double[] padDestination, final int piStartIndex, double[] padSource)
  {
    copy(padDestination, piStartIndex, padSource, padSource.length);
  }

  /**
   * Generic <code>copy()</code> routine is based on <code>System.arraycopy()</code>.
   *
   * @param poDestination destination array of copy
   * @param poSource source of elements
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy(Object poDestination, Object poSource, final int piHowMany)
  {
    copy(poDestination, 0, poSource, piHowMany);
  }

  /**
   * Generic <code>copy()</code> routine is based on <code>System.arraycopy()</code>
   * for Object arrays.
   *
   * @param paoDestination array to copy to
   * @param paoSource source of object elements
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy(Object[] paoDestination, Object[] paoSource, final int piHowMany)
  {
    copy(paoDestination, 0, paoSource, piHowMany);
  }

  /**
   * Copies N character elements from source to destination.
   *
   * @param pacDestination array to copy to
   * @param pacSource array of characters to copy from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy(char[] pacDestination, char[] pacSource, final int piHowMany)
  {
    copy(pacDestination, 0, pacSource, piHowMany);
  }

  /**
   * Copies N boolean elements from source to destination.
   *
   * @param pabDestination array to copy to
   * @param pabSource array of boolean to copy from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy(boolean[] pabDestination, boolean[] pabSource, final int piHowMany)
  {
    copy(pabDestination, 0, pabSource, piHowMany);
  }

  /**
   * Copies N byte elements from source to destination.
   *
   * @param patDestination array to copy to
   * @param patSource array of bytes to copy from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy(byte[] patDestination, byte[] patSource, final int piHowMany)
  {
    copy(patDestination, 0, patSource, piHowMany);
  }

  /**
   * Copies N short elements from source to destination.
   *
   * @param pasDestination array to copy to
   * @param pasSource array of shorts to copy from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy(short[] pasDestination, short[] pasSource, final int piHowMany)
  {
    copy(pasDestination, 0, pasSource, piHowMany);
  }

  /**
   * Copies N long elements from source to destination.
   *
   * @param palDestination array to copy to
   * @param palSource array of longs to copy from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy(long[] palDestination, long[] palSource, final int piHowMany)
  {
    copy(palDestination, 0, palSource, piHowMany);
  }

  /**
   * Copies N float elements from source to destination.
   *
   * @param pafDestination array to copy to
   * @param pafSource array of floats to copy from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy(float[] pafDestination, float[] pafSource, final int piHowMany)
  {
    copy(pafDestination, 0, pafSource, piHowMany);
  }

  /**
   * Copies N double elements from source to destination.
   *
   * @param padDestination array to copy to
   * @param padSource array of doubles to copy from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy(double[] padDestination, double[] padSource, final int piHowMany)
  {
    copy(padDestination, 0, padSource, piHowMany);
  }

  /**
   * Copies N int elements from source to destination.
   *
   * @param paiDestination array to copy to
   * @param paiSource array of ints to copy from
   * @param piHowMany N; the number of elements to copy from the source to the destination
   */
  public static void copy(int[] paiDestination, int[] paiSource, final int piHowMany)
  {
    copy(paiDestination, 0, paiSource, 0, piHowMany);
  }

  /*
   * -------------
   * Concatenation
   * -------------
   */

  /**
   * Concatenates two arrays of objects and returns a newly
   * allocated array of the concatenated pieces.
   * @param paoLHS first array piece
   * @param paoRHS second array piece
   * @return new combined array
   * @since 0.3.0.4
   */
  public static Object[] concatenate(final Object[] paoLHS, final Object[] paoRHS)
  {
    Object[] aoConcatenated = new Object[paoLHS.length + paoRHS.length];
    System.arraycopy(paoLHS, 0, aoConcatenated, 0, paoLHS.length);
    System.arraycopy(paoRHS, 0, aoConcatenated, paoLHS.length,paoRHS.length);
    return aoConcatenated;
  }

  /**
   * Concatenates two arrays of Strings and returns a newly
   * allocated array of the concatenated pieces.
   * @param pastrLHS first array piece
   * @param pastrRHS second array piece
   * @return new combined array
   * @since 0.3.0.4
   */
  public static String[] concatenate(final String[] pastrLHS, final String[] pastrRHS)
  {
    String[] astrConcatenated = new String[pastrLHS.length + pastrRHS.length];
    System.arraycopy(pastrLHS, 0, astrConcatenated, 0, pastrLHS.length);
    System.arraycopy(pastrRHS, 0, astrConcatenated, pastrLHS.length, pastrRHS.length);
    return astrConcatenated;
  }

  /**
   * Concatenates two arrays of doubles and returns a newly
   * allocated array of the concatenated pieces.
   * @param padLHS first array piece
   * @param padRHS second array piece
   * @return new combined array
   * @since 0.3.0.4
   */
  public static double[] concatenate(final double[] padLHS, final double[] padRHS)
  {
    double[] adConcatenated = new double[padLHS.length + padRHS.length];
    System.arraycopy(padLHS, 0, adConcatenated, 0, padLHS.length);
    System.arraycopy(padRHS, 0, adConcatenated, padLHS.length, padRHS.length);
    return adConcatenated;
  }

  /**
   * Concatenates two arrays of booleans and returns a newly
   * allocated array of the concatenated pieces.
   * @param pabLHS first array piece
   * @param pabRHS second array piece
   * @return new combined array
   * @since 0.3.0.4
   */
  public static boolean[] concatenate(final boolean[] pabLHS, final boolean[] pabRHS)
  {
    boolean[] abConcatenated = new boolean[pabLHS.length + pabRHS.length];
    System.arraycopy(pabLHS, 0, abConcatenated, 0, pabLHS.length);
    System.arraycopy(pabRHS, 0, abConcatenated, pabLHS.length, pabRHS.length);
    return abConcatenated;
  }

  /**
   * Concatenates two arrays of bytes and returns a newly
   * allocated array of the concatenated pieces.
   * @param patLHS first array piece
   * @param patRHS second array piece
   * @return new combined array
   * @since 0.3.0.4
   */
  public static byte[] concatenate(final byte[] patLHS, final byte[] patRHS)
  {
    byte[] atConcatenated = new byte[patLHS.length + patRHS.length];
    System.arraycopy(patLHS, 0, atConcatenated, 0, patLHS.length);
    System.arraycopy(patRHS, 0, atConcatenated, patLHS.length, patRHS.length);
    return atConcatenated;
  }

  /**
   * Concatenates two arrays of characters and returns a newly
   * allocated array of the concatenated pieces.
   * @param pacLHS first array piece
   * @param pacRHS second array piece
   * @return new combined array
   * @since 0.3.0.4
   */
  public static char[] concatenate(final char[] pacLHS, final char[] pacRHS)
  {
    char[] acConcatenated = new char[pacLHS.length + pacRHS.length];
    System.arraycopy(pacLHS, 0, acConcatenated, 0, pacLHS.length);
    System.arraycopy(pacRHS, 0, acConcatenated, pacLHS.length, pacRHS.length);
    return acConcatenated;
  }

  /**
   * Concatenates two arrays of integers and returns a newly
   * allocated array of the concatenated pieces.
   * @param paiLHS first array piece
   * @param paiRHS second array piece
   * @return new combined array
   * @since 0.3.0.4
   */
  public static int[] concatenate(final int[] paiLHS, final int[] paiRHS)
  {
    int[] aiConcatenated = new int[paiLHS.length + paiRHS.length];
    System.arraycopy(paiLHS, 0, aiConcatenated, 0, paiLHS.length);
    System.arraycopy(paiRHS, 0, aiConcatenated, paiLHS.length, paiRHS.length);
    return aiConcatenated;
  }

  /**
   * Concatenates two arrays of shorts and returns a newly
   * allocated array of the concatenated pieces.
   * @param pasLHS first array piece
   * @param pasRHS second array piece
   * @return new combined array
   * @since 0.3.0.4
   */
  public static short[] concatenate(final short[] pasLHS, final short[] pasRHS)
  {
    short[] asConcatenated = new short[pasLHS.length + pasRHS.length];
    System.arraycopy(pasLHS, 0, asConcatenated, 0, pasLHS.length);
    System.arraycopy(pasRHS, 0, asConcatenated, pasLHS.length, pasRHS.length);
    return asConcatenated;
  }

  /**
   * Concatenates two arrays of floats and returns a newly
   * allocated array of the concatenated pieces.
   * @param pafLHS first array piece
   * @param pafRHS second array piece
   * @return new combined array
   * @since 0.3.0.4
   */
  public static float[] concatenate(final float[] pafLHS, final float[] pafRHS)
  {
    float[] afConcatenated = new float[pafLHS.length + pafRHS.length];
    System.arraycopy(pafLHS, 0, afConcatenated, 0, pafLHS.length);
    System.arraycopy(pafRHS, 0, afConcatenated, pafLHS.length, pafRHS.length);
    return afConcatenated;
  }

  /**
   * Concatenates two arrays of longs and returns a newly
   * allocated array of the concatenated pieces.
   * @param palLHS first array piece
   * @param palRHS second array piece
   * @return new combined array
   * @since 0.3.0.4
   */
  public static long[] concatenate(final long[] palLHS, final long[] palRHS)
  {
    long[] alConcatenated = new long[palLHS.length + palRHS.length];
    System.arraycopy(palLHS, 0, alConcatenated, 0, palLHS.length);
    System.arraycopy(palRHS, 0, alConcatenated, palLHS.length, palRHS.length);
    return alConcatenated;
  }

  /*
   * --------
   * Equality
   * --------
   */

  /**
   * The <code>equals()</code> routine is based on <code>java.util.Arrays.equals()</code>.
   *
   * @param pabArray1 the first array of booleans to be compared for equality
   * @param pabArray2 the second array of booleans to be compared for equality
   * @return a boolean value <code> true </code> if the two arrays are equal
   */
  public static boolean equals(boolean[] pabArray1, boolean[] pabArray2)
  {
    return java.util.Arrays.equals(pabArray1, pabArray2);
  }

  /**
   * The <code>equals()</code> routine is based on <code>java.util.Arrays.equals()</code>.
   *
   * @param patArray1 the first array of bytes to be compared for equality
   * @param patArray2 the second array of bytes to be compared for equality
   * @return a boolean value <code> true </code> if the two arrays are equal
   */
  public static boolean equals(byte[] patArray1, byte[] patArray2)
  {
    return java.util.Arrays.equals(patArray1, patArray2);
  }

  /**
   * The <code>equals()</code> routine is based on <code>java.util.Arrays.equals()</code>.
   *
   * @param pacArray1 the first array of characters to be compared for equality
   * @param pacArray2 the second array of characters to be compared for equality
   * @return a boolean value <code> true </code> if the two arrays are equal
   */
  public static boolean equals(char[] pacArray1, char[] pacArray2)
  {
    return java.util.Arrays.equals(pacArray1, pacArray2);
  }

  /**
   * The <code>equals()</code> routine is based on <code>java.util.Arrays.equals()</code>.
   *
   * @param padArray1 the first array of doubles to be compared for equality
   * @param padArray2 the second array of doubles to be compared for equality
   * @return a boolean value <code> true </code> if the two arrays are equal
   */
  public static boolean equals(double[] padArray1, double[] padArray2)
  {
    return java.util.Arrays.equals(padArray1, padArray2);
  }

  /**
   * The <code>equals()</code> routine is based on <code>java.util.Arrays.equals()</code>.
   *
   * @param pafArray1 the first array of floats to be compared for equality
   * @param pafArray2 the second array of floats to be compared for equality
   * @return a boolean value <code> true </code> if the two arrays are equal
   */
  public static boolean equals(float[] pafArray1, float[] pafArray2)
  {
    return java.util.Arrays.equals(pafArray1, pafArray2);
  }

  /**
   * The <code>equals()</code> routine is based on <code>java.util.Arrays.equals()</code>.
   *
   * @param paiArray1 the first array of integers to be compared for equality
   * @param paiArray2 the second array of integers to be compared for equality
   * @return a boolean value <code> true </code> if the two arrays are equal
   */
  public static boolean equals(int[] paiArray1, int[] paiArray2)
  {
    return java.util.Arrays.equals(paiArray1, paiArray2);
  }

  /**
   * The <code>equals()</code> routine is based on <code>java.util.Arrays.equals()</code>.
   *
   * @param palArray1 the first array of longs to be compared for equality
   * @param palArray2 the second array of longs to be compared for equality
   * @return a boolean value <code> true </code> if the two arrays are equal
   */
  public static boolean equals(long[] palArray1, long[] palArray2)
  {
    return java.util.Arrays.equals(palArray1, palArray2);
  }

  /**
   * The <code>equals()</code> routine is based on <code>java.util.Arrays.equals()</code>.
   *
   * @param paoArray1 the first array of Objects to be compared for equality
   * @param paoArray2 the second array of Objects to be compared for equality
   * @return a boolean value <code> true </code> if the two arrays are equal
   */
  public static boolean equals(Object[] paoArray1, Object[] paoArray2)
  {
    return java.util.Arrays.equals(paoArray1, paoArray2);
  }

  /**
   * The <code>equals()</code> routine is based on <code>java.util.Arrays.equals()</code>.
   *
   * @param pasArray1 the first array of shorts to be compared for equality
   * @param pasArray2 the second array of shorts to be compared for equality
   * @return a boolean value <code> true </code> if the two arrays are equal
   */
  public static boolean equals(short[] pasArray1, short[] pasArray2)
  {
    return java.util.Arrays.equals(pasArray1, pasArray2);
  }

  /*
   * -------------
   * Array filling
   * -------------
   */

  /**
   * The <code>fill()</code> is based on <code>java.util.Arrays.fill()</code>.
   *
   * @param pabArray the array of booleans to be filled
   * @param pbValue the value of boolean  to fill into the array of booleans
   */
  public static void fill(boolean[] pabArray, boolean pbValue)
  {
    java.util.Arrays.fill(pabArray, pbValue);
  }

  /**
   * The <code>fill()</code> is based on <code>java.util.Arrays.fill()</code>.
   *
   * @param pabArray the array of booleans to be filled
   * @param piFromIndex the index of the array from here the value to be filled
   * @param piToIndex the index one after the last element of the array to be filled
   * @param pbValue the value of boolean  to fill into the array of booleans
   */
  public static void fill(boolean[] pabArray, int piFromIndex, int piToIndex, boolean pbValue)
  {
    java.util.Arrays.fill(pabArray, piFromIndex, piToIndex, pbValue);
  }

  /**
   * The <code>fill()</code> is based on <code>java.util.Arrays.fill()</code>.
   *
   * @param patArray the array of bytes to be filled
   * @param ptValue the value of byte to fill into the array of bytes
   */
  public static void fill(byte[] patArray, byte ptValue)
  {
    java.util.Arrays.fill(patArray, ptValue);
  }

  /**
   * The <code>fill()</code> is based on <code>java.util.Arrays.fill()</code>.
   *
   * @param patArray the array of bytes to be filled
   * @param piFromIndex the index of the array from here the value to be filled
   * @param piToIndex the index one after the last element of the array to be filled
   * @param ptValue the value of byte to fill into the array of bytes
   */
  public static void fill(byte[] patArray, int piFromIndex, int piToIndex, byte ptValue)
  {
    java.util.Arrays.fill(patArray, piFromIndex, piToIndex, ptValue);
  }

  /**
   * The <code>fill()</code> is based on <code>java.util.Arrays.fill()</code>.
   *
   * @param pacArray the array of characters to be filled
   * @param pcValue the value of character to fill into the array of characters
   */
  public static void fill(char[] pacArray, char pcValue)
  {
    java.util.Arrays.fill(pacArray, pcValue);
  }

  /**
   * The <code>fill()</code> is based on <code>java.util.Arrays.fill()</code>.
   *
   * @param pacArray the array of characters to be filled
   * @param piFromIndex the index of the array from here the value to be filled
   * @param piToIndex the index one after the last element of the array to be filled
   * @param pcValue the value of character to fill into the array of characters
   */
  public static void fill(char[] pacArray, int piFromIndex, int piToIndex, char pcValue)
  {
    java.util.Arrays.fill(pacArray, piFromIndex, piToIndex, pcValue);
  }

  /**
   * The <code>fill()</code> is based on <code>java.util.Arrays.fill()</code>.
   *
   * @param padArray the array of doubles to be filled
   * @param pdValue the value of double to fill into the array of doubles
   */
  public static void fill(double[] padArray, double pdValue)
  {
    java.util.Arrays.fill(padArray, pdValue);
  }

  /**
   * The <code>fill()</code> is based on <code>java.util.Arrays.fill()</code>.
   *
   * @param padArray the array of doubles to be filled
   * @param piFromIndex the index of the array from here the value to be filled
   * @param piToIndex the index one after the last element of the array to be filled
   * @param pdValue the value of double to fill into the array of doubles
   */
  public static void fill(double[] padArray, int piFromIndex, int piToIndex, double pdValue)
  {
    java.util.Arrays.fill(padArray, piFromIndex, piToIndex, pdValue);
  }

  /**
   * The <code>fill()</code> is based on <code>java.util.Arrays.fill()</code>.
   *
   * @param pafArray the array of floats to be filled
   * @param pfValue the value of float to fill into the array of floats
   */
  public static void fill(float[] pafArray, float pfValue)
  {
    java.util.Arrays.fill(pafArray, pfValue);
  }

  /**
   * The <code>fill()</code> is based on <code>java.util.Arrays.fill()</code>.
   *
   * @param pafArray the array of floats to be filled
   * @param piFromIndex the index of the array from here the value to be filled
   * @param piToIndex the index one after the last element of the array to be filled
   * @param pfValue the value of float to fill into the array of floats
   */
  public static void fill(float[] pafArray, int piFromIndex, int piToIndex, float pfValue)
  {
    java.util.Arrays.fill(pafArray, piFromIndex, piToIndex, pfValue);
  }

  /**
   * The <code>fill()</code> is based on <code>java.util.Arrays.fill()</code>.
   *
   * @param paiArray the array of integers to be filled
   * @param piValue the value of integer to fill into the array of integers
   */
  public static void fill(int[] paiArray, int piValue)
  {
    java.util.Arrays.fill(paiArray, piValue);
  }

  /**
   * The <code>fill()</code> is based on <code>java.util.Arrays.fill()</code>.
   *
   * @param paiArray the array of integers to be filled
   * @param piFromIndex the index of the array from here the value to be filled
   * @param piToIndex the index one after the last element of the array to be filled
   * @param piValue the value of integer to fill into the array of integers
   */
  public static void fill(int[] paiArray, int piFromIndex, int piToIndex, int piValue)
  {
    java.util.Arrays.fill(paiArray, piFromIndex, piToIndex, piValue);
  }

  /**
   * The <code>fill()</code> is based on <code>java.util.Arrays.fill()</code>.
   *
   * @param palArray the array of longs to be filled
   * @param piFromIndex the index of the array from here the value to be filled
   * @param piToIndex the index one after the last element of the array to be filled
   * @param plValue the value of long to fill into the array of longs
   */
  public static void fill(long[] palArray, int piFromIndex, int piToIndex, long plValue)
  {
    java.util.Arrays.fill(palArray, piFromIndex, piToIndex, plValue);
  }

  /**
   * The <code>fill()</code> is based on <code>java.util.Arrays.fill()</code>.
   *
   * @param palArray the array of longs to be filled
   * @param plValue the value of long to fill into the array of longs
   */
  public static void fill(long[] palArray, long plValue)
  {
    java.util.Arrays.fill(palArray, plValue);
  }

  /**
   * The <code>fill()</code> is based on <code>java.util.Arrays.fill()</code>.
   *
   * @param paoArray the array to be filled
   * @param piFromIndex the index of the array from here the value to be filled
   * @param piToIndex the index one after the last element of the array to be filled
   * @param paValue the value to fill into the array
   */
  public static void fill(Object[] paoArray, int piFromIndex, int piToIndex, Object paValue)
  {
    java.util.Arrays.fill(paoArray, piFromIndex, piToIndex, paValue);
  }

  /**
   * The <code>fill()</code> is based on <code>java.util.Arrays.fill()</code>.
   *
   * @param paoArray the array to be filled
   * @param poValue the value to fill into the array
   */
  public static void fill(Object[] paoArray, Object poValue)
  {
    java.util.Arrays.fill(paoArray, poValue);
  }

  /**
   * The <code>fill()</code> is based on <code>java.util.Arrays.fill()</code>.
   *
   * @param pasArray the array of shorts to be filled
   * @param piFromIndex the index of the array from here the value to be filled
   * @param piToIndex the index one after the last element of the array to be filled
   * @param psValue the value of short  to fill into the array of shorts
   */
  public static void fill(short[] pasArray, int piFromIndex, int piToIndex, short psValue)
  {
    java.util.Arrays.fill(pasArray, piFromIndex, piToIndex, psValue);
  }

  /**
   * The <code>fill()</code> is based on <code>java.util.Arrays.fill()</code>.
   *
   * @param pasArray the array of shorts to be filled
   * @param psValue the value of short  to fill into the array of shorts
   */
  public static void fill(short[] pasArray, short psValue)
  {
    java.util.Arrays.fill(pasArray, psValue);
  }

  /**
   * Sets all elements of the parameter at pseudo-random order.
   * The range of the values is [- Double.MAX_VALUE / 2, Double.MAX_VALUE / 2].
   * @param padArray the array to fill
   * @since 0.3.0.6
   */
  public static void fillRandom(double[] padArray)
  {
    for(int i = 0; i < padArray.length; i++)
    {
      padArray[i] = (Math.random() - 0.5) * Double.MAX_VALUE;
    }
  }

  
  /*
   * -------
   * Sorting
   * -------
   */

  /**
   * A wrapper of java.util.Arrays.sort(Object[], Comparator).
   *
   * @param paoArrayToSort array of objects to sort
   * @param poComparator comparator object to use while sorting
   */
  public static void sort(Object[] paoArrayToSort, Comparator poComparator)
  {
    java.util.Arrays.sort(paoArrayToSort, poComparator);
  }

  /**
   * A wrapper of java.util.Arrays.sort(double[]).
   *
   * @param padArrayToSort array of doubles to sort
   */
  public static void sort(double[] padArrayToSort)
  {
    java.util.Arrays.sort(padArrayToSort);
  }

  /**
   * A wrapper of java.util.Arrays.sort(float[]).
   *
   * @param pafArrayToSort array of float to sort
   */
  public static void sort(float[] pafArrayToSort)
  {
    java.util.Arrays.sort(pafArrayToSort);
  }

  /**
   * A wrapper of java.util.Arrays.sort(int[]).
   *
   * @param paiArrayToSort array of integers to sort
   */
  public static void sort(int[] paiArrayToSort)
  {
    java.util.Arrays.sort(paiArrayToSort);
  }

  /**
   * A wrapper of java.util.Arrays.sort(byte[]).
   *
   * @param patArrayToSort array of bytes to sort
   */
  public static void sort(byte[] patArrayToSort)
  {
    java.util.Arrays.sort(patArrayToSort);
  }

  /**
   * A wrapper of java.util.Arrays.sort(char[]).
   *
   * @param pacArrayToSort array of characters to sort
   */
  public static void sort(char[] pacArrayToSort)
  {
    java.util.Arrays.sort(pacArrayToSort);
  }

  /**
   * A wrapper of java.util.Arrays.sort(double[]).
   *
   * @param palArrayToSort array of longs to sort
   */
  public static void sort(long[] palArrayToSort)
  {
    java.util.Arrays.sort(palArrayToSort);
  }

  /**
   * A wrapper of java.util.Arrays.sort(short[]).
   *
   * @param pasArrayToSort array of shorts to sort
   */
  public static void sort(short[] pasArrayToSort)
  {
    java.util.Arrays.sort(pasArrayToSort);
  }

  /**
   * A wrapper of java.util.Arrays.sort(object []).
   *
   * @param paoArrayToSort array of objects to sort
   */
  public static void sort(Object[] paoArrayToSort)
  {
    java.util.Arrays.sort(paoArrayToSort);
  }

  /*
   * ----------
   * Conversion
   * ----------
   */

  /**
   * Converts array of doubles to Vector.
   *
   * @param padData array of double data
   * @return equivalent collection of Double objects
   * @since 0.3.0.3
   */
  public static Vector arrayToVector(final double[] padData)
  {
    Vector oVector = new Vector(padData.length);

    for(int i = 0; i < padData.length; i++)
    {
      oVector.add(new Double(padData[i]));
    }

    return oVector;
  }

  /**
   * Converts array of ints to Vector.
   *
   * @param paiData array of int data
   * @return equivalent collection of Integer objects
   * @since 0.3.0.3
   */
  public static Vector arrayToVector(final int[] paiData)
  {
    Vector oVector = new Vector(paiData.length);

    for(int i = 0; i < paiData.length; i++)
    {
      oVector.add(new Integer(paiData[i]));
    }

    return oVector;
  }

  /**
   * Converts array of floats to Vector.
   *
   * @param pafData array of float data
   * @return equivalent collection of Float objects
   * @since 0.3.0.3
   */
  public static Vector arrayToVector(final float[] pafData)
  {
    Vector oVector = new Vector(pafData.length);

    for(int i = 0; i < pafData.length; i++)
    {
      oVector.add(new Float(pafData[i]));
    }

    return oVector;
  }

  /**
   * Converts array of shorts to Vector.
   *
   * @param pasData array of short data
   * @return equivalent collection of Short objects
   * @since 0.3.0.3
   */
  public static Vector arrayToVector(final short[] pasData)
  {
    Vector oVector = new Vector(pasData.length);

    for(int i = 0; i < pasData.length; i++)
    {
      oVector.add(new Short(pasData[i]));
    }

    return oVector;
  }

  /**
   * Converts array of longs to Vector.
   *
   * @param palData array of long data
   * @return equivalent collection of Long objects
   * @since 0.3.0.3
   */
  public static Vector arrayToVector(final long[] palData)
  {
    Vector oVector = new Vector(palData.length);

    for(int i = 0; i < palData.length; i++)
    {
      oVector.add(new Long(palData[i]));
    }

    return oVector;
  }

  /**
   * Converts array of characters to Vector.
   *
   * @param pacData array of character data
   * @return equivalent collection of Character objects
   * @since 0.3.0.3
   */
  public static Vector arrayToVector(final char[] pacData)
  {
    Vector oVector = new Vector(pacData.length);

    for(int i = 0; i < pacData.length; i++)
    {
      oVector.add(new Character(pacData[i]));
    }

    return oVector;
  }

  /**
   * Converts array of bytes to Vector.
   *
   * @param patData array of byte data
   * @return equivalent collection of Byte objects
   * @since 0.3.0.3
   */
  public static Vector arrayToVector(final byte[] patData)
  {
    Vector oVector = new Vector(patData.length);

    for(int i = 0; i < patData.length; i++)
    {
      oVector.add(new Byte(patData[i]));
    }

    return oVector;
  }

  /**
   * Converts array of Strings to Vector.
   *
   * @param pastrData array of String data
   * @return equivalent collection of String objects
   * @since 0.3.0.3
   */
  public static Vector arrayToVector(final String[] pastrData)
  {
    Vector oVector = new Vector(pastrData.length);

    for(int i = 0; i < pastrData.length; i++)
    {
      oVector.add(new String(pastrData[i]));
    }

    return oVector;
  }

  /**
   * Converts array of Objects to Vector.
   *
   * @param paoData array of Object data
   * @return equivalent collection of objects
   * @since 0.3.0.6
   */
  public static Vector arrayToVector(final Object[] paoData)
  {
    Vector oVector = new Vector(paoData.length);

    for(int i = 0; i < paoData.length; i++)
    {
      oVector.add(paoData[i]);
    }

    return oVector;
  }

  /**
   * Converts array of Strings to a single string separated by
   * the specified delimeter.
   *
   * @param pastrData string data to concatenate
   * @param pstrDelimeter data elements separator
   * @return the resulting combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToDelimitedString(final String[] pastrData, final String pstrDelimeter)
  {
    String strRetVal = pastrData[0];

    if(pastrData.length > 0)
    {
      for(int i = 1; i < pastrData.length; i++)
      {
        strRetVal += pstrDelimeter + pastrData[i];
      }
    }

    return strRetVal;
  }

  /**
   * Converts array of integers to a single string separated by
   * the specified delimeter.
   *
   * @param paiData int data to append
   * @param pstrDelimeter data elements separator
   * @return the resulting combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToDelimitedString(final int[] paiData, final String pstrDelimeter)
  {
    StringBuffer oRetVal = new StringBuffer();

    if(paiData.length > 0)
    {
      oRetVal.append(paiData[0]);
  
      for(int i = 1; i < paiData.length; i++)
      {
        oRetVal.append(pstrDelimeter).append(paiData[i]);
      }
    }

    return oRetVal.toString();
  }

  /**
   * Converts array of Objects to a single string separated by
   * the specified delimeter.
   *
   * @param paoData Object data to append
   * @param pstrDelimeter data elements separator
   * @return the resulting combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToDelimitedString(final Object[] paoData, final String pstrDelimeter)
  {
    StringBuffer oRetVal = new StringBuffer();

    if(paoData.length > 0)
    {
      oRetVal.append(paoData[0]);
  
      for(int i = 1; i < paoData.length; i++)
      {
        oRetVal.append(pstrDelimeter).append(paoData[i]);
      }
    }

    return oRetVal.toString();
  }

  /**
   * Converts array of longs to a single string separated by
   * the specified delimeter.
   *
   * @param palData long data to append
   * @param pstrDelimeter data elements separator
   * @return the resulting combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToDelimitedString(final long[] palData, final String pstrDelimeter)
  {
    StringBuffer oRetVal = new StringBuffer();

    if(palData.length > 0)
    {
      oRetVal.append(palData[0]);
  
      for(int i = 1; i < palData.length; i++)
      {
        oRetVal.append(pstrDelimeter).append(palData[i]);
      }
    }

    return oRetVal.toString();
  }

  /**
   * Converts array of floats to a single string separated by
   * the specified delimeter.
   *
   * @param pafData float data to append
   * @param pstrDelimeter data elements separator
   * @return the resulting combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToDelimitedString(final float[] pafData, final String pstrDelimeter)
  {
    StringBuffer oRetVal = new StringBuffer();

    if(pafData.length > 0)
    {
      oRetVal.append(pafData[0]);
  
      for(int i = 1; i < pafData.length; i++)
      {
        oRetVal.append(pstrDelimeter).append(pafData[i]);
      }
    }

    return oRetVal.toString();
  }

  /**
   * Converts array of doubles to a single string separated by
   * the specified delimeter.
   *
   * @param padData double data to append
   * @param pstrDelimeter data elements separator
   * @return the resulting combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToDelimitedString(final double[] padData, final String pstrDelimeter)
  {
    StringBuffer oRetVal = new StringBuffer();

    if(padData.length > 0)
    {
      oRetVal.append(padData[0]);
  
      for(int i = 1; i < padData.length; i++)
      {
        oRetVal.append(pstrDelimeter).append(padData[i]);
      }
    }

    return oRetVal.toString();
  }

  /**
   * Converts array of bytes to a single string separated by
   * the specified delimeter.
   *
   * @param patData byte data to append
   * @param pstrDelimeter data elements separator
   * @return the resulting combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToDelimitedString(final byte[] patData, final String pstrDelimeter)
  {
    StringBuffer oRetVal = new StringBuffer();

    if(patData.length > 0)
    {
      oRetVal.append(patData[0]);
  
      for(int i = 1; i < patData.length; i++)
      {
        oRetVal.append(pstrDelimeter).append(patData[i]);
      }
    }

    return oRetVal.toString();
  }

  /**
   * Converts array of booleans to a single string separated by
   * the specified delimeter.
   *
   * @param pabData boolean data to append
   * @param pstrDelimeter data elements separator
   * @return the resulting combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToDelimitedString(final boolean[] pabData, final String pstrDelimeter)
  {
    StringBuffer oRetVal = new StringBuffer();

    if(pabData.length > 0)
    {
      oRetVal.append(pabData[0]);
  
      for(int i = 1; i < pabData.length; i++)
      {
        oRetVal.append(pstrDelimeter).append(pabData[i]);
      }
    }

    return oRetVal.toString();
  }

  /**
   * Converts array of characters to a single string separated by
   * the specified delimeter.
   *
   * @param pacData charater data to append
   * @param pstrDelimeter data elements separator
   * @return the resulting combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToDelimitedString(final char[] pacData, final String pstrDelimeter)
  {
    StringBuffer oRetVal = new StringBuffer();

    if(pacData.length > 0)
    {
      oRetVal.append(pacData[0]);
  
      for(int i = 1; i < pacData.length; i++)
      {
        oRetVal.append(pstrDelimeter).append(pacData[i]);
      }
    }

    return oRetVal.toString();
  }

  /**
   * Converts array of Strings to a single space-separated String.
   *
   * @param pastrData array of String data
   * @return equivalent combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToString(final String[] pastrData)
  {
    return arrayToDelimitedString(pastrData, " ");
  }

  /**
   * Converts array of Objects to a single space-separated String.
   *
   * @param paoData array of Object data
   * @return equivalent combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToString(final Object[] paoData)
  {
    return arrayToDelimitedString(paoData, " ");
  }

  /**
   * Converts array of integers to a single space-separated String.
   *
   * @param paiData array of integer data
   * @return equivalent combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToString(final int[] paiData)
  {
    return arrayToDelimitedString(paiData, " ");
  }

  /**
   * Converts array of longs to a single space-separated String.
   *
   * @param palData array of long data
   * @return equivalent combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToString(final long[] palData)
  {
    return arrayToDelimitedString(palData, " ");
  }

  /**
   * Converts array of floats to a single space-separated String.
   *
   * @param pafData array of float data
   * @return equivalent combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToString(final float[] pafData)
  {
    return arrayToDelimitedString(pafData, " ");
  }

  /**
   * Converts array of doubles to a single space-separated String.
   *
   * @param padData array of double data
   * @return equivalent combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToString(final double[] padData)
  {
    return arrayToDelimitedString(padData, " ");
  }

  /**
   * Converts array of bytes to a single space-separated String.
   *
   * @param patData array of byte data
   * @return equivalent combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToString(final byte[] patData)
  {
    return arrayToDelimitedString(patData, " ");
  }

  /**
   * Converts array of booleans to a single space-separated String.
   *
   * @param pabData array of boolean data
   * @return equivalent combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToString(final boolean[] pabData)
  {
    return arrayToDelimitedString(pabData, " ");
  }

  /**
   * Converts array of characters to a single space-separated String.
   *
   * @param pacData array of charater data
   * @return equivalent combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToString(final char[] pacData)
  {
    return arrayToDelimitedString(pacData, " ");
  }

  /**
   * Converts array of Strings to a single comma-separated String.
   *
   * @param pastrData array of String data
   * @return equivalent combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToCSV(final String[] pastrData)
  {
    return arrayToDelimitedString(pastrData, ",");
  }

  /**
   * Converts array of Objects to a single comma-separated String.
   *
   * @param paoData array of Object data
   * @return equivalent combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToCSV(final Object[] paoData)
  {
    return arrayToDelimitedString(paoData, ",");
  }

  /**
   * Converts array of integers to a single comma-separated String.
   *
   * @param paiData array of integer data
   * @return equivalent combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToCSV(final int[] paiData)
  {
    return arrayToDelimitedString(paiData, ",");
  }

  /**
   * Converts array of longs to a single comma-separated String.
   *
   * @param palData array of long data
   * @return equivalent combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToCSV(final long[] palData)
  {
    return arrayToDelimitedString(palData, ",");
  }

  /**
   * Converts array of floats to a single comma-separated String.
   *
   * @param pafData array of float data
   * @return equivalent combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToCSV(final float[] pafData)
  {
    return arrayToDelimitedString(pafData, ",");
  }

  /**
   * Converts array of doubles to a single comma-separated String.
   *
   * @param padData array of double data
   * @return equivalent combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToCSV(final double[] padData)
  {
    return arrayToDelimitedString(padData, ",");
  }

  /**
   * Converts array of bytes to a single comma-separated String.
   *
   * @param patData array of byte data
   * @return equivalent combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToCSV(final byte[] patData)
  {
    return arrayToDelimitedString(patData, ",");
  }

  /**
   * Converts array of booleans to a single comma-separated String.
   *
   * @param pabData array of boolean data
   * @return equivalent combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToCSV(final boolean[] pabData)
  {
    return arrayToDelimitedString(pabData, ",");
  }

  /**
   * Converts array of charaters to a single comma-separated String.
   *
   * @param pacData array of charater data
   * @return equivalent combined string
   *
   * @since 0.3.0.5
   */
  public static String arrayToCSV(final char[] pacData)
  {
    return arrayToDelimitedString(pacData, ",");
  }

  /**
   * Provides an array-of-objects-to-List bridge.
   * Wraps <code>java.util.Arrays.asList()</code>.
   *
   * @param paoObjects array of objects
   * @return corresponding List collection
   * @since 0.3.0.3
   */
  public static java.util.List asList(Object[] paoObjects)
  {
    return java.util.Arrays.asList(paoObjects);
  }

  /**
   * General copy-conversion method that copies N int elements
   * from an array of ints into array of doubles.
   *
   * @param padDestination destination array of doubles
   * @param piDestinationFrom index in the destination to start place elements at
   * @param paiSource sourc earray of ints
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(double[] padDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      padDestination[piDestinationFrom + i] = paiSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N int elements
   * from an array of ints into array of doubles.
   *
   * @param padDestination destination array of doubles
   * @param paiSource sourc earray of ints
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(double[] padDestination, int[] paiSource, int piHowMany)
  {
    copy(padDestination, 0, paiSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all int elements
   * from an array of ints into array of doubles.
   *
   * @param padDestination destination array of doubles
   * @param paiSource source array of ints
   * @since 0.3.0.3
   */
  public static void copy(double[] padDestination, int[] paiSource)
  {
    copy(padDestination, 0, paiSource, 0, paiSource.length);
  }

  /**
   * General copy-conversion method that copies N int elements
   * from an array of ints into array of floats.
   *
   * @param pafDestination destination array of floats
   * @param piDestinationFrom index in the destination to start place elements at
   * @param paiSource source array of ints
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(float[] pafDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pafDestination[piDestinationFrom + i] = paiSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N int elements
   * from an array of ints into array of floats.
   *
   * @param pafDestination destination array of floats
   * @param paiSource source array of ints
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(float[] pafDestination, int[] paiSource, int piHowMany)
  {
    copy(pafDestination, 0, paiSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all int elements
   * from an array of ints into array of floats.
   *
   * @param pafDestination destination array of floats
   * @param paiSource source array of ints
   * @since 0.3.0.3
   */
  public static void copy(float[] pafDestination, int[] paiSource)
  {
    copy(pafDestination, 0, paiSource, 0, paiSource.length);
  }

  /**
   * General copy-conversion method that copies N int elements
   * from an array of ints into array of longs.
   *
   * @param palDestination destination array of longs
   * @param piDestinationFrom index in the destination to start place elements at
   * @param paiSource source array of ints
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      palDestination[piDestinationFrom + i] = paiSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N int elements
   * from an array of ints into array of longs.
   *
   * @param palDestination destination array of longs
   * @param paiSource source array of ints
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, int[] paiSource, int piHowMany)
  {
    copy(palDestination, 0, paiSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all int elements
   * from an array of ints into array of longs.
   *
   * @param palDestination destination array of longs
   * @param paiSource source array of ints
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, int[] paiSource)
  {
    copy(palDestination, 0, paiSource, 0, paiSource.length);
  }

  /**
   * General copy-conversion method that copies N int elements
   * from an array of ints into array of shorts.
   *
   * @param pasDestination destination array of shorts
   * @param piDestinationFrom index in the destination to start place elements at
   * @param paiSource source array of ints
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(short[] pasDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pasDestination[piDestinationFrom + i] = (short)paiSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N int elements
   * from an array of ints into array of shorts.
   *
   * @param pasDestination destination array of shorts
   * @param paiSource source array of ints
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(short[] pasDestination, int[] paiSource, int piHowMany)
  {
    copy(pasDestination, 0, paiSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all int elements
   * from an array of ints into array of shorts.
   *
   * @param pasDestination destination array of shorts
   * @param paiSource source array of ints
   * @since 0.3.0.3
   */
  public static void copy(short[] pasDestination, int[] paiSource)
  {
    copy(pasDestination, 0, paiSource, 0, paiSource.length);
  }

  /**
   * General copy-conversion method that copies N int elements
   * from an array of ints into array of bytes.
   *
   * @param patDestination destination array of bytes
   * @param piDestinationFrom index in the destination to start place elements at
   * @param paiSource source array of ints
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(byte[] patDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      patDestination[piDestinationFrom + i] = (byte)(paiSource[piSourceFrom + i]);
  }

  /**
   * Copy-conversion method that copies N int elements
   * from an array of ints into array of bytes.
   *
   * @param patDestination destination array of bytes
   * @param paiSource source array of ints
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(byte[] patDestination, int[] paiSource, int piHowMany)
  {
    copy(patDestination, 0, paiSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all int elements
   * from an array of ints into array of bytes.
   *
   * @param patDestination destination array of bytes
   * @param paiSource sourc earray of ints
   * @since 0.3.0.3
   */
  public static void copy(byte[] patDestination, int[] paiSource)
  {
    copy(patDestination, 0, paiSource, 0, paiSource.length);
  }

  /**
   * General copy-conversion method that copies N int elements
   * from an array of ints into array of characters.
   *
   * @param pacDestination destination array of characters
   * @param piDestinationFrom index in the destination to start place elements at
   * @param paiSource source array of ints
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(char[] pacDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pacDestination[piDestinationFrom + i] = (char)paiSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N int elements
   * from an array of ints into array of characters.
   *
   * @param pacDestination destination array of characters
   * @param paiSource sourc earray of ints
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(char[] pacDestination, int[] paiSource, int piHowMany)
  {
    copy(pacDestination, 0, paiSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all int elements
   * from an array of ints into array of characters.
   *
   * @param pacDestination destination array of characters
   * @param paiSource sourc earray of ints
   * @since 0.3.0.3
   */
  public static void copy(char[] pacDestination, int[] paiSource)
  {
    copy(pacDestination, 0, paiSource, 0, paiSource.length);
  }

  /**
   * General copy-conversion method that copies N double elements
   * from an array of doubles into array of integers.
   *
   * @param paiDestination destination array of integers
   * @param piDestinationFrom index in the destination to start place elements at
   * @param padSource source array of doubles
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(int[] paiDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      paiDestination[piDestinationFrom + i] =(int)padSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N double elements
   * from an array of doubles into array of integers.
   *
   * @param paiDestination destination array of integers
   * @param padSource source array of doubles
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(int[] paiDestination, double[] padSource, int piHowMany)
  {
    copy(paiDestination, 0, padSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all double elements
   * from an array of doubles into array of ints.
   *
   * @param paiDestination destination array of ints
   * @param padSource source array of doubles
   * @since 0.3.0.3
   */
  public static void copy(int[] paiDestination, double[] padSource)
  {
    copy(paiDestination, 0, padSource, 0, padSource.length);
  }

  /**
   * General copy-conversion method that copies N double elements
   * from an array of doubles into array of characters.
   *
   * @param pacDestination destination array of characters
   * @param piDestinationFrom index in the destination to start place elements at
   * @param padSource source array of doubles
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(char[] pacDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pacDestination[piDestinationFrom + i] =(char)padSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N double elements
   * from an array of doubles into array of characters.
   *
   * @param pacDestination destination array of characters
   * @param padSource source array of doubles
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(char[] pacDestination, double[] padSource, int piHowMany)
  {
    copy(pacDestination, 0, padSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all double elements
   * from an array of doubles into array of characters.
   *
   * @param pacDestination destination array of characters
   * @param padSource source array of doubles
   * @since 0.3.0.3
   */
  public static void copy(char[] pacDestination, double[] padSource)
  {
    copy(pacDestination, 0, padSource, 0, padSource.length);
  }

  /**
   * General copy-conversion method that copies N double elements
   * from an array of doubles into array of bytes.
   *
   * @param patDestination destination array of bytes
   * @param piDestinationFrom index in the destination to start place elements at
   * @param padSource source array of doubles
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(byte[] patDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      patDestination[piDestinationFrom + i] =(byte)padSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N double elements
   * from an array of doubles into array of bytes.
   *
   * @param patDestination destination array of bytes
   * @param padSource source array of doubles
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(byte[] patDestination, double[] padSource, int piHowMany)
  {
    copy(patDestination, 0, padSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all double elements
   * from an array of doubles into array of bytes.
   *
   * @param patDestination destination array of bytes
   * @param padSource source array of doubles
   * @since 0.3.0.3
   */
  public static void copy(byte[] patDestination, double[] padSource)
  {
    copy(patDestination, 0, padSource, 0, padSource.length);
  }

  /**
   * General copy-conversion method that copies N double elements
   * from an array of doubles into array of floats.
   *
   * @param pafDestination destination array of floats
   * @param piDestinationFrom index in the destination to start place elements at
   * @param padSource source array of doubles
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(float[] pafDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pafDestination[piDestinationFrom + i] = (float)padSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N double elements
   * from an array of doubles into array of floats.
   *
   * @param pafDestination destination array of floats
   * @param padSource source array of doubles
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(float[] pafDestination, double[] padSource, int piHowMany)
  {
    copy(pafDestination, 0, padSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all double elements
   * from an array of doubles into array of floats.
   *
   * @param pafDestination destination array of floats
   * @param padSource source array of doubles
   * @since 0.3.0.3
   */
  public static void copy(float[] pafDestination, double[] padSource)
  {
    copy(pafDestination, 0, padSource, 0, padSource.length);
  }

  /**
   * General copy-conversion method that copies N double elements
   * from an array of doubles into array of shorts.
   *
   * @param pasDestination destination array of shorts
   * @param piDestinationFrom index in the destination to start place elements at
   * @param padSource source array of doubles
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(short[] pasDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pasDestination[piDestinationFrom + i] =(short)padSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N double elements
   * from an array of doubles into array of shorts.
   *
   * @param pasDestination destination array of shorts
   * @param padSource source array of doubles
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(short[] pasDestination, double[] padSource, int piHowMany)
  {
    copy(pasDestination, 0, padSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all double elements
   * from an array of doubles into array of shorts.
   *
   * @param pasDestination destination array of shorts
   * @param padSource source array of doubles
   * @since 0.3.0.3
   */
  public static void copy(short[] pasDestination, double[] padSource)
  {
    copy(pasDestination, 0, padSource, 0, padSource.length);
  }

  /**
   * General copy-conversion method that copies N double elements
   * from an array of doubles into array of longs.
   *
   * @param palDestination destination array of longs
   * @param piDestinationFrom index in the destination to start place elements at
   * @param padSource source array of doubles
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      palDestination[piDestinationFrom + i] =(long)padSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N double elements
   * from an array of doubles into array of longs.
   *
   * @param palDestination destination array of longs
   * @param padSource source array of doubles
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, double[] padSource, int piHowMany)
  {
    copy(palDestination, 0, padSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all double elements
   * from an array of doubles into array of longs.
   *
   * @param palDestination destination array of longs
   * @param padSource source array of doubles
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, double[] padSource)
  {
    copy(palDestination, 0, padSource, 0, padSource.length);
  }


  /**
   * General copy-conversion method that copies N float elements
   * from an array of floats into array of characters.
   *
   * @param pacDestination destination array of characters
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pafSource source array of floats
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(char[] pacDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pacDestination[piDestinationFrom + i] = (char)pafSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N float elements
   * from an array of floats into array of characters.
   *
   * @param pacDestination destination array of characters
   * @param pafSource source array of floats
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(char[] pacDestination, float[] pafSource, int piHowMany)
  {
    copy(pacDestination, 0, pafSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all float elements
   * from an array of floats into array of characters.
   *
   * @param pacDestination destination array of characters
   * @param pafSource source array of floats
   * @since 0.3.0.3
   */
  public static void copy(char[] pacDestination, float[] pafSource)
  {
    copy(pacDestination, 0, pafSource, 0, pafSource.length);
  }

  /**
   * General copy-conversion method that copies N float elements
   * from an array of floats into array of bytes.
   *
   * @param patDestination destination array of bytes
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pafSource source array of floats
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(byte[] patDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      patDestination[piDestinationFrom + i] = (byte)pafSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N float elements
   * from an array of floats into array of bytes.
   *
   * @param patDestination destination array of characters
   * @param pafSource source array of bytes
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(byte[] patDestination, float[] pafSource, int piHowMany)
  {
    copy(patDestination, 0, pafSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all float elements
   * from an array of floats into array of characters.
   *
   * @param patDestination destination array of bytes
   * @param pafSource source array of floats
   * @since 0.3.0.3
   */
  public static void copy(byte[] patDestination, float[] pafSource)
  {
    copy(patDestination, 0, pafSource, 0, pafSource.length);
  }

  /**
   * General copy-conversion method that copies N float elements
   * from an array of floats into array of integers.
   *
   * @param paiDestination destination array of integers
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pafSource source array of floats
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(int[] paiDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      paiDestination[piDestinationFrom + i] =(int)pafSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N float elements
   * from an array of floats into array of integers.
   *
   * @param paiDestination destination array of integers
   * @param pafSource source array of floats
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(int[] paiDestination, float[] pafSource, int piHowMany)
  {
    copy(paiDestination, 0, pafSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all float elements
   * from an array of floats into array of integers.
   *
   * @param paiDestination destination array of integers
   * @param pafSource source array of floats
   * @since 0.3.0.3
   */
  public static void copy(int[] paiDestination, float[] pafSource)
  {
    copy(paiDestination, 0, pafSource, 0, pafSource.length);
  }

  /**
   * General copy-conversion method that copies N float elements
   * from an array of floats into array of shorts.
   *
   * @param pasDestination destination array of shorts
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pafSource source array of floats
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(short[] pasDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pasDestination[piDestinationFrom + i] = (short)pafSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N float elements
   * from an array of floats into array of shorts.
   *
   * @param pasDestination destination array of shorts
   * @param pafSource source array of floats
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(short[] pasDestination, float[] pafSource, int piHowMany)
  {
    copy(pasDestination, 0, pafSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all float elements
   * from an array of floats into array of shorts.
   *
   * @param pasDestination destination array of shorts
   * @param pafSource source array of floats
   * @since 0.3.0.3
   */
  public static void copy(short[] pasDestination, float[] pafSource)
  {
    copy(pasDestination, 0, pafSource, 0, pafSource.length);
  }

  /**
   * General copy-conversion method that copies N float elements
   * from an array of floats into array of longs.
   *
   * @param palDestination destination array of longs
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pafSource source array of floats
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      palDestination[piDestinationFrom + i] =(long)pafSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N float elements
   * from an array of floats into array of longs.
   *
   * @param palDestination destination array of longs
   * @param pafSource source array of floats
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, float[] pafSource, int piHowMany)
  {
    copy(palDestination, 0, pafSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all float elements
   * from an array of floats into array of longs.
   *
   * @param palDestination destination array of longs
   * @param pafSource source array of floats
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, float[] pafSource)
  {
    copy(palDestination, 0, pafSource, 0, pafSource.length);
  }

  /**
   * General copy-conversion method that copies N float elements
   * from an array of floats into array of doubles.
   *
   * @param padDestination destination array of doubles
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pafSource source array of floats
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(double[] padDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      padDestination[piDestinationFrom + i] = pafSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N float elements
   * from an array of floats into array of doubles.
   *
   * @param padDestination destination array of doubles
   * @param pafSource source array of floats
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(double[] padDestination, float[] pafSource, int piHowMany)
  {
    copy(padDestination, 0, pafSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all float elements
   * from an array of floats into array of doubles.
   *
   * @param padDestination destination array of doubles
   * @param pafSource source array of floats
   * @since 0.3.0.3
   */
  public static void copy(double[] padDestination, float[] pafSource)
  {
    copy(padDestination, 0, pafSource, 0, pafSource.length);
  }

  /**
   * General copy-conversion method that copies N short elements
   * from an array of shorts into array of doubles.
   *
   * @param padDestination destination array of doubles
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pasSource source array of shorts
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(double[] padDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      padDestination[piDestinationFrom + i] = pasSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N short elements
   * from an array of shorts into array of doubles.
   *
   * @param padDestination destination array of doubles
   * @param pasSource source array of shorts
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(double[] padDestination, short[] pasSource, int piHowMany)
  {
    copy(padDestination, 0, pasSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all short elements
   * from an array of shorts into array of doubles.
   *
   * @param padDestination destination array of doubles
   * @param pasSource source array of shorts
   * @since 0.3.0.3
   */
  public static void copy(double[] padDestination, short[] pasSource)
  {
    copy(padDestination, 0, pasSource, 0, pasSource.length);
  }

  /**
   * General copy-conversion method that copies N short elements
   * from an array of shorts into array of characters.
   *
   * @param pacDestination destination array of characters
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pasSource source array of shorts
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(char[] pacDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pacDestination[piDestinationFrom + i] = (char)pasSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N short elements
   * from an array of shorts into array of characters.
   *
   * @param pacDestination destination array of characters
   * @param pasSource source array of shorts
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(char[] pacDestination, short[] pasSource, int piHowMany)
  {
    copy(pacDestination, 0, pasSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all short elements
   * from an array of shorts into array of characters.
   *
   * @param pacDestination destination array of characters
   * @param pasSource source array of shorts
   * @since 0.3.0.3
   */
  public static void copy(char[] pacDestination, short[] pasSource)
  {
    copy(pacDestination, 0, pasSource, 0, pasSource.length);
  }

  /**
   * General copy-conversion method that copies N short elements
   * from an array of shorts into array of bytes.
   *
   * @param patDestination destination array of bytes
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pasSource source array of shorts
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(byte[] patDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      patDestination[piDestinationFrom + i] =(byte)pasSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N short elements
   * from an array of shorts into array of bytes.
   *
   * @param patDestination destination array of bytes
   * @param pasSource source array of shorts
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(byte[] patDestination, short[] pasSource, int piHowMany)
  {
    copy(patDestination, 0, pasSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all short elements
   * from an array of shorts into array of bytes.
   *
   * @param patDestination destination array of bytes
   * @param pasSource source array of shorts
   * @since 0.3.0.3
   */
  public static void copy(byte[] patDestination, short[] pasSource)
  {
    copy(patDestination, 0, pasSource, 0, pasSource.length);
  }

  /**
   * General copy-conversion method that copies N short elements
   * from an array of shorts into array of integers.
   *
   * @param paiDestination destination array of integers
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pasSource source array of shorts
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(int[] paiDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      paiDestination[piDestinationFrom + i] = pasSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N short elements
   * from an array of shorts into array of integers.
   *
   * @param paiDestination destination array of integers
   * @param pasSource source array of shorts
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(int[] paiDestination, short[] pasSource, int piHowMany)
  {
    copy(paiDestination, 0, pasSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all short elements
   * from an array of shorts into array of integers.
   *
   * @param paiDestination destination array of integers
   * @param pasSource source array of shorts
   * @since 0.3.0.3
   */
  public static void copy(int[] paiDestination, short[] pasSource)
  {
    copy(paiDestination, 0, pasSource, 0, pasSource.length);
  }

  /**
   * General copy-conversion method that copies N short elements
   * from an array of shorts into array of floats.
   *
   * @param pafDestination destination array of floats
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pasSource source array of shorts
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(float[] pafDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pafDestination[piDestinationFrom + i] = pasSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N short elements
   * from an array of shorts into array of floats.
   *
   * @param pafDestination destination array of floats
   * @param pasSource source array of shorts
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(float[] pafDestination, short[] pasSource, int piHowMany)
  {
    copy(pafDestination, 0, pasSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all short elements
   * from an array of shorts into array of floats.
   *
   * @param pafDestination destination array of floats
   * @param pasSource source array of shorts
   * @since 0.3.0.3
   */
  public static void copy(float[] pafDestination, short[] pasSource)
  {
    copy(pafDestination, 0, pasSource, 0, pasSource.length);
  }

  /**
   * General copy-conversion method that copies N short elements
   * from an array of shorts into array of longs.
   *
   * @param palDestination destination array of longs
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pasSource source array of shorts
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      palDestination[piDestinationFrom + i] = pasSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N short elements
   * from an array of shorts into array of longs.
   *
   * @param palDestination destination array of longs
   * @param pasSource source array of shorts
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, short[] pasSource, int piHowMany)
  {
    copy(palDestination, 0, pasSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all short elements
   * from an array of shorts into array of longs.
   *
   * @param palDestination destination array of longs
   * @param pasSource source array of shorts
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, short[] pasSource)
  {
    copy(palDestination, 0, pasSource, 0, pasSource.length);
  }

  /**
   * General copy-conversion method that copies N byte elements
   * from an array of bytes into array of longs.
   *
   * @param palDestination destination array of longs
   * @param piDestinationFrom index in the destination to start place elements at
   * @param patSource source array of bytes
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      palDestination[piDestinationFrom + i] = patSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N byte elements
   * from an array of bytes into array of longs.
   *
   * @param palDestination destination array of longs
   * @param patSource source array of bytes
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, byte[] patSource, int piHowMany)
  {
    copy(palDestination, 0, patSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all byte elements
   * from an array of bytes into array of longs.
   *
   * @param palDestination destination array of longs
   * @param patSource source array of bytes
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, byte[] patSource)
  {
    copy(palDestination, 0, patSource, 0, patSource.length);
  }

  /**
   * General copy-conversion method that copies N byte elements
   * from an array of bytes into array of doubles.
   *
   * @param padDestination destination array of doubles
   * @param piDestinationFrom index in the destination to start place elements at
   * @param patSource source array of bytes
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(double[] padDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      padDestination[piDestinationFrom + i] = patSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N byte elements
   * from an array of bytes into array of doubles.
   *
   * @param padDestination destination array of doubles
   * @param patSource source array of bytes
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(double[] padDestination, byte[] patSource, int piHowMany)
  {
    copy(padDestination, 0, patSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all byte elements
   * from an array of bytes into array of doubles.
   *
   * @param padDestination destination array of doubles
   * @param patSource source array of bytes
   * @since 0.3.0.3
   */
  public static void copy(double[] padDestination, byte[] patSource)
  {
    copy(padDestination, 0, patSource, 0, patSource.length);
  }

  /**
   * General copy-conversion method that copies N byte elements
   * from an array of bytes into array of shorts.
   *
   * @param pasDestination destination array of shorts
   * @param piDestinationFrom index in the destination to start place elements at
   * @param patSource source array of bytes
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(short[] pasDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pasDestination[piDestinationFrom + i] = patSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N byte elements
   * from an array of bytes into array of shorts.
   *
   * @param pasDestination destination array of shorts
   * @param patSource source array of bytes
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(short[] pasDestination, byte[] patSource, int piHowMany)
  {
    copy(pasDestination, 0, patSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all byte elements
   * from an array of bytes into array of shorts.
   *
   * @param pasDestination destination array of shorts
   * @param patSource source array of bytes
   * @since 0.3.0.3
   */
  public static void copy(short[] pasDestination, byte[] patSource)
  {
    copy(pasDestination, 0, patSource, 0, patSource.length);
  }

  /**
   * General copy-conversion method that copies N byte elements
   * from an array of bytes into array of floats.
   *
   * @param pafDestination destination array of floats
   * @param piDestinationFrom index in the destination to start place elements at
   * @param patSource source array of bytes
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(float[] pafDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pafDestination[piDestinationFrom + i] = patSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N byte elements
   * from an array of bytes into array of floats.
   *
   * @param pafDestination destination array of floats
   * @param patSource source array of bytes
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(float[] pafDestination, byte[] patSource, int piHowMany)
  {
    copy(pafDestination, 0, patSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all byte elements
   * from an array of bytes into array of floats.
   *
   * @param pafDestination destination array of floats
   * @param patSource source array of bytes
   * @since 0.3.0.3
   */
  public static void copy(float[] pafDestination, byte[] patSource)
  {
    copy(pafDestination, 0, patSource, 0, patSource.length);
  }

  /**
   * General copy-conversion method that copies N byte elements
   * from an array of bytes into array of characters.
   *
   * @param pacDestination destination array of characters
   * @param piDestinationFrom index in the destination to start place elements at
   * @param patSource source array of bytes
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(char[] pacDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pacDestination[piDestinationFrom + i] = (char)patSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N byte elements
   * from an array of bytes into array of characters.
   *
   * @param pacDestination destination array of characters
   * @param patSource source array of bytes
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(char[] pacDestination, byte[] patSource, int piHowMany)
  {
    copy(pacDestination, 0, patSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all byte elements
   * from an array of bytes into array of bytes.
   *
   * @param pacDestination destination array of characters
   * @param patSource source array of bytes
   * @since 0.3.0.3
   */
  public static void copy(char[] pacDestination, byte[] patSource)
  {
    copy(pacDestination, 0, patSource, 0, patSource.length);
  }

  /**
   * General copy-conversion method that copies N byte elements
   * from an array of bytes into array of integers.
   *
   * @param paiDestination destination array of integers
   * @param piDestinationFrom index in the destination to start place elements at
   * @param patSource source array of bytes
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(int[] paiDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      paiDestination[piDestinationFrom + i] = patSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N byte elements
   * from an array of bytes into array of integers.
   *
   * @param paiDestination destination array of integers
   * @param patSource source array of bytes
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(int[] paiDestination, byte[] patSource, int piHowMany)
  {
    copy(paiDestination, 0, patSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all byte elements
   * from an array of bytes into array of integers.
   *
   * @param paiDestination destination array of integers
   * @param patSource source array of bytes
   * @since 0.3.0.3
   */
  public static void copy(int[] paiDestination, byte[] patSource)
  {
    copy(paiDestination, 0, patSource, 0, patSource.length);
  }

  /**
   * General copy-conversion method that copies N character elements
   * from an array of characters into array of integers.
   *
   * @param paiDestination destination array of integers
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pacSource source array of characters
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(int[] paiDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      paiDestination[piDestinationFrom + i] = pacSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N character elements
   * from an array of characters into array of integers.
   *
   * @param paiDestination destination array of integers
   * @param pacSource source array of characters
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(int[] paiDestination, char[] pacSource, int piHowMany)
  {
    copy(paiDestination, 0, pacSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all character elements
   * from an array of characters into array of integers.
   *
   * @param paiDestination destination array of integers
   * @param pacSource source array of characters
   * @since 0.3.0.3
   */
  public static void copy(int[] paiDestination, char[] pacSource)
  {
    copy(paiDestination, 0, pacSource, 0, pacSource.length);
  }

  /**
   * General copy-conversion method that copies N character elements
   * from an array of characters into array of bytes.
   *
   * @param patDestination destination array of bytes
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pacSource source array of characters
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(byte[] patDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      patDestination[piDestinationFrom + i] = (byte)pacSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N character elements
   * from an array of characters into array of bytes.
   *
   * @param patDestination destination array of bytes
   * @param pacSource source array of characters
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(byte[] patDestination, char[] pacSource, int piHowMany)
  {
    copy(patDestination, 0, pacSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all character elements
   * from an array of characters into array of bytes.
   *
   * @param patDestination destination array of bytes
   * @param pacSource source array of characters
   * @since 0.3.0.3
   */
  public static void copy(byte[] patDestination, char[] pacSource)
  {
    copy(patDestination, 0, pacSource, 0, pacSource.length);
  }

  /**
   * General copy-conversion method that copies N character elements
   * from an array of characters into array of shorts.
   *
   * @param pasDestination destination array of shorts
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pacSource source array of characters
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(short[] pasDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pasDestination[piDestinationFrom + i] = (short)pacSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N character elements
   * from an array of characters into array of shorts.
   *
   * @param pasDestination destination array of shorts
   * @param pacSource source array of characters
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(short[] pasDestination, char[] pacSource, int piHowMany)
  {
    copy(pasDestination, 0, pacSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all character elements
   * from an array of characters into array of shorts.
   *
   * @param pasDestination destination array of shorts
   * @param pacSource source array of characters
   * @since 0.3.0.3
   */
  public static void copy(short[] pasDestination, char[] pacSource)
  {
    copy(pasDestination, 0, pacSource, 0, pacSource.length);
  }

  /**
   * General copy-conversion method that copies N character elements
   * from an array of characters into array of longs.
   *
   * @param palDestination destination array of longs
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pacSource source array of characters
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      palDestination[piDestinationFrom + i] = pacSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N character elements
   * from an array of characters into array of longs.
   *
   * @param palDestination destination array of longs
   * @param pacSource source array of characters
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, char[] pacSource, int piHowMany)
  {
    copy(palDestination, 0, pacSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all character elements
   * from an array of characters into array of longs.
   *
   * @param palDestination destination array of longs
   * @param pacSource source array of characters
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, char[] pacSource)
  {
    copy(palDestination, 0, pacSource, 0, pacSource.length);
  }

  /**
   * General copy-conversion method that copies N character elements
   * from an array of characters into array of floats.
   *
   * @param pafDestination destination array of floats
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pacSource source array of characters
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(float[] pafDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pafDestination[piDestinationFrom + i] = pacSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N character elements
   * from an array of characters into array of floats.
   *
   * @param pafDestination destination array of floats
   * @param pacSource source array of characters
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(float[] pafDestination, char[] pacSource, int piHowMany)
  {
    copy(pafDestination, 0, pacSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all character elements
   * from an array of characters into array of floats.
   *
   * @param pafDestination destination array of floats
   * @param pacSource source array of characters
   * @since 0.3.0.3
   */
  public static void copy(float[] pafDestination, char[] pacSource)
  {
    copy(pafDestination, 0, pacSource, 0, pacSource.length);
  }

  /**
   * General copy-conversion method that copies N character elements
   * from an array of characters into array of doubles.
   *
   * @param padDestination destination array of doubles
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pacSource source array of characters
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(double[] padDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      padDestination[piDestinationFrom + i] = pacSource[piSourceFrom + i];
  }

  /**
   * Copy-conversion method that copies N character elements
   * from an array of characters into array of doubles.
   *
   * @param padDestination destination array of doubles
   * @param pacSource source array of characters
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(double[] padDestination, char[] pacSource, int piHowMany)
  {
    copy(padDestination, 0, pacSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all character elements
   * from an array of characters into array of doubles.
   *
   * @param padDestination destination array of doubles
   * @param pacSource source array of characters
   * @since 0.3.0.3
   */
  public static void copy(double[] padDestination, char[] pacSource)
  {
    copy(padDestination, 0, pacSource, 0, pacSource.length);
  }

  /**
   * General copy-conversion method that copies N int elements
   * from an array of ints into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param piDestinationFrom index in the destination to start place elements at
   * @param paiSource source array of ints
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pstrDestination[piDestinationFrom + i] = paiSource[piSourceFrom + i] + "";
  }

  /**
   * Copy-conversion method that copies N int elements
   * from an array of ints into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param paiSource source array of ints
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, int[] paiSource, int piHowMany)
  {
    copy(pstrDestination, 0, paiSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all int elements
   * from an array of ints into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param paiSource source array of ints
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, int[] paiSource)
  {
    copy(pstrDestination, 0, paiSource, 0, paiSource.length);
  }

  /**
   * General copy-conversion method that copies N char elements
   * from an array of chars into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pacSource source array of chars
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pstrDestination[piDestinationFrom + i] = pacSource[piSourceFrom + i] + "";
  }

  /**
   * Copy-conversion method that copies N char elements
   * from an array of chars into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param pacSource source array of chars
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, char[] pacSource, int piHowMany)
  {
    copy(pstrDestination, 0, pacSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all char elements
   * from an array of chars into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param pacSource source array of chars
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, char[] pacSource)
  {
    copy(pstrDestination, 0, pacSource, 0, pacSource.length);
  }

  /**
   * General copy-conversion method that copies N byte elements
   * from an array of bytes into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param piDestinationFrom index in the destination to start place elements at
   * @param patSource source array of bytes
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pstrDestination[piDestinationFrom + i] = patSource[piSourceFrom + i] + "";
  }

  /**
   * Copy-conversion method that copies N byte elements
   * from an array of bytes into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param patSource source array of bytes
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, byte[] patSource, int piHowMany)
  {
    copy(pstrDestination, 0, patSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all byte elements
   * from an array of ints into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param patSource source array of bytes
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, byte[] patSource)
  {
    copy(pstrDestination, 0, patSource, 0, patSource.length);
  }

  /**
   * General copy-conversion method that copies N short elements
   * from an array of shorts into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pasSource source array of shorts
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pstrDestination[piDestinationFrom + i] = pasSource[piSourceFrom + i] + "";
  }

  /**
   * Copy-conversion method that copies N short elements
   * from an array of shorts into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param patSource source array of shorts
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, short[] patSource, int piHowMany)
  {
    copy(pstrDestination, 0, patSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all short elements
   * from an array of shorts into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param pasSource source array of shorts
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, short[] pasSource)
  {
    copy(pstrDestination, 0, pasSource, 0, pasSource.length);
  }

  /**
   * General copy-conversion method that copies N long elements
   * from an array of longs into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param piDestinationFrom index in the destination to start place elements at
   * @param palSource source array of longs
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, int piDestinationFrom, long[] palSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pstrDestination[piDestinationFrom + i] = palSource[piSourceFrom + i] + "";
  }

  /**
   * Copy-conversion method that copies N long elements
   * from an array of longs into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param palSource source array of longs
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, long[] palSource, int piHowMany)
  {
    copy(pstrDestination, 0, palSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all long elements
   * from an array of longs into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param palSource source array of longs
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, long[] palSource)
  {
    copy(pstrDestination, 0, palSource, 0, palSource.length);
  }

  /**
   * General copy-conversion method that copies N float elements
   * from an array of floats into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pafSource source array of floats
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pstrDestination[piDestinationFrom + i] = pafSource[piSourceFrom + i] + "";
  }

  /**
   * Copy-conversion method that copies N float elements
   * from an array of floats into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param pafSource source array of floats
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, float[] pafSource, int piHowMany)
  {
    copy(pstrDestination, 0, pafSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all float elements
   * from an array of floats into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param pafSource source array of floats
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, float[] pafSource)
  {
    copy(pstrDestination, 0, pafSource, 0, pafSource.length);
  }

  /**
   * General copy-conversion method that copies N double elements
   * from an array of doubles into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param piDestinationFrom index in the destination to start place elements at
   * @param padSource source array of doubles
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pstrDestination[piDestinationFrom + i] = padSource[piSourceFrom + i] + "";
  }

  /**
   * Copy-conversion method that copies N double elements
   * from an array of doubles into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param padSource source array of doubles
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, double[] padSource, int piHowMany)
  {
    copy(pstrDestination, 0, padSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all double elements
   * from an array of doubles into array of Strings.
   *
   * @param pstrDestination destination array of Strings
   * @param padSource source array of doubles
   * @since 0.3.0.3
   */
  public static void copy(String[] pstrDestination, double[] padSource)
  {
    copy(pstrDestination, 0, padSource, 0, padSource.length);
  }

  /**
   * General copy-conversion method that copies N String elements
   * from an array of Strings into array of doubles.
   *
   * @param padDestination destination array of doubles
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pastrSource source array of Strings
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   *
   * @throws NumberFormatException if one of the Strings doesn't have a properly formatted number
   * @since 0.3.0.3
   */
  public static void copy(double[] padDestination, int piDestinationFrom, String[] pastrSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      padDestination[piDestinationFrom + i] = Double.parseDouble(pastrSource[piSourceFrom + i]);
  }

  /**
   * Copy-conversion method that copies N String elements
   * from an array of Strings into array of doubles.
   *
   * @param padDestination destination array of doubles
   * @param pastrSource source array of Strings
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(double[] padDestination, String[] pastrSource, int piHowMany)
  {
    copy(padDestination, 0, pastrSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all String elements
   * from an array of Strings into array of doubles.
   *
   * @param padDestination destination array of doubles
   * @param pastrSource source array of Strings
   * @since 0.3.0.3
   */
  public static void copy(double[] padDestination, String[] pastrSource)
  {
    copy(padDestination, 0, pastrSource, 0, pastrSource.length);
  }

  /**
   * General copy-conversion method that copies N String elements
   * from an array of Strings into array of floats.
   *
   * @param pafDestination destination array of floats
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pastrSource source array of Strings
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   *
   * @throws NumberFormatException if one of the Strings doesn't have a properly formatted number
   * @since 0.3.0.3
   */
  public static void copy(float[] pafDestination, int piDestinationFrom, String[] pastrSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pafDestination[piDestinationFrom + i] = Float.parseFloat(pastrSource[piSourceFrom + i]);
  }

  /**
   * Copy-conversion method that copies N String elements
   * from an array of Strings into array of floats.
   *
   * @param pafDestination destination array of floats
   * @param pastrSource source array of Strings
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(float[] pafDestination, String[] pastrSource, int piHowMany)
  {
    copy(pafDestination, 0, pastrSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all String elements
   * from an array of Strings into array of floats.
   *
   * @param pafDestination destination array of floats
   * @param pastrSource source array of Strings
   */
  public static void copy(float[] pafDestination, String[] pastrSource)
  {
    copy(pafDestination, 0, pastrSource, 0, pastrSource.length);
  }

  /**
   * General copy-conversion method that copies N String elements
   * from an array of Strings into array of longs.
   *
   * @param palDestination destination array of longs
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pastrSource source array of Strings
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   *
   * @throws NumberFormatException if one of the Strings doesn't have a properly formatted number
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, int piDestinationFrom, String[] pastrSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      palDestination[piDestinationFrom + i] = Long.parseLong(pastrSource[piSourceFrom + i]);
  }

  /**
   * Copy-conversion method that copies N String elements
   * from an array of Strings into array of longs.
   *
   * @param palDestination destination array of longs
   * @param pastrSource source array of Strings
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, String[] pastrSource, int piHowMany)
  {
    copy(palDestination, 0, pastrSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all String elements
   * from an array of Strings into array of longs.
   *
   * @param palDestination destination array of longs
   * @param pastrSource source array of Strings
   * @since 0.3.0.3
   */
  public static void copy(long[] palDestination, String[] pastrSource)
  {
    copy(palDestination, 0, pastrSource, 0, pastrSource.length);
  }

  /**
   * General copy-conversion method that copies N String elements
   * from an array of Strings into array of integers.
   *
   * @param paiDestination destination array of integers
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pastrSource source array of Strings
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   *
   * @throws NumberFormatException if one of the Strings doesn't have a properly formatted number
   * @since 0.3.0.3
   */
  public static void copy(int[] paiDestination, int piDestinationFrom, String[] pastrSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      paiDestination[piDestinationFrom + i] = Integer.parseInt(pastrSource[piSourceFrom + i]);
  }

  /**
   * Copy-conversion method that copies N String elements
   * from an array of Strings into array of integers.
   *
   * @param paiDestination destination array of integers
   * @param pastrSource source array of Strings
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(int[] paiDestination, String[] pastrSource, int piHowMany)
  {
    copy(paiDestination, 0, pastrSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all String elements
   * from an array of Strings into array of integers.
   *
   * @param paiDestination destination array of integers
   * @param pastrSource source array of Strings
   * @since 0.3.0.3
   */
  public static void copy(int[] paiDestination, String[] pastrSource)
  {
    copy(paiDestination, 0, pastrSource, 0, pastrSource.length);
  }

  /**
   * General copy-conversion method that copies N String elements
   * from an array of Strings into array of shorts.
   *
   * @param pasDestination destination array of shorts
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pastrSource source array of Strings
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   *
   * @throws NumberFormatException if one of the Strings doesn't have a properly formatted number
   * @since 0.3.0.3
   */
  public static void copy(short[] pasDestination, int piDestinationFrom, String[] pastrSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      pasDestination[piDestinationFrom + i] = Short.parseShort(pastrSource[piSourceFrom + i]);
  }

  /**
   * Copy-conversion method that copies N String elements
   * from an array of Strings into array of shorts.
   *
   * @param pasDestination destination array of shorts
   * @param pastrSource source array of Strings
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(short[] pasDestination, String[] pastrSource, int piHowMany)
  {
    copy(pasDestination, 0, pastrSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all String elements
   * from an array of Strings into array of shorts.
   *
   * @param pasDestination destination array of shorts
   * @param pastrSource source array of Strings
   * @since 0.3.0.3
   */
  public static void copy(short[] pasDestination, String[] pastrSource)
  {
    copy(pasDestination, 0, pastrSource, 0, pastrSource.length);
  }

  /**
   * General copy-conversion method that copies N String elements
   * from an array of Strings into array of bytes.
   *
   * @param patDestination destination array of bytes
   * @param piDestinationFrom index in the destination to start place elements at
   * @param pastrSource source array of Strings
   * @param piSourceFrom index in the source to start take elements from
   * @param piHowMany N; how many elements to copy
   *
   * @throws NumberFormatException if one of the Strings doesn't have a properly formatted number
   * @since 0.3.0.3
   */
  public static void copy(byte[] patDestination, int piDestinationFrom, String[] pastrSource, int piSourceFrom, int piHowMany)
  {
    for(int i = 0; i < piHowMany; i++)
      patDestination[piDestinationFrom + i] = Byte.parseByte(pastrSource[piSourceFrom + i]);
  }

  /**
   * Copy-conversion method that copies N String elements
   * from an array of Strings into array of bytes.
   *
   * @param patDestination destination array of bytes
   * @param pastrSource source array of Strings
   * @param piHowMany N; how many elements to copy
   * @since 0.3.0.3
   */
  public static void copy(byte[] patDestination, String[] pastrSource, int piHowMany)
  {
    copy(patDestination, 0, pastrSource, 0, piHowMany);
  }

  /**
   * Copy-conversion method that copies all String elements
   * from an array of Strings into array of bytes.
   *
   * @param patDestination destination array of bytes
   * @param pastrSource source array of Strings
   * @since 0.3.0.3
   */
  public static void copy(byte[] patDestination, String[] pastrSource)
  {
    copy(patDestination, 0, pastrSource, 0, pastrSource.length);
  }

  /*
   * -------------
   * Binary Search
   * -------------
   */

  /**
   * The <code>binarySearch()</code> routine is based on <code>java.util.Arrays.binarySearch()</code>.
   *
   * @param pafArray the array of floats to be searched
   * @param pfValue the value of float to be searched in the array of floats
   * @return index of the searched value if it is in the array of floats
   * @since 0.3.0.3
   */
  public static int binarySearch(float[] pafArray, float pfValue)
  {
    return java.util.Arrays.binarySearch(pafArray, pfValue);
  }

  /**
   * The <code>binarySearch()</code> routine is based on <code>java.util.Arrays.binarySearch()</code>.
   *
   * @param padArray the array of doubles to be searched
   * @param pdValue the value of double to be searched in the array of doubles
   * @return index of the searched value if it is in the array of doubles
   * @since 0.3.0.3
   */
  public static int binarySearch(double[] padArray, double pdValue)
  {
    return java.util.Arrays.binarySearch(padArray, pdValue);
  }

  /**
   * The <code>binarySearch()</code> routine is based on <code>java.util.Arrays.binarySearch()</code>.
   *
   * @param pasArray the array of shorts to be searched
   * @param psValue the value of shorts to be searched in the array of shorts
   * @return index of the searched value if it is in the array of shorts
   * @since 0.3.0.3
   */
  public static int binarySearch(short[] pasArray, short psValue)
  {
    return java.util.Arrays.binarySearch(pasArray, psValue);
  }

  /**
   * The <code>binarySearch()</code> routine is based on <code>java.util.Arrays.binarySearch()</code>.
   *
   * @param paiArray the array of integers to be searched
   * @param piValue the value of integer to be searched in the array of integers
   * @return index of the searched value if it is in the array of integers
   * @since 0.3.0.3
   */
  public static int binarySearch(int[] paiArray, int piValue)
  {
    return java.util.Arrays.binarySearch(paiArray, piValue);
  }

  /**
   * The <code>binarySearch()</code> routine is based on <code>java.util.Arrays.binarySearch()</code>.
   *
   * @param patArray the array of bytes to be searched
   * @param ptValue the value of byte to be searched in the array of bytes
   * @return index of the searched value if it is in the array of bytes
   * @since 0.3.0.3
   */
  public static int binarySearch(byte[] patArray, byte ptValue)
  {
    return java.util.Arrays.binarySearch(patArray, ptValue);
  }

  /**
   * The <code>binarySearch()</code> routine is based on <code>java.util.Arrays.binarySearch()</code>.
   *
   * @param pacArray the array of characters to be searched
   * @param pcValue the value of character to be searched in the array of characters
   * @return index of the searched value if it is in the array of characters
   * @since 0.3.0.3
   */
  public static int binarySearch(char[] pacArray, char pcValue)
  {
    return java.util.Arrays.binarySearch(pacArray, pcValue);
  }

  /**
   * The <code>binarySearch()</code> routine is based on <code>java.util.Arrays.binarySearch()</code>.
   *
   * @param paoArray the array of objects to be searched
   * @param poValue the value of object to be searched in the array of objects
   * @return index of the searched value if it is in the array of objects
   * @throws ClassCastException if the type of the searched value is not match the type of the array
   * @since 0.3.0.3
   */
  public static int binarySearch(Object[] paoArray, Object poValue)
  {
    return java.util.Arrays.binarySearch(paoArray, poValue);
  }

  /**
   * The <code>binarySearch()</code> routine is based on <code>java.util.Arrays.binarySearch()</code>.
   *
   * @param paoArray the array of objects to be searched
   * @param poValue the value of object to be searched in the array of objects
   * @param poComparator the comparator to decide the order of the array
   * @return index of the searched value if it is in the array of objects
   * @throws ClassCastException if the type of the searched value is not match the type of the array
   * @since 0.3.0.3
   */
  public static int binarySearch(Object[] paoArray, Object poValue, Comparator poComparator)
  {
    return java.util.Arrays.binarySearch(paoArray, poValue, poComparator);
  }

  /*
   * ----
   * Misc
   * ----
   */

  /**
   * Returns source code revision information.
   *
   * @return revision string
   * @since 0.3.0.2
   */
  public static String getMARFSourceCodeRevision()
  {
    return "$Revision: 1.38 $";
  }
}

// EOF

   
    
    
    
    
    
  








Related examples in the same category

1.Adds all the elements of the given arrays into a new boolean-value array.
2.Adds all the elements of the given arrays into a new byte-type array.
3.Adds all the elements of the given arrays into a new char-type array.
4.Adds all the elements of the given arrays into a new double-type array.
5.Adds all the elements of the given arrays into a new float-type array.
6.Adds all the elements of the given arrays into a new int-type array.
7.Adds all the elements of the given arrays into a new long-type array.
8.Adds all the elements of the given arrays into a new short-type array.
9.Copies the given array and adds the given element at the end of the new array. (char type value)
10.Copies the given array and adds the given element at the end of the new array. (float type value)
11.Copies the given array and adds the given element at the end of the new array. (long value type)
12.Copies the given array and adds the given element at the end of the new array. (object value type)
13.Copies the given array and adds the given element at the end of the new array.(boolean value type)
14.Copies the given array and adds the given element at the end of the new array.(byte value type)
15.Copies the given array and adds the given element at the end of the new array.(double type value)
16.Copies the given array and adds the given element at the end of the new array.(int value type)
17.Copies the given array and adds the given element at the end of the new array.(short type array)
18.Inserts the specified element at the specified position in the array.
19.Inserts the specified element at the specified position in the boolean-type-value array.
20.Inserts the specified element at the specified position in the byte-type-value array.
21.Inserts the specified element at the specified position in the char-type-value array.
22.Inserts the specified element at the specified position in the double-type-value array.
23.Inserts the specified element at the specified position in the float-value-type array.
24.Inserts the specified element at the specified position in the int-type-value array.
25.Inserts the specified element at the specified position in the long-type-value array.
26.Inserts the specified element at the specified position in the short-value-type array.
27.Removes the element at the specified position from the specified array.
28.Removes the element at the specified position from the specified long type array.
29.Removes the first occurrence of the specified element from the specified array.
30.Removes the first occurrence of the specified element from the specified long value array.
31.Insert value to array
32.Concatenate Java arrays
33.This program demonstrates array manipulation.
34.Appends an Object to an Object array.
35.Appends an integer to an integer array.
36.Inserts an Object into an Object array at the index position.
37.Prepends an Object to an Object array.
38.Removes an Object from an Object array.
39.Removes duplicate elements from the array
40.Creates a new subarray from a larger array.
41.Append one array to another
42.Array Expander
43.Array Util: seach, insert, append, remove, copy, shuffle
44.Add new value to exsisting array.The new value is indexed to the last.
45.Add new value, which sets as the first value, to existing array.
46.Add one array to another
47.Concatenates all the passed arrays
48.Returns a copy of the specified array of objects of the specified size.
49.Pack chunks
50.Removes an element from a an array yielding a new array with that data.