rsspice 0.1.0

Pure Rust port of the SPICE Toolkit for space geometry
Documentation 
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

//
// GENERATED FILE
//

use super::*;
use f2rust_std::*;

pub const LBCELL: i32 = -5;
const PSIZE: i32 = 8;
const BSIZE: i32 = 100;

//$Procedure ZZCKCVR2 ( Private --- C-kernel segment coverage, type 02 )
pub fn ZZCKCVR2(
    HANDLE: i32,
    ARRBEG: i32,
    ARREND: i32,
    SCHEDL: &mut [f64],
    ctx: &mut Context,
) -> f2rust_std::Result<()> {
    let mut SCHEDL = DummyArrayMut::new(SCHEDL, LBCELL..);
    let mut FIRST = StackArray::<f64, 100>::new(1..=BSIZE);
    let mut LAST = StackArray::<f64, 100>::new(1..=BSIZE);
    let mut ARRSIZ: i32 = 0;
    let mut BEGAT: i32 = 0;
    let mut ENDAT: i32 = 0;
    let mut GET: i32 = 0;
    let mut GOT: i32 = 0;
    let mut NREC: i32 = 0;

    //
    // SPICELIB Functions
    //

    //
    // Local Parameters
    //

    //
    // Local Variables
    //

    //
    // Standard SPICE error handling.
    //
    if spicelib::RETURN(ctx) {
        return Ok(());
    } else {
        spicelib::CHKIN(b"ZZCKCVR2", ctx)?;
    }

    //
    // Determine the size of the array and the number of records
    // in it.
    //
    ARRSIZ = ((ARREND - ARRBEG) + 1);
    NREC = intrinsics::IDNINT((((100.0 * (ARRSIZ as f64)) + 1.0) / 1001.0));

    //
    // The variable GOT tells us how many time endpoints we've
    // gotten so far.
    //
    GOT = 0;

    while (GOT < NREC) {
        GET = intrinsics::MIN0(&[BSIZE, (NREC - GOT)]);

        BEGAT = ((ARRBEG + (NREC * PSIZE)) + GOT);
        ENDAT = (((ARRBEG + (NREC * PSIZE)) + NREC) + GOT);

        //
        // Retrieve the list next list of windows.
        //
        spicelib::DAFGDA(
            HANDLE,
            BEGAT,
            ((BEGAT + GET) - 1),
            FIRST.as_slice_mut(),
            ctx,
        )?;
        spicelib::DAFGDA(HANDLE, ENDAT, ((ENDAT + GET) - 1), LAST.as_slice_mut(), ctx)?;

        //
        // Insert the coverage intervals into the schedule.
        //
        for I in 1..=GET {
            spicelib::WNINSD(FIRST[I], LAST[I], SCHEDL.as_slice_mut(), ctx)?;
        }

        GOT = (GOT + GET);
    }

    spicelib::CHKOUT(b"ZZCKCVR2", ctx)?;
    Ok(())
}