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
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
//
// GENERATED FILE
//
use super::*;
use crate::SpiceContext;
use f2rust_std::*;
pub const LBCELL: i32 = -5;
/// Select a subset of the values of a symbol
///
/// Select a subset of the values associated with a particular
/// symbol in a double precision symbol table.
///
/// # Required Reading
///
/// * [SYMBOLS](crate::required_reading::symbols)
///
/// # Brief I/O
///
/// ```text
/// VARIABLE I/O DESCRIPTION
/// -------- --- --------------------------------------------------
/// NAME I Name of the symbol whose associated values are to
/// be returned.
/// BEGIN I Index of the first associated value to be returned.
/// END I Index of the last associated value to be returned.
/// TABSYM,
/// TABPTR,
/// TABVAL I Components of the symbol table.
/// VALUES O Subset of the values associated with the symbol
/// NAME.
/// FOUND O .TRUE. if the subset of values exists.
/// ```
///
/// # Detailed Input
///
/// ```text
/// NAME is the name of the symbol whose subset of associated
/// values to be returned. If NAME is not in the symbol
/// table, FOUND is .FALSE.
///
/// BEGIN is the index of the first associated value to be
/// returned. If BEGIN is out of range (BEGIN < 1 or
/// BEGIN > END) FOUND is .FALSE.
///
/// END is the index of the last associated value to be
/// returned. If END is out of range (END < 1 or
/// END > is greater than the dimension of NAME)
/// FOUND is .FALSE.
///
/// TABSYM,
/// TABPTR,
/// TABVAL are components of the double precision symbol table.
/// ```
///
/// # Detailed Output
///
/// ```text
/// VALUES is a subset of the values associated with the
/// symbol NAME. If the subset specified by BEGIN and
/// END exists, as many values as will fit in VALUES
/// are returned. If the subset does not exist, no
/// values are returned and FOUND is .FALSE.
///
/// FOUND is .TRUE. if the subset of values is exists.
/// FOUND is .FALSE. if BEGIN < 1, BEGIN > END, END < 1,
/// END > the dimension of NAME, or NAME is not
/// in the symbol table.
/// ```
///
/// # Exceptions
///
/// ```text
/// 1) If there is an issue while reading the components of a double
/// precision symbol table, an error is signaled by a routine in
/// the call tree of this routine. This normally indicates that
/// the double precision symbol table is corrupted.
/// ```
///
/// # Particulars
///
/// ```text
/// FOUND will be false if the bounds of the subset specified by
/// BEGIN and END are out of range. Values of BEGIN and END which
/// specify bounds out of range are BEGIN < 1, BEGIN > END,
/// END < 1, or END > the dimension of NAME. FOUND is also false
/// if the symbol NAME is not in the symbol table.
/// ```
///
/// # Examples
///
/// ```text
/// The contents of the symbol table are:
///
/// BODY4_POLE_RA --> 3.17681D2
/// 1.08D-1
/// 0.0D0
/// DELTA_T_A --> 3.2184D1
/// K --> 1.657D-3
/// MEAN_ANOM --> 6.239996D0
/// 1.99096871D-7
/// ORBIT_ECC --> 1.671D-2
///
/// Let the dimension of the array VALUES be 3.
///
///
/// The ouput values of VALUES and FOUND for the input values of
/// NAME, BEGIN, and END are contained in this table:
///
/// NAME BEGIN END VALUES FOUND
/// ------------- ----- --- -------------------- -------
/// MEAN_ANOM 1 2 6.239996D0 .TRUE.
/// 1.99096871D-7
///
/// BODY4_POLE_RA 1 3 3.17681D2 .TRUE.
/// 1.08D-1
/// 0.0D0
///
/// BODY4_PRIME 1 3 .FALSE.
///
/// MEAN_ANOM 2 1 .FALSE.
///
/// ORBIT_ECC 1 -2 .FALSE.
///
/// K 1 5 .FALSE.
/// --------------------------------------------------------------
///
/// Note that FOUND is .FALSE. for examples 3 through 6 because:
///
/// - In the 3rd example, the symbol 'BODY4_PRIME' is not in the
/// symbol table.
///
/// - In the 4th example, BEGIN > END.
///
/// - In the 5th example, END < 0.
///
/// - In the 6th example, END is greater than the dimension of the
/// symbol 'K'.
/// ```
///
/// # Restrictions
///
/// ```text
/// 1) This subroutine does not check to see if the output array
/// VALUES is large enough to hold the selected set of values.
/// The caller must provide the required space.
/// ```
///
/// # Author and Institution
///
/// ```text
/// N.J. Bachman (JPL)
/// J. Diaz del Rio (ODC Space)
/// H.A. Neilan (JPL)
/// W.L. Taber (JPL)
/// I.M. Underwood (JPL)
/// ```
///
/// # Version
///
/// ```text
/// - SPICELIB Version 1.1.0, 16-AUG-2021 (JDR)
///
/// Added IMPLICIT NONE statement.
///
/// Edited the header to comply with NAIF standard. Moved entry
/// from $Exceptions to $Restrictions and added entry #1 in
/// $Exceptions.
///
/// - SPICELIB Version 1.0.2, 03-NOV-2005 (NJB)
///
/// Various header corrections were made. In particular,
/// the header no longer asserts that this routine will
/// "return as many values as will fit" in the output array
/// VALUES.
///
/// - 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 (IMU) (HAN)
/// ```
pub fn syseld(
ctx: &mut SpiceContext,
name: &str,
begin: i32,
end: i32,
tabsym: CharArray,
tabptr: &[i32],
tabval: &[f64],
values: &mut [f64],
found: &mut bool,
) -> crate::Result<()> {
SYSELD(
name.as_bytes(),
begin,
end,
tabsym,
tabptr,
tabval,
values,
found,
ctx.raw_context(),
)?;
ctx.handle_errors()?;
Ok(())
}
//$Procedure SYSELD ( Select a subset of the values of a symbol )
pub fn SYSELD(
NAME: &[u8],
BEGIN: i32,
END: i32,
TABSYM: CharArray,
TABPTR: &[i32],
TABVAL: &[f64],
VALUES: &mut [f64],
FOUND: &mut bool,
ctx: &mut Context,
) -> f2rust_std::Result<()> {
let TABSYM = DummyCharArray::new(TABSYM, None, LBCELL..);
let TABPTR = DummyArray::new(TABPTR, LBCELL..);
let TABVAL = DummyArray::new(TABVAL, LBCELL..);
let mut VALUES = DummyArrayMut::new(VALUES, 1..);
let mut NSYM: i32 = 0;
let mut LOCSYM: i32 = 0;
let mut LOCVAL: i32 = 0;
let mut N: i32 = 0;
//
// SPICELIB functions
//
//
// Local variables
//
//
// Standard SPICE error handling.
//
if RETURN(ctx) {
return Ok(());
} else {
CHKIN(b"SYSELD", ctx)?;
}
//
// How many symbols to start with?
//
NSYM = CARDC(TABSYM.as_arg(), ctx)?;
//
// Is this symbol even in the table?
//
LOCSYM = BSRCHC(NAME, NSYM, TABSYM.subarray(1));
//
// If it's not in the table, it's definitely a problem.
//
if (LOCSYM == 0) {
*FOUND = false;
} else {
//
// We could still have a problem: do these components exist?
// Does this request even make sense?
//
N = TABPTR[LOCSYM];
if (((((BEGIN >= 1) && (BEGIN <= N)) && (END >= 1)) && (END <= N)) && (BEGIN <= END)) {
*FOUND = true;
LOCVAL = (SUMAI(TABPTR.subarray(1), (LOCSYM - 1)) + 1);
MOVED(
TABVAL.subarray(((LOCVAL + BEGIN) - 1)),
((END - BEGIN) + 1),
VALUES.as_slice_mut(),
);
} else {
*FOUND = false;
}
}
CHKOUT(b"SYSELD", ctx)?;
Ok(())
}