Logo
Distributed Genetic Programming Framework
print print

File org.sfc.collections.Arrays.java

Here you can find all the information about the file org.sfc.collections.Arrays.java. You may explore it here or download it onto your local disk.
/*
 * Copyright (c) 2005 Thomas Weise
 *
 * E-Mail           : tweise@gmx.de
 * Creation Date    : 2005-09-30 06:31:23
 * Original Filename: org.sfc.collections.Arrays.java
 * Version          : 2.0.0
 * Last modification: 2006-04-10
 *                by: Thomas Weise
 *
 * License          : GNU LESSER GENERAL PUBLIC LICENSE
 *                    Version 2.1, February 1999
 *                    You should have received a copy of this license along
 *                    with this library; if not, write to the Free Software
 *                    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *                    MA 02111-1307, USA or download the license under
 *                    http://www.gnu.org/copyleft/lesser.html.
 *
 * Warranty         : This software is provided "as is" without any
 *                    warranty; without even the implied warranty of
 *                    merchantability or fitness for a particular purpose.
 *                    See the Gnu Lesser General Public License for more
 *                    details.
 */


package org.sfc.collections;

import java.lang.reflect.Array;
import java.util.Comparator;

import org.sfc.math.Mathematics;
import org.sfc.utils.Typesafe;


/**
 * The array helper functions.
 *
 * @author Thomas Weise
 */

public final  class Arrays
  {
/**
 * The empty class array.
 */

  public  static  final Class[]     EMPTY_CLASS_ARRAY = new Class[0];
/**
 * The empty object array.
 */

  public  static  final Object[]    EMPTY_OBJECT_ARRAY = EMPTY_CLASS_ARRAY;
  
/**
 * The hidden constructor.
 */

  private Arrays  ()
    {
    Typesafe.do_not_call();
    }

/**
 * Copy only the array item contents from <code>p_source</code> to
 * <code>p_dest</code>. This method is especial usefull when treating
 * multi-dimensional arrays. Only the contents of the inner-most arrays
 * will then be copied, ie. no array objects are copied, only the data
 * they contain.
 * @param p_source  The source array.
 * @param p_dest    The destination array.
 * @param <T>       The type of <code>p_source</code> and
 *                  <code>p_dest</code>, which must be an array type.
 */

  public static final <T> void array_data_copy (final T p_source,
                                                final T p_dest)
    {
    int l_c;

    l_c = Math.min(Array.getLength(p_source), Array.getLength(p_dest));

    if(p_source.getClass().getComponentType().isArray())
      {
      for(--l_c; l_c >= 0; l_c--)
        {
        array_data_copy(Array.get(p_source, l_c), Array.get(p_dest, l_c));
        }
      }
    else
      {
      System.arraycopy(p_source, 0, p_dest, 0, l_c);
      }
    }

/**
 * Create a <code>p_class</code>-typed array of the specified length.
 * @param p_class   The class object used for array creation.
 * @param p_length  The desired length of the array.
 * @param <T>       The type of the array's items.
 * @param <Q>       The type of the array's items.
 * @return  The new array.
 */

  public static final <T, Q extends T> Q[] create(final Class<T> p_class,
                                                  final int      p_length)
    {
    return Typesafe.cast(Array.newInstance(p_class, p_length));
    }


/**
 * Create a new typed array
 * @param p_params  The passed in array data.
 * @param <T>       The type of the array's items.
 * @param <Q>       The type of the array's items.
 * @return  The new array.
 */

  public static final <T, Q extends T> Q[] create(T ... p_params)
    {
    return Typesafe.cast(p_params);
    }



/**
 * Create free space to insert some elements into an array.
 * The array might be of any type, even int or boolean or such and such
 * will work. The resulting array may have more slots than actually
 * required, optimized for continuos modification performance.
 * @param p_array     The array object where to create free spaces.
 * @param p_count     The count of valid elements inside
 *                    <code>p_array</code>.
 * @param p_position  The position where to create free slots.
 *                    The contents of this free slots will be undefined.
 * @param p_insert    The array which items should be inserted.
 * @param p_insert_count  The count of valid items in <code>p_insert</code>.
 * @param <T>         The type of <code>p_array</code> and
 *                    <code>p_insert</code>. This must be an array-type.
 * @return  An array containing the contents of <code>p_array</code>
 *          correctly re-arranged and with the valid contents of
 *          <code>p_insert</code> inserted. <code>p_array</code> is not
 *          valid any longer after you called this method. You must only
 *          use the return value of this method in any further processing.
 * @see #insert_space(Object, int, int, int)
 */

  public  static  final <T> T insert_array  (      T    p_array,
                                             final int  p_count,
                                             final int  p_position,
                                             final T    p_insert,
                                             final int  p_insert_count)
    {
    if(p_insert_count <= 0) return p_array;

    p_array = insert_space(p_array, p_count, p_position, p_insert_count);
    System.arraycopy(p_insert, 0, p_array, p_position, p_insert_count);

    return p_array;
    }

/**
 * Create free space to insert some elements into an array.
 * The array might be of any type, even int or boolean or such and such
 * will work. The resulting array has exactly the needed size.
 * @param p_array     The array object where to create free spaces.
 * @param p_position  The position where to create free slots.
 *                    The contents of this free slots will be undefined.
 * @param p_insert    The array which items should be inserted.
 * @param <T>         The type of <code>p_array</code> and
 *                    <code>p_insert</code>. This must be an array-type.
 * @return  An array containing the contents of <code>p_array</code>
 *          correctly re-arranged and with the valid contents of
 *          <code>p_insert</code> inserted. <code>p_array</code> is not
 *          valid any longer after you called this method. You must only
 *          use the return value of this method in any further processing.
 * @see #insert_space_direct(Object, int, int)
 */

  public  static  final <T> T insert_array_direct(      T    p_array,
                                                  final int  p_position,
                                                  final T    p_insert)
    {
    int l_l;

    if( (p_insert == null) ||
        ((l_l = Array.getLength(p_insert)) <= 0) ) return p_array;

    p_array = insert_space_direct(p_array, p_position, l_l);
    System.arraycopy(p_insert, 0, p_array, p_position, l_l);

    return p_array;
    }

/**
 * Create free space to insert some elements into an array.
 * The array might be of any type, even int or boolean or such and such
 * will work.
 * @param p_array     The array object where to create free spaces.
 * @param p_count     The count of valid elements inside
 *                    <code>p_array</code>.
 * @param p_position  The position where to create free slots.
 *                    The contents of this free slots will be undefined.
 * @param p_free      The count of free slots to create.
 * @param <T>         The type of <code>p_array</code>. This must be an
 *                    array-type.
 * @return  An array containing the contents of <code>p_array</code>
 *          correctly re-arranged. <code>p_array</code> is not valid any
 *          longer after you called this method. You must only use the
 *          return value of this method in any further processing.
 * @see #insert_space_direct(Object, int, int)
 */

  public  static  final <T> T insert_space  (final T    p_array,
                                             final int  p_count,
                                             final int  p_position,
                                             final int  p_free)
    {
    int     l_l, l_needed;
    T       l_na;

    l_l      = Array.getLength(p_array);
    l_needed = (p_count + p_free);

    if(l_needed > l_l)
      {
      l_needed  = (1 << (Mathematics.ld(l_needed) + 1));
      l_na      = Typesafe.cast(Array.newInstance(
                    p_array.getClass().getComponentType(), l_needed));
      System.arraycopy(p_array, 0, l_na, 0, p_position);

      }
    else l_na = p_array;

    System.arraycopy(p_array, p_position, l_na, p_position + p_free,
                       p_count - p_position);
    return l_na;
    }

/**
 * Create free space to insert some elements into an array.
 * The array might be of any type, even int or boolean or such and such
 * will work. This method creates a new array which has exactly the right
 * size to hold all the elements.
 * @param p_array     The array object where to create free spaces.
 * @param p_position  The position where to create free slots.
 *                    The contents of this free slots will be undefined.
 * @param p_free      The count of free slots to create.
 * @param <T>         The type of <code>p_array</code>. This must be an
 *                    array-type.
 * @return  An array containing the contents of <code>p_array</code>
 *          correctly re-arranged. <code>p_array</code> is not valid any
 *          longer after you called this method. You must only use the
 *          return value of this method in any further processing.
 * @see #insert_space(Object, int, int, int)
 */

  public  static  final <T> T insert_space_direct(final T    p_array,
                                                  final int  p_position,
                                                  final int  p_free)
    {
    int     l_l;
    T       l_na;

    if(p_free <= 0) return p_array;

    l_l  = Array.getLength(p_array);
    l_na = Typesafe.cast(Array.newInstance(
                  p_array.getClass().getComponentType(), l_l + p_free));

    System.arraycopy(p_array, 0, l_na, 0, p_position);
    System.arraycopy(p_array, p_position, l_na, p_position + p_free,
                       l_l - p_position);
    return l_na;
    }

/**
 * Delete some elements from an array while preserving the element order.
 * This method does not necessarily adjust the size of the array.
 * @param p_array     The array object where to delete elements.
 * @param p_count     The count of valid elements inside
 *                    <code>p_array</code>.
 * @param p_position  The position where to delete elements.
 * @param p_delete    The count of elements to be deleted.
 * @param <T>         The type of <code>p_array</code>. This must be an
 *                    array-type.
 * @return  An array containing the contents of <code>p_array</code>
 *          correctly re-arranged. <code>p_array</code> is not valid any
 *          longer after you called this method. You must only use the
 *          return value of this method in any further processing.
 * @see #delete_fast(Object, int, int, int)
 * @see #delete_direct(Object, int, int)
 */

  public  static  final <T> T delete        (final T    p_array,
                                             final int  p_count,
                                             final int  p_position,
                                             final int  p_delete)
    {
    int     l_l, l_needed;
    T       l_na;

    l_needed = (p_count - p_delete);
    l_l      = Array.getLength(p_array);

    if( (l_l > 512) && ((l_needed*3) < l_l ))
      {
      l_na = Typesafe.cast(Array.newInstance(
              p_array.getClass().getComponentType(), l_needed));
      System.arraycopy(p_array, 0, l_na, 0, p_position);
      }
    else l_na = p_array;

    System.arraycopy(p_array, p_position + p_delete, l_na, p_position,
                     l_needed - p_position);
    return l_na;
    }


/**
 * Delete some elements from an array faster than <code>delete</code>, but
 * doesn't preserve the order of the elements.
 * This method does not necessarily adjust the size of the array.
 * @param p_array     The array object where to delete elements.
 * @param p_count     The count of valid elements inside
 *                    <code>p_array</code>.
 * @param p_position  The position where to delete elements.
 * @param p_delete    The count of elements to be deleted.
 * @param <T>         The type of <code>p_array</code>. This must be an
 *                    array-type.
 * @return  An array containing the contents of <code>p_array</code>
 *          correctly re-arranged. <code>p_array</code> is not valid any
 *          longer after you called this method. You must only use the
 *          return value of this method in any further processing.
 * @see #delete(Object, int, int, int)
 * @see #delete_direct(Object, int, int)
 */

  public  static  final <T> T delete_fast   (final T    p_array,
                                             final int  p_count,
                                             final int  p_position,
                                                   int  p_delete)
    {
    int     l_l, l_needed;
    T       l_na;

    l_needed = (p_count - p_delete);
    l_l      = Array.getLength(p_array);

    if( (l_l > 512) && ((l_needed*3) < l_l ))
      {
      l_na = Typesafe.cast(Array.newInstance(
              p_array.getClass().getComponentType(), l_needed));
      System.arraycopy(p_array, 0, l_na, 0, p_position);
      System.arraycopy(p_array, p_position + p_delete, l_na, p_position,
                     l_needed - p_position);
      return l_na;
      }

    p_delete = Math.min(p_delete, l_needed - p_position);
    System.arraycopy(p_array, p_count - p_delete,
                     p_array, p_position, p_delete);
    return p_array;
    }


/**
 * Delete some elements from an array while preserving the element order.
 * This method does necessarily adjust the size of the array.
 * @param p_array     The array object where to delete elements.
 * @param p_position  The position where to delete elements.
 * @param p_delete    The count of elements to be deleted.
 * @param <T>         The type of <code>p_array</code>. This must be an
 *                    array-type.
 * @return  An array containing the contents of <code>p_array</code>
 *          correctly re-arranged. <code>p_array</code> is not valid any
 *          longer after you called this method. You must only use the
 *          return value of this method in any further processing.
 * @see #delete_fast(Object, int, int, int)
 * @see #delete(Object, int, int, int)
 */

  public  static  final <T> T delete_direct (final T    p_array,
                                             final int  p_position,
                                             final int  p_delete)
    {
    int     l_needed;
    T       l_na;

    if(p_delete <= 0) return p_array;

    l_needed = (Array.getLength(p_array) - p_delete);
    l_na     = Typesafe.cast(Array.newInstance(
                        p_array.getClass().getComponentType(), l_needed));

    System.arraycopy(p_array, 0, l_na, 0, p_position);
    System.arraycopy(p_array, p_position + p_delete,
                     l_na, p_position, l_needed - p_position);

    return l_na;
    }

/**
 * Combine two arrays to form another one.
 * @param p_a The first array.
 * @param p_b The second array.
 * @param <T> The type parameter.
 * @return  A new array, a combination of the both parameter arrays.
 */

  public  static  final <T> T   combine (final  T    p_a,
                                         final  T    p_b)
    {
    int l_a, l_b;
    T   l_x;

    if(p_a != null)
      {
      l_a = Array.getLength(p_a);
      }
    else
      {
      l_a = 0;
      }

    if(p_b != null)
      {
      l_b = Array.getLength(p_b);
      }
    else
      {
      l_b = 0;
      }

    if(l_a <= 0) return p_b;
    if(l_b <= 0) return p_a;

    l_x = Typesafe.cast(Array.newInstance(p_a.getClass().getComponentType(),
                        l_a+l_b));

    System.arraycopy(p_a, 0, l_x, 0, l_a);
    System.arraycopy(p_b, 0, l_x, l_a, l_b);

    return l_x;
    }

/**
 * Returns an array only containing the unique elements of <code>p_a</code>.
 * @param p_a The array with the items.
 * @param <T> The type parameter.
 * @return  An array containing only the unique elements of <code>p_a</code>.
 */

  public  static  final <T> T[]   unique  (final T[]  p_a)
    {
    int l_i, l_j, l_z, l_l;
    T   l_x;
    T[] l_d;

    if(p_a == null) return null;

    l_z = p_a.length;
    l_l = l_z;

main:
    for(l_i = (l_z-1); l_i > 0; l_i--)
      {
      l_x = p_a[l_i];
      for(l_j = (l_i-1); l_j >= 0; l_j--)
        {
        if(l_x == p_a[l_j])
          {
          l_z--;
          continue main;
          }
        }
      }

    if(l_z >= l_l) return p_a;
    if(l_z <= 0) return null;

    l_d = Typesafe.cast(
              Arrays.create(p_a.getClass().getComponentType(), l_z));

main_2:
    for(--l_l; l_l >= 0; l_l--)
      {
      l_x = p_a[l_l];
      for(l_j = (l_l-1); l_j >= 0; l_j--)
        {
        if(l_x == p_a[l_j])
          {
          continue main_2;
          }
        }
      l_d[--l_z] = l_x;
      }

    return l_d;
    }


/**
 * Combine two arrays to form another one, but only apper in either one of
 * the arrays.
 * @param p_a The first array.
 * @param p_b The second array.
 * @param <T> The type parameter.
 * @return  A new array, a combination of the both parameter arrays.
 */

  public  static  final <T> T[] combine_unique (final  T[]  p_a,
                                                final  T[]  p_b)
    {
    return unique(combine(p_a, p_b));
    }


/**
 * Searches the specified array for the specified value using the
 * binary search algorithm.  The array <strong>must</strong> be sorted (as
 * by the <tt>sort</tt> method, above) prior to making this call.  If it
 * is not sorted, the results are undefined.  If the array contains
 * multiple elements with the specified value, there is no guarantee which
 * one will be found.
 *
 * @param p_a     The array to be searched.
 * @param p_key   The value to be searched for.
 * @param p_count The count of valid items in <code>p_a.</code>
 * @return The Index of the search key, if it is contained in the array;
 *         otherwise, <code>(-(<i>insertion point</i>) - 1)</code>.  The
 *         <i>insertion point</i> is defined as the point at which the
 *         key would be inserted into the list: the index of the first
 *         element greater than the key, or <code>p_a.length</code>, if all
 *         elements in the list are less than the specified key.  Note
 *         that this guarantees that the return value will be &gt;= 0 if
 *         and only if the key is found.
 */

  public static final int search(final  long[]  p_a,
                                 final  long    p_key,
                                        int     p_count)
    {
    int   l_low, l_mid;
    long  l_mid_val;

    l_low = 0;
    p_count--;

    while (l_low <= p_count)
      {
      l_mid     = ((l_low + p_count) >> 1);
      l_mid_val = p_a[l_mid];

      if(l_mid_val < p_key)   l_low   = (l_mid + 1);
      else
        {
        if(l_mid_val > p_key) p_count = (l_mid - 1);
        else return l_mid;
        }
      }

    return -(l_low + 1);
    }



/**
 * Searches the specified array for the specified value using the
 * binary search algorithm.  The array <strong>must</strong> be sorted (as
 * by the <tt>sort</tt> method, above) prior to making this call.  If it
 * is not sorted, the results are undefined.  If the array contains
 * multiple elements with the specified value, there is no guarantee which
 * one will be found.
 *
 * @param p_a     The array to be searched.
 * @param p_key   The value to be searched for.
 * @param p_count The count of valid items in <code>p_a.</code>
 * @return The Index of the search key, if it is contained in the array;
 *         otherwise, <code>(-(<i>insertion point</i>) - 1)</code>.  The
 *         <i>insertion point</i> is defined as the point at which the
 *         key would be inserted into the list: the index of the first
 *         element greater than the key, or <code>p_a.length</code>, if all
 *         elements in the list are less than the specified key.  Note
 *         that this guarantees that the return value will be &gt;= 0 if
 *         and only if the key is found.
 */

  public static final int search(final  int[]   p_a,
                                 final  int     p_key,
                                        int     p_count)
    {
    int   l_low, l_mid, l_mid_val;

    l_low = 0;
    p_count--;

    while (l_low <= p_count)
      {
      l_mid     = ((l_low + p_count) >> 1);
      l_mid_val = p_a[l_mid];

      if(l_mid_val < p_key)   l_low   = (l_mid + 1);
      else
        {
        if(l_mid_val > p_key) p_count = (l_mid - 1);
        else return l_mid;
        }
      }

    return -(l_low + 1);
    }


/**
 * Searches the specified array for the specified value using the
 * binary search algorithm.  The array <strong>must</strong> be sorted (as
 * by the <tt>sort</tt> method, above) prior to making this call.  If it
 * is not sorted, the results are undefined.  If the array contains
 * multiple elements with the specified value, there is no guarantee which
 * one will be found.
 *
 * @param p_a     The array to be searched.
 * @param p_key   The value to be searched for.
 * @param p_count The count of valid items in <code>p_a.</code>
 * @return The Index of the search key, if it is contained in the array;
 *         otherwise, <code>(-(<i>insertion point</i>) - 1)</code>.  The
 *         <i>insertion point</i> is defined as the point at which the
 *         key would be inserted into the list: the index of the first
 *         element greater than the key, or <code>p_a.length</code>, if all
 *         elements in the list are less than the specified key.  Note
 *         that this guarantees that the return value will be &gt;= 0 if
 *         and only if the key is found.
 */

  public static final int search(final  short[]  p_a,
                                 final  short    p_key,
                                        int      p_count)
    {
    int   l_low, l_mid;
    short l_mid_val;

    l_low = 0;
    p_count--;

    while (l_low <= p_count)
      {
      l_mid     = ((l_low + p_count) >> 1);
      l_mid_val = p_a[l_mid];

      if(l_mid_val < p_key)   l_low   = (l_mid + 1);
      else
        {
        if(l_mid_val > p_key) p_count = (l_mid - 1);
        else return l_mid;
        }
      }

    return -(l_low + 1);
    }


/**
 * Searches the specified array for the specified value using the
 * binary search algorithm.  The array <strong>must</strong> be sorted (as
 * by the <tt>sort</tt> method, above) prior to making this call.  If it
 * is not sorted, the results are undefined.  If the array contains
 * multiple elements with the specified value, there is no guarantee which
 * one will be found.
 *
 * @param p_a     The array to be searched.
 * @param p_key   The value to be searched for.
 * @param p_count The count of valid items in <code>p_a.</code>
 * @return The Index of the search key, if it is contained in the array;
 *         otherwise, <code>(-(<i>insertion point</i>) - 1)</code>.  The
 *         <i>insertion point</i> is defined as the point at which the
 *         key would be inserted into the list: the index of the first
 *         element greater than the key, or <code>p_a.length</code>, if all
 *         elements in the list are less than the specified key.  Note
 *         that this guarantees that the return value will be &gt;= 0 if
 *         and only if the key is found.
 */

  public static final int search(final  char[]  p_a,
                                 final  char    p_key,
                                        int     p_count)
    {
    int   l_low, l_mid;
    char  l_mid_val;

    l_low = 0;
    p_count--;

    while (l_low <= p_count)
      {
      l_mid     = ((l_low + p_count) >> 1);
      l_mid_val = p_a[l_mid];

      if(l_mid_val < p_key)   l_low   = (l_mid + 1);
      else
        {
        if(l_mid_val > p_key) p_count = (l_mid - 1);
        else return l_mid;
        }
      }

    return -(l_low + 1);
    }


/**
 * Searches the specified array for the specified value using the
 * binary search algorithm.  The array <strong>must</strong> be sorted (as
 * by the <tt>sort</tt> method, above) prior to making this call.  If it
 * is not sorted, the results are undefined.  If the array contains
 * multiple elements with the specified value, there is no guarantee which
 * one will be found.
 *
 * @param p_a     The array to be searched.
 * @param p_key   The value to be searched for.
 * @param p_count The count of valid items in <code>p_a.</code>
 * @return The Index of the search key, if it is contained in the array;
 *         otherwise, <code>(-(<i>insertion point</i>) - 1)</code>.  The
 *         <i>insertion point</i> is defined as the point at which the
 *         key would be inserted into the list: the index of the first
 *         element greater than the key, or <code>p_a.length</code>, if all
 *         elements in the list are less than the specified key.  Note
 *         that this guarantees that the return value will be &gt;= 0 if
 *         and only if the key is found.
 */

  public static final int search(final  byte[]  p_a,
                                 final  byte    p_key,
                                        int     p_count)
    {
    int   l_low, l_mid;
    byte  l_mid_val;

    l_low = 0;
    p_count--;

    while (l_low <= p_count)
      {
      l_mid     = ((l_low + p_count) >> 1);
      l_mid_val = p_a[l_mid];

      if(l_mid_val < p_key)   l_low   = (l_mid + 1);
      else
        {
        if(l_mid_val > p_key) p_count = (l_mid - 1);
        else return l_mid;
        }
      }

    return -(l_low + 1);
    }

/**
 * Searches the specified array for the specified value using the
 * binary search algorithm.  The array <strong>must</strong> be sorted (as
 * by the <tt>sort</tt> method, above) prior to making this call.  If it
 * is not sorted, the results are undefined.  If the array contains
 * multiple elements with the specified value, there is no guarantee which
 * one will be found.
 *
 * @param p_a     The array to be searched.
 * @param p_key   The value to be searched for.
 * @param p_count The count of valid items in <code>p_a.</code>
 * @return The Index of the search key, if it is contained in the array;
 *         otherwise, <code>(-(<i>insertion point</i>) - 1)</code>.  The
 *         <i>insertion point</i> is defined as the point at which the
 *         key would be inserted into the list: the index of the first
 *         element greater than the key, or <code>p_a.length</code>, if all
 *         elements in the list are less than the specified key.  Note
 *         that this guarantees that the return value will be &gt;= 0 if
 *         and only if the key is found.
 */

  public static final int search(final  double[]  p_a,
                                 final  double    p_key,
                                        int       p_count)
    {
    int     l_low, l_mid, l_cmp;
    double  l_mid_val;
    long    l_mid_bits, l_key_bits;

    l_low      = 0;
    l_key_bits = Double.doubleToLongBits(p_key);
    p_count--;

    while(l_low <= p_count)
      {
      l_mid     = ((l_low + p_count) >> 1);
      l_mid_val = p_a[l_mid];

      if(l_mid_val < p_key)
        {
        l_cmp = -1;
        }
      else
        {
        if(l_mid_val > p_key)
          {
          l_cmp = 1;    // Neither val is NaN, thisVal is larger
          }
        else
          {
          l_mid_bits = Double.doubleToLongBits(l_mid_val);
          l_cmp      = ( (l_mid_bits == l_key_bits) ?  0 :
                         ((l_mid_bits <  l_key_bits) ? -1 : 1));
          }
        }

      if(l_cmp < 0) l_low = (l_mid + 1);
      else
        {
        if(l_cmp > 0) p_count = (l_mid - 1);
        else          return l_mid;
        }
      }

    return -(l_low + 1);
    }

/**
 * Searches the specified array for the specified value using the
 * binary search algorithm.  The array <strong>must</strong> be sorted (as
 * by the <tt>sort</tt> method, above) prior to making this call.  If it
 * is not sorted, the results are undefined.  If the array contains
 * multiple elements with the specified value, there is no guarantee which
 * one will be found.
 *
 * @param p_a     The array to be searched.
 * @param p_key   The value to be searched for.
 * @param p_count The count of valid items in <code>p_a.</code>
 * @return The Index of the search key, if it is contained in the array;
 *         otherwise, <code>(-(<i>insertion point</i>) - 1)</code>.  The
 *         <i>insertion point</i> is defined as the point at which the
 *         key would be inserted into the list: the index of the first
 *         element greater than the key, or <code>p_a.length</code>, if all
 *         elements in the list are less than the specified key.  Note
 *         that this guarantees that the return value will be &gt;= 0 if
 *         and only if the key is found.
 */

  public static final int search(final  float[]  p_a,
                                 final  float    p_key,
                                        int      p_count)
    {
    int     l_low, l_mid, l_cmp;
    float   l_mid_val;
    int     l_mid_bits, l_key_bits;

    l_low      = 0;
    l_key_bits = Float.floatToIntBits(p_key);
    p_count--;

    while(l_low <= p_count)
      {
      l_mid     = ((l_low + p_count) >> 1);
      l_mid_val = p_a[l_mid];

      if(l_mid_val < p_key)
        {
        l_cmp = -1;
        }
      else
        {
        if(l_mid_val > p_key)
          {
          l_cmp = 1;    // Neither val is NaN, thisVal is larger
          }
        else
          {
          l_mid_bits = Float.floatToIntBits(l_mid_val);
          l_cmp      = ( (l_mid_bits == l_key_bits) ?  0 :
                         ((l_mid_bits <  l_key_bits) ? -1 : 1));
          }
        }

      if(l_cmp < 0) l_low = (l_mid + 1);
      else
        {
        if(l_cmp > 0) p_count = (l_mid - 1);
        else          return l_mid;
        }
      }

    return -(l_low + 1);
    }


/**
 * Searches the specified array for the specified object using the binary
 * search algorithm.  The array must be sorted into ascending order
 * according to the <i>natural ordering</i> of its elements prior to making
 * this call.  If it is not sorted, the results are undefined.
 * (If the array contains elements that are not  mutually comparable (for
 * example,strings and integers), it <i>cannot</i> be sorted according
 * to the natural order of its elements, hence results are undefined.)
 *  If the array contains multiple
 * elements equal to the specified object, there is no guarantee which
 * one will be found.
 *
 * @param p_a     The array to be searched.
 * @param p_key   The value to be searched for.
 * @param p_count The count of valid items in <code>p_a.</code>
 * @return The index of the search key, if it is contained in the array;
 *         otherwise, <tt>(-(<i>insertion point</i>) - 1)</tt>.  The
 *         <i>insertion point</i> is defined as the point at which the
 *         key would be inserted into the list: the index of the first
 *         element greater than the key, or <tt>p_a.length</tt>, if all
 *         elements in the list are less than the specified key.  Note
 *         that this guarantees that the return value will be &gt;= 0 if
 *         and only if the key is found.
 * @throws ClassCastException if the search key in not comparable to the
 *         elements of the array.
 * @see Comparable
 */

  public static final int search(final  Object[]  p_a,
                                 final  Object    p_key,
                                        int       p_count)
    {
    int                 l_low, l_mid, l_cmp;
    Comparable<Object>  l_mid_val;

    l_low = 0;
    p_count--;

    while(l_low <= p_count)
      {
      l_mid     = ((l_low + p_count) >> 1);
      l_mid_val = Typesafe.cast(p_a[l_mid]);
      l_cmp     = l_mid_val.compareTo(p_key);

      if(l_cmp < 0)
        {
        l_low = (l_mid + 1);
        }
      else
        {
        if(l_cmp > 0) p_count = (l_mid - 1);
        else  return l_mid;
        }
      }

    return -(l_low + 1);  // key not found.
    }

/**
 * Searches the specified array for the specified object using the binary
 * search algorithm.  The array must be sorted into ascending order
 * according to the specified comparator (as by the <tt>Sort(Object[],
 * Comparator)</tt> method, above), prior to making this call.  If it is
 * not sorted, the results are undefined.
 * If the array contains multiple
 * elements equal to the specified object, there is no guarantee which one
 * will be found.
 *
 * @param p_a     The array to be searched.
 * @param p_key   The value to be searched for.
 * @param p_c     The comparator by which the array is ordered.  A
 *                <tt>null</tt> value indicates that the elements'
 *                <i>natural ordering</i> should be used.
 * @param p_count The count of valid items in <code>p_a.</code>
 * @param <T>     The type of the array elements.
 * @return The index of the search key, if it is contained in the array;
 *         otherwise, <tt>(-(<i>insertion point</i>) - 1)</tt>.  The
 *         <i>insertion point</i> is defined as the point at which the
 *         key would be inserted into the list: the index of the first
 *         element greater than the key, or <tt>p_a.length</tt>, if all
 *         elements in the list are less than the specified key.  Note
 *         that this guarantees that the return value will be &gt;= 0 if
 *         and only if the key is found.
 * @throws ClassCastException if the array contains elements that are not
 *         <i>mutually comparable</i> using the specified comparator,
 *         or the search key in not mutually comparable with the
 *         elements of the array using this comparator.
 * @see Comparable
 */

  public static final <T> int search(final  T[]                   p_a,
                                     final  T                     p_key,
                                     final  Comparator<? super T> p_c,
                                            int                   p_count)
    {
    int l_low, l_mid, l_cmp;
    T   l_mid_val;

    if(p_c == null)
      {
      return search(p_a, p_key, p_count);
      }

    l_low = 0;
    p_count--;

    while(l_low <= p_count)
      {
      l_mid     = ((l_low + p_count) >> 1);
      l_mid_val = p_a[l_mid];
      l_cmp     = p_c.compare(l_mid_val, p_key);

      if(l_cmp < 0) l_low = (l_mid + 1);
      else
        {
        if(l_cmp > 0) p_count = (l_mid - 1);
        else return l_mid;
        }
      }

    return -(l_low + 1);
    }


/**
 * Sort an array of longs.
 * @param p_a     The array to be sorted.
 * @param p_count The count of valid items in <code>p_a.</code>
 */

  public  static  final void  sort  (final long[] p_a,
                                     final int    p_count)
    {
    java.util.Arrays.sort(p_a, 0, p_count);
    }

/**
 * Sort an array of ints.
 * @param p_a     The array to be sorted.
 * @param p_count The count of valid items in <code>p_a.</code>
 */

  public  static  final void  sort  (final int[]  p_a,
                                     final int    p_count)
    {
    java.util.Arrays.sort(p_a, 0, p_count);
    }

/**
 * Sort an array of bytes.
 * @param p_a     The array to be sorted.
 * @param p_count The count of valid items in <code>p_a.</code>
 */

  public  static  final void  sort  (final byte[] p_a,
                                     final int    p_count)
    {
    java.util.Arrays.sort(p_a, 0, p_count);
    }

/**
 * Sort an array of shorts.
 * @param p_a     The array to be sorted.
 * @param p_count The count of valid items in <code>p_a.</code>
 */

  public  static  final void  sort  (final short[]  p_a,
                                     final int      p_count)
    {
    java.util.Arrays.sort(p_a, 0, p_count);
    }

/**
 * Sort an array of chars.
 * @param p_a     The array to be sorted.
 * @param p_count The count of valid items in <code>p_a.</code>
 */

  public  static  final void  sort  (final char[] p_a,
                                     final int    p_count)
    {
    java.util.Arrays.sort(p_a, 0, p_count);
    }

/**
 * Sort an array of double.
 * @param p_a     The array to be sorted.
 * @param p_count The count of valid items in <code>p_a.</code>
 */

  public  static  final void  sort  (final double[] p_a,
                                     final int      p_count)
    {
    java.util.Arrays.sort(p_a, 0, p_count);
    }

/**
 * Sort an array of float.
 * @param p_a     The array to be sorted.
 * @param p_count The count of valid items in <code>p_a.</code>
 */

  public  static  final void  sort  (final float[] p_a,
                                     final int     p_count)
    {
    java.util.Arrays.sort(p_a, 0, p_count);
    }

/**
 * Sort an array of objects.
 * @param p_a     The array to be sorted.
 * @param p_count The count of valid items in <code>p_a.</code>
 */

  public  static  final void  sort  (final Object[] p_a,
                                     final int      p_count)
    {
    java.util.Arrays.sort(p_a, 0, p_count);
    }


/**
 * Sort an array of objects.
 * @param p_a     The array to be sorted.
 * @param p_index The start index.
 * @param p_count The count of valid items in <code>p_a.</code>
 */

  public  static  final void  sort  (final Object[] p_a,
                                     final int      p_index,
                                     final int      p_count)
    {
    java.util.Arrays.sort(p_a, p_index, p_index+p_count);
    }

/**
 * Sort an array of longs.
 * @param p_a     The array to be sorted.
 * @param p_count The count of valid items in <code>p_a.</code>
 * @param p_c     The comparator used for sorting.
 * @param <T>     The item type of the array.
 */

  public  static  final <T> void  sort(final T[]                    p_a,
                                       final int                    p_count,
                                       final Comparator<? super T>  p_c)
    {
    java.util.Arrays.sort(p_a, 0, p_count, p_c);
    }

/**
 * Sort an array of longs.
 * @param p_a     The array to be sorted.
 * @param p_index The start index.
 * @param p_count The count of valid items in <code>p_a.</code>
 * @param p_c     The comparator used for sorting.
 * @param <T>     The item type of the array.
 */

  public  static  final <T> void  sort(final T[]                    p_a,
                                       final int                    p_index,
                                       final int                    p_count,
                                       final Comparator<? super T>  p_c)
    {
    java.util.Arrays.sort(p_a, p_index, p_index+p_count, p_c);
    }


/**
 * Fills a portion of an array with a specified value.
 * @param p_a     The array to be filled partly.
 * @param p_item  The item to be used for filling.
 * @param p_start Where to start with filling.
 * @param p_count How many slots are to be filled.
 */

  public  static  final void  fill  (final long[] p_a,
                                     final long   p_item,
                                           int    p_start,
                                           int    p_count)
    {
    for(; p_count > 0; p_count--, p_start++)
      {
      p_a[p_start] = p_item;
      }
    }

/**
 * Fills a portion of an array with a specified value.
 * @param p_a     The array to be filled partly.
 * @param p_item  The item to be used for filling.
 * @param p_start Where to start with filling.
 * @param p_count How many slots are to be filled.
 */

  public  static  final void  fill  (final int[]  p_a,
                                     final int    p_item,
                                           int    p_start,
                                           int    p_count)
    {
    for(; p_count > 0; p_count--, p_start++)
      {
      p_a[p_start] = p_item;
      }
    }



/**
 * Fills a portion of an array with a specified value.
 * @param p_a     The array to be filled partly.
 * @param p_item  The item to be used for filling.
 * @param p_start Where to start with filling.
 * @param p_count How many slots are to be filled.
 */

  public  static  final void  fill  (final short[] p_a,
                                     final short   p_item,
                                           int     p_start,
                                           int     p_count)
    {
    for(; p_count > 0; p_count--, p_start++)
      {
      p_a[p_start] = p_item;
      }
    }

/**
 * Fills a portion of an array with a specified value.
 * @param p_a     The array to be filled partly.
 * @param p_item  The item to be used for filling.
 * @param p_start Where to start with filling.
 * @param p_count How many slots are to be filled.
 */

  public  static  final void  fill  (final byte[] p_a,
                                     final byte   p_item,
                                           int    p_start,
                                           int    p_count)
    {
    for(; p_count > 0; p_count--, p_start++)
      {
      p_a[p_start] = p_item;
      }
    }



/**
 * Fills a portion of an array with a specified value.
 * @param p_a     The array to be filled partly.
 * @param p_item  The item to be used for filling.
 * @param p_start Where to start with filling.
 * @param p_count How many slots are to be filled.
 */

  public  static  final void  fill  (final boolean[] p_a,
                                     final boolean   p_item,
                                           int       p_start,
                                           int       p_count)
    {
    for(; p_count > 0; p_count--, p_start++)
      {
      p_a[p_start] = p_item;
      }
    }

/**
 * Fills a portion of an array with a specified value.
 * @param p_a     The array to be filled partly.
 * @param p_item  The item to be used for filling.
 * @param p_start Where to start with filling.
 * @param p_count How many slots are to be filled.
 */

  public  static  final void  fill  (final char[] p_a,
                                     final char   p_item,
                                           int    p_start,
                                           int    p_count)
    {
    for(; p_count > 0; p_count--, p_start++)
      {
      p_a[p_start] = p_item;
      }
    }



/**
 * Fills a portion of an array with a specified value.
 * @param p_a     The array to be filled partly.
 * @param p_item  The item to be used for filling.
 * @param p_start Where to start with filling.
 * @param p_count How many slots are to be filled.
 */

  public  static  final void  fill  (final double[] p_a,
                                     final double   p_item,
                                           int      p_start,
                                           int      p_count)
    {
    for(; p_count > 0; p_count--, p_start++)
      {
      p_a[p_start] = p_item;
      }
    }



/**
 * Fills a portion of an array with a specified value.
 * @param p_a     The array to be filled partly.
 * @param p_item  The item to be used for filling.
 * @param p_start Where to start with filling.
 * @param p_count How many slots are to be filled.
 */

  public  static  final void  fill  (final float[] p_a,
                                     final float   p_item,
                                           int     p_start,
                                           int     p_count)
    {
    for(; p_count > 0; p_count--, p_start++)
      {
      p_a[p_start] = p_item;
      }
    }



/**
 * Fills a portion of an array with a specified value.
 * @param p_a     The array to be filled partly.
 * @param p_item  The item to be used for filling.
 * @param p_start Where to start with filling.
 * @param p_count How many slots are to be filled.
 * @param <X>     The base array type.
 * @param <T>     The item's type.
 */

  public  static  final <X, T extends X>void  fill  (final X[]    p_a,
                                                     final T      p_item,
                                                           int    p_start,
                                                           int    p_count)
    {
    for(; p_count > 0; p_count--, p_start++)
      {
      p_a[p_start] = p_item;
      }
    }


/**
 * Fills an array with a specified value.
 * @param p_a     The array to be filled partly.
 * @param p_item  The item to be used for filling.
 */

  public  static  final void  fill  (final long[] p_a,
                                     final long   p_item)
    {
    int l_i;

    for(l_i = (p_a.length-1); l_i >= 0; l_i--)
      {
      p_a[l_i] = p_item;
      }
    }


/**
 * Fills an array with a specified value.
 * @param p_a     The array to be filled partly.
 * @param p_item  The item to be used for filling.
 */

  public  static  final void  fill  (final int[] p_a,
                                     final int   p_item)
    {
    int l_i;

    for(l_i = (p_a.length-1); l_i >= 0; l_i--)
      {
      p_a[l_i] = p_item;
      }
    }


/**
 * Fills an array with a specified value.
 * @param p_a     The array to be filled partly.
 * @param p_item  The item to be used for filling.
 */

  public  static  final void  fill  (final short[] p_a,
                                     final short   p_item)
    {
    int l_i;

    for(l_i = (p_a.length-1); l_i >= 0; l_i--)
      {
      p_a[l_i] = p_item;
      }
    }


/**
 * Fills an array with a specified value.
 * @param p_a     The array to be filled partly.
 * @param p_item  The item to be used for filling.
 */

  public  static  final void  fill  (final byte[] p_a,
                                     final byte   p_item)
    {
    int l_i;

    for(l_i = (p_a.length-1); l_i >= 0; l_i--)
      {
      p_a[l_i] = p_item;
      }
    }


/**
 * Fills an array with a specified value.
 * @param p_a     The array to be filled partly.
 * @param p_item  The item to be used for filling.
 */

  public  static  final void  fill  (final boolean[] p_a,
                                     final boolean   p_item)
    {
    int l_i;

    for(l_i = (p_a.length-1); l_i >= 0; l_i--)
      {
      p_a[l_i] = p_item;
      }
    }


/**
 * Fills an array with a specified value.
 * @param p_a     The array to be filled partly.
 * @param p_item  The item to be used for filling.
 */

  public  static  final void  fill  (final char[] p_a,
                                     final char   p_item)
    {
    int l_i;

    for(l_i = (p_a.length-1); l_i >= 0; l_i--)
      {
      p_a[l_i] = p_item;
      }
    }


/**
 * Fills an array with a specified value.
 * @param p_a     The array to be filled partly.
 * @param p_item  The item to be used for filling.
 */

  public  static  final void  fill  (final double[] p_a,
                                     final double   p_item)
    {
    int l_i;

    for(l_i = (p_a.length-1); l_i >= 0; l_i--)
      {
      p_a[l_i] = p_item;
      }
    }


/**
 * Fills an array with a specified value.
 * @param p_a     The array to be filled partly.
 * @param p_item  The item to be used for filling.
 */

  public  static  final void  fill  (final float[] p_a,
                                     final float   p_item)
    {
    int l_i;

    for(l_i = (p_a.length-1); l_i >= 0; l_i--)
      {
      p_a[l_i] = p_item;
      }
    }


/**
 * Fills an array with a specified value.
 * @param p_a     The array to be filled partly.
 * @param p_item  The item to be used for filling.
 * @param <X>     The array's base type.
 * @param <T>     The item's type.
 */

  public  static  final <X, T extends X> void  fill  (final X[] p_a,
                                                      final T   p_item)
    {
    int l_i;

    for(l_i = (p_a.length-1); l_i >= 0; l_i--)
      {
      p_a[l_i] = p_item;
      }
    }
  }

File Information:

file name:Arrays.java
package:org.sfc.collections
qualified name:org.sfc.collections.Arrays.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/sfc/collections/Arrays.java
size:48.444 KB (49607 B)
uploaded: 2018-01-07 12:03:36 GMT+0000
last update: 2006-06-15 12:49:53 GMT+0000
last access: 2018-04-23 23:16:20 GMT+0000

statistics online since 2006-01-02.   RSS Feed
Contact us by sending an email to tweise@gmx.de to receive further information, to report errors, or to join our project.
All content on this site (http://dgpf.sourceforge.net/) is LGPL-licensed.
http://dgpf.sourceforge.net/scripts/source/source.php last modified at 2018-01-07 12:03:34 GMT+0000 served at 2018-04-23 23:16:20 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo