Khác biệt giữa các bản “Dịch thuật”

→‎Lịch sử: Chuyển sang tiếng việt
n (Thay thế ‘(?mi)\{\{(Liên kết chọn lọc|Link FA)\|.+?\}\}\n?’ bằng ‘’.: deprecated template)
(→‎Lịch sử: Chuyển sang tiếng việt)
Thẻ: Sửa đổi di động Sửa đổi từ trang di động
 
==Lịch sử==
Index Page
lstlei
A B C D E F G H I J K L M N O P Q R S T U V W X
 
Procedure
Abstract
Required_Reading
Keywords
Declarations
Brief_I/O
Detailed_Input
Detailed_Output
Parameters
Exceptions
Files
Particulars
Examples
Restrictions
Literature_References
Author_and_Institution
Version
Procedure
 
LSTLEI ( Last integer element less than or equal to )
INTEGER FUNCTION LSTLEI ( X, N, ARRAY )
Abstract
 
Given a number X and an array of non-decreasing numbers,
find the index of the largest array element less than or equal
to X.
Required_Reading
 
None.
Keywords
 
SEARCH, ARRAY
Declarations
 
INTEGER X
INTEGER N
INTEGER ARRAY ( * )
Brief_I/O
 
VARIABLE I/O DESCRIPTION
-------- --- --------------------------------------------------
X I Value to search against.
ARRAY I Array of possible lower bounds.
N I Number elements in ARRAY.
LSTLEI O the index of the last element of ARRAY <= X.
Detailed_Input
 
X Integer for which one desires to find
the last ARRAY element less than or equal to X.
 
ARRAY Array of integers that forms a
non-decreasing sequence. We will find the last element
of the sequence that is less than or equal to X.
 
N Total number of elements in ARRAY
Detailed_Output
 
LSTLEI Index of the last element of the non-decreasing sequence:
{ARRAY(I) : 0 < I < N + 1} that is less than or equal
to X. (Note that LSTLEI = I for some I in the range 1 to
N unless X is less than all of these elements in which
case LSTLEI = 0.)
 
In the case that N is input with value less than or equal
to zero, LSTLEI is returned as zero.
Parameters
 
None.
Exceptions
 
Error free.
Files
 
None.
Particulars
 
An array of integers is given. The array
ARRAY(I) (0 < I < N ) forms a non-decreasing sequence of
numbers. Given a real number X, there will be a last one of
these numbers that is less than or equal to X. This routine
finds the index LSTLEI such that ARRAY(LSTLEI) is that number.
 
If X is not greater than ARRAY(1), INDEX will be set to zero.
 
This routine uses a binary search algorithm and so requires
at most LOG_2(N) steps to find the value of LSTLEI.
 
Note: If you need to find the first element of the array that
is greater than 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
 
Suppose that you have an reasonably large ordered array of
integers, into which you want to insert a few more without
destroying the ordering.
 
Depending upon your application, it may be desirable to
not insert duplicates, to insert duplicates before
existing entries or to insert them after existing entries.
 
The code fragment below, illustrates an insertion scheme
that will insert duplicate items after existing items
and simultaneously update a second parallel array of
double precision numbers.
 
get the pair to insert
 
READ (*,*) KEY, VALUE
 
locate the place to insert the new KEY into the sorted
array of keys.
 
LOC = LSTLEI ( KEY, NKEYS, KEYS ) + 1
 
insert the key and its associated value into the
KEYS and VALUES arrays at location LOC
 
CALL INSLAI ( KEY, 1, LOC, NKEYS, KEYS )
CALL INSLAD ( VALUE, 1, LOC, NVALS, VALUES )
 
If at the READ statement the arrays KEYS and VALUES looked like:
 
KEYS VALUES NKEYS = 6, NVALS = 6
---- -------
2 3.00D0
5 1.00D0
7 3.14D0
16 7.11D0
18 2.14D0
23 12.12D0
 
and 9 and 33.33D3 were read into KEY and VALUE respectively
then LSTLEI (KEY, NKEYS, KEYS ) would be 3 and LOC would be 4.
After the calls to the routines INSLAI and INSLAD we would have
 
KEYS VALUES NKEYS = 7, NVALS = 7
---- -------
2 3.00D0
5 1.00D0
7 3.14D0
9 33.33D3 <===== inserted items.
16 7.11D0
18 2.14D0
23 12.12D0
 
If 7 and 33.33D3 were read into KEY and VALUE respectively
then again LSTLEI (KEY, NKEYS, KEYS ) would be 3 and LOC would
be 4. After the calls to the routines INSLAI and INSLAD we
would have:
 
KEYS VALUES NKEYS = 7, NVALS = 7
---- -------
2 3.00D0
5 1.00D0
7 3.14D0
7 33.33D3 <===== inserted items.
16 7.11D0
18 2.14D0
23 12.12D0
 
If we replaced the line of code
 
LOC = LSTLEI ( KEY, NKEYS, KEYS ) + 1
by
 
LOC = LSTLTI ( KEY, NKEYS, KEYS ) + 1
 
we would obtain a routine that inserted duplicates before
existing entries. (LSTLTI is similar to LSTLEI except it finds
the last occurrance of an integer strictly less than a value.)
Using 7 and 33.33D3 for KEY and VALUE again, the modified code
fragment would yield the results shown below.
 
KEYS VALUES NKEYS = 7, NVALS = 7
---- -------
2 3.00D0
5 1.00D0
7 33.33D3 <===== inserted items.
7 3.14D0
16 7.11D0
18 2.14D0
23 12.12D0
 
 
(Note: you should NOT use the
code outlined above as the basis of a sorting algorithm.
The NAIF routines SHELLI, SHELLD, SHELLC, ORDERI, ORDERD, ORDERC,
REORDI, REORDD and REORDC are much more efficient routines for
sorting arrays or sorting a set of parallel arrays using
one of the set as a key. The fragment presented here is useful
for performing update insertions into previously ordered arrays.)
 
For more ideas regarding the use of this routine, see LSTLEC
and LSTLTC.
Restrictions
 
If the sequence does not non-decreasing, the program will run
to completion but the index found will not mean anything.
Literature_References
 
None.
Author_and_Institution
 
H.A. Neilan (JPL)
W.L. Taber (JPL)
Version
 
SPICELIB Version 1.0.1, 10-MAR-1992 (WLT)
 
Comment section for permuted index source lines was added
following the header.
 
SPICELIB Version 1.0.0, 31-JAN-1990 (WLT)
Tue Jul 15 14:24:35 2014
 
==Lí thuyết==
===Phương Tây===
10

lần sửa đổi