1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
//
// GENERATED FILE
//
use super::*;
use crate::SpiceContext;
use f2rust_std::*;
/// Last double precision element less than
///
/// Find the index of the largest array element less than
/// a given number X in an array of non-decreasing numbers.
///
/// # Brief I/O
///
/// ```text
/// VARIABLE I/O DESCRIPTION
/// -------- --- --------------------------------------------------
/// X I Upper bound value to search against.
/// N I Number of 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
///
/// ```text
/// X is a double precision value acting as an upper bound: the
/// element of ARRAY that is the greatest element less than X
/// is to be found.
///
/// N is the total number of elements in ARRAY.
///
/// ARRAY is an array of double precision numbers that forms a
/// non-decreasing sequence. The elements of array need not
/// be distinct.
/// ```
///
/// # Detailed Output
///
/// ```text
/// 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 1 to N.
///
/// If all elements of ARRAY are greater than or equal to X, the
/// routine returns the value 0. If N is less than or equal to zero,
/// the routine returns the value 0.
/// ```
///
/// # Exceptions
///
/// ```text
/// Error free.
///
/// 1) If N is less than or equal to zero, the function returns 0.
/// This case is not treated as an error.
///
/// 2) If the input array is not sorted in non-decreasing order, the
/// output of this routine is undefined. No error is signaled.
/// ```
///
/// # Particulars
///
/// ```text
/// This routine uses a binary search algorithm and so requires
/// at most on the order of
///
/// log (N)
/// 2
///
/// steps to compute the value of LSTLTD.
///
/// 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
///
/// ```text
/// If ARRAY(I) = -1 + 4*I/3 (real arithmetic implied here)
///
/// N = 10
/// X = 7.12
///
/// then
///
/// LSTLTD will be I where
///
/// (4*I/3) - 1 < 7.12
///
/// but
///
/// (4*(I+1)/3) - 1 > or = 7.12 .
///
/// In this case our subsequence is:
///
/// 1/3, 5/3, 9/3, 13/3, 17/3, 21/3, 25/3, .... 37/3
///
/// index: 1 2 3 4 5 6 7 .... 10
///
/// Thus LSTLTD will be returned as 6
///
/// The following table shows the values of LSTLTD that would be
/// returned for various values of X
///
/// X LSTLTD
/// ----- -------
/// 0.12 0
/// 1.34 1
/// 5.13 4
/// 8.00 6
/// 15.10 10
/// ```
///
/// # Restrictions
///
/// ```text
/// 1) If the sequence of double precision numbers in the input array
/// ARRAY is not non-decreasing, the program will run to
/// completion but the index found will not mean anything.
/// ```
///
/// # Author and Institution
///
/// ```text
/// N.J. Bachman (JPL)
/// J. Diaz del Rio (ODC Space)
/// W.L. Taber (JPL)
/// ```
///
/// # Version
///
/// ```text
/// - SPICELIB Version 1.1.0, 26-OCT-2021 (JDR)
///
/// Added IMPLICIT NONE statement.
///
/// Edited the header to comply with NAIF standard. Removed
/// unnecessary $Revisions section. Improved $Detailed_Input,
/// $Detailed_Output, $Particulars, $Exceptions and $Restrictions
/// sections.
///
/// - 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) (NJB)
/// ```
pub fn lstltd(x: f64, n: i32, array: &[f64]) -> i32 {
let ret = LSTLTD(x, n, array);
ret
}
//$Procedure LSTLTD ( Last double precision element less than )
pub fn LSTLTD(X: f64, N: i32, ARRAY: &[f64]) -> i32 {
let ARRAY = DummyArray::new(ARRAY, 1..);
let mut LSTLTD: i32 = 0;
let mut J: i32 = 0;
let mut BEGIN: i32 = 0;
let mut END: i32 = 0;
let mut MIDDLE: i32 = 0;
let mut ITEMS: i32 = 0;
//
// Local variables
//
ITEMS = N;
BEGIN = 1;
END = N;
if (N <= 0) {
//
// There's nobody home---that is there is nothing in the array
// to compare against. Zero is the only sensible thing to return
//
LSTLTD = 0;
} else if (X <= ARRAY[BEGIN]) {
//
// None of the array elements are less than X
//
LSTLTD = 0;
} else if (ARRAY[END] < X) {
//
// X is greater than all elements of the array. Thus the last
// element of the array is the last item less than X.
//
LSTLTD = END;
} else {
//
// X lies between some pair of elements of the array
//
while (ITEMS > 2) {
J = (ITEMS / 2);
MIDDLE = (BEGIN + J);
if (ARRAY[MIDDLE] < X) {
BEGIN = MIDDLE;
} else {
END = MIDDLE;
}
ITEMS = (1 + (END - BEGIN));
}
LSTLTD = BEGIN;
}
LSTLTD
}