Procedure

   SpiceInt lstltd_c ( SpiceDouble         x,
                       SpiceInt            n,
                       ConstSpiceDouble  * array ) 

Abstract

 
   Given a number x and an array of non-decreasing numbers, 
   find the index of the largest array element less than x. 
 

Required_Reading

 
   None. 
 

Keywords

 
   SEARCH,  ARRAY 
 

Brief_I/O

 
   VARIABLE  I/O  DESCRIPTION 
   --------  ---  -------------------------------------------------- 
   x          I   Value to search against 
   n          I   Number elements in array
   array      I   Array of possible lower bounds 

   The function returns the index of the last element of array that
   is less than x. 
 

Detailed_Input

 
   x       Double precision number.

   n       Total number of elements in array. 

   array   Array of double precision numbers which forms a
           non-decreasing sequence.  The elements of array need not be
           distinct.

 

Detailed_Output

 
   The function returns the index of the highest-indexed element in the 
   input array that is less than x.  The routine assumes the array elements 
   are sorted in non-decreasing order.

   Indices range from 0 to n-1.
 
   If all elements of the input array are greater than or equal to x,
   the function returns -1.

Parameters

 
   None. 
 

Exceptions

 
   Error free.

   1) In the case that n is input with value less than or equal 
      to zero, the function returns -1.

   2) If the input array is not sorted in increasing order, the
      output of this routine are undefined.  No error is signaled.

Files

 
   None. 
  

Particulars

   Note:  If you need to find the first element of the array that
          is greater than or equal to x, simply add 1 to the
          result returned by this function and check to see if the
          result is within the array bounds given by n.

Examples

 
   1)  Let array be assigned the following values:

          array[0] = -2.0;
          array[1] = -2.0;
          array[2] =  0.0;
          array[3] =  1.0;
          array[4] =  1.0;
          array[5] = 11.0;


       The table below demonstrates the behavior of lstltd_c:

                    Call                       Returned Value
          ===========================          ==============
          lstltd_c ( -3.0, 6, array )                -1

          lstltd_c ( -2.0, 6, array )                -1

          lstltd_c (  0.0, 6, array )                 1

          lstltd_c (  1.0, 6, array )                 2

          lstltd_c ( 11.1, 6, array )                 5

Restrictions

 
   If the sequence of elements in array is not non-decreasing, 
   the program will run to completion but the index found will 
   not mean anything. 
 

Literature_References

 
   None. 
 

Author_and_Institution

 
   N.J. Bachman    (JPL) 
   W.L. Taber      (JPL) 
 

Version

 
   -CSPICE Version 1.0.0, 10-JUL-2002 (NJB) (WLT)

Index_Entries

 
   last d.p. element less_than 
 

Link to routine lstltd_c source file lstltd_c.c