#[doc = " The (u,v,w) coordinates of a baseline. They are in units of metres."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct UVW {
pub u: f64,
pub v: f64,
pub w: f64,
}
#[test]
fn bindgen_test_layout_UVW() {
assert_eq!(
::std::mem::size_of::<UVW>(),
24usize,
concat!("Size of: ", stringify!(UVW))
);
assert_eq!(
::std::mem::align_of::<UVW>(),
8usize,
concat!("Alignment of ", stringify!(UVW))
);
fn test_field_u() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<UVW>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize
},
0usize,
concat!("Offset of field: ", stringify!(UVW), "::", stringify!(u))
);
}
test_field_u();
fn test_field_v() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<UVW>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).v) as usize - ptr as usize
},
8usize,
concat!("Offset of field: ", stringify!(UVW), "::", stringify!(v))
);
}
test_field_v();
fn test_field_w() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<UVW>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).w) as usize - ptr as usize
},
16usize,
concat!("Offset of field: ", stringify!(UVW), "::", stringify!(w))
);
}
test_field_w();
}
#[doc = " The LMN coordinates of a sky-model component (prepared for application in the"]
#[doc = "RIME)."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct LmnRime {
pub l: f64,
pub m: f64,
pub n: f64,
}
#[test]
fn bindgen_test_layout_LmnRime() {
assert_eq!(
::std::mem::size_of::<LmnRime>(),
24usize,
concat!("Size of: ", stringify!(LmnRime))
);
assert_eq!(
::std::mem::align_of::<LmnRime>(),
8usize,
concat!("Alignment of ", stringify!(LmnRime))
);
fn test_field_l() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<LmnRime>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).l) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(LmnRime),
"::",
stringify!(l)
)
);
}
test_field_l();
fn test_field_m() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<LmnRime>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).m) as usize - ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(LmnRime),
"::",
stringify!(m)
)
);
}
test_field_m();
fn test_field_n() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<LmnRime>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).n) as usize - ptr as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(LmnRime),
"::",
stringify!(n)
)
);
}
test_field_n();
}
#[doc = " Parameters describing a Gaussian (also applicable to shapelets)."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GaussianParams {
pub maj: f64,
pub min: f64,
pub pa: f64,
}
#[test]
fn bindgen_test_layout_GaussianParams() {
assert_eq!(
::std::mem::size_of::<GaussianParams>(),
24usize,
concat!("Size of: ", stringify!(GaussianParams))
);
assert_eq!(
::std::mem::align_of::<GaussianParams>(),
8usize,
concat!("Alignment of ", stringify!(GaussianParams))
);
fn test_field_maj() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<GaussianParams>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).maj) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(GaussianParams),
"::",
stringify!(maj)
)
);
}
test_field_maj();
fn test_field_min() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<GaussianParams>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).min) as usize - ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(GaussianParams),
"::",
stringify!(min)
)
);
}
test_field_min();
fn test_field_pa() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<GaussianParams>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).pa) as usize - ptr as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(GaussianParams),
"::",
stringify!(pa)
)
);
}
test_field_pa();
}
#[doc = " Parameters describing a shapelet coefficient."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ShapeletCoeff {
pub n1: usize,
pub n2: usize,
pub value: f64,
}
#[test]
fn bindgen_test_layout_ShapeletCoeff() {
assert_eq!(
::std::mem::size_of::<ShapeletCoeff>(),
24usize,
concat!("Size of: ", stringify!(ShapeletCoeff))
);
assert_eq!(
::std::mem::align_of::<ShapeletCoeff>(),
8usize,
concat!("Alignment of ", stringify!(ShapeletCoeff))
);
fn test_field_n1() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<ShapeletCoeff>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).n1) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ShapeletCoeff),
"::",
stringify!(n1)
)
);
}
test_field_n1();
fn test_field_n2() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<ShapeletCoeff>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).n2) as usize - ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ShapeletCoeff),
"::",
stringify!(n2)
)
);
}
test_field_n2();
fn test_field_value() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<ShapeletCoeff>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(ShapeletCoeff),
"::",
stringify!(value)
)
);
}
test_field_value();
}
#[doc = " (u,v) coordinates for a shapelet. W isn't used, so we're a bit more efficient"]
#[doc = " by not using UVW."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ShapeletUV {
pub u: f64,
pub v: f64,
}
#[test]
fn bindgen_test_layout_ShapeletUV() {
assert_eq!(
::std::mem::size_of::<ShapeletUV>(),
16usize,
concat!("Size of: ", stringify!(ShapeletUV))
);
assert_eq!(
::std::mem::align_of::<ShapeletUV>(),
8usize,
concat!("Alignment of ", stringify!(ShapeletUV))
);
fn test_field_u() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<ShapeletUV>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(ShapeletUV),
"::",
stringify!(u)
)
);
}
test_field_u();
fn test_field_v() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<ShapeletUV>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).v) as usize - ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ShapeletUV),
"::",
stringify!(v)
)
);
}
test_field_v();
}
#[doc = " A Jones matrix, single precision. The floats are unpacked into real and imag"]
#[doc = " components because complex numbers don't traverse the FFI boundary well."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JonesF32 {
pub xx_re: f32,
pub xx_im: f32,
pub xy_re: f32,
pub xy_im: f32,
pub yx_re: f32,
pub yx_im: f32,
pub yy_re: f32,
pub yy_im: f32,
}
#[test]
fn bindgen_test_layout_JonesF32() {
assert_eq!(
::std::mem::size_of::<JonesF32>(),
32usize,
concat!("Size of: ", stringify!(JonesF32))
);
assert_eq!(
::std::mem::align_of::<JonesF32>(),
4usize,
concat!("Alignment of ", stringify!(JonesF32))
);
fn test_field_xx_re() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<JonesF32>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).xx_re) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(JonesF32),
"::",
stringify!(xx_re)
)
);
}
test_field_xx_re();
fn test_field_xx_im() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<JonesF32>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).xx_im) as usize - ptr as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(JonesF32),
"::",
stringify!(xx_im)
)
);
}
test_field_xx_im();
fn test_field_xy_re() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<JonesF32>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).xy_re) as usize - ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(JonesF32),
"::",
stringify!(xy_re)
)
);
}
test_field_xy_re();
fn test_field_xy_im() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<JonesF32>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).xy_im) as usize - ptr as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(JonesF32),
"::",
stringify!(xy_im)
)
);
}
test_field_xy_im();
fn test_field_yx_re() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<JonesF32>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).yx_re) as usize - ptr as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(JonesF32),
"::",
stringify!(yx_re)
)
);
}
test_field_yx_re();
fn test_field_yx_im() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<JonesF32>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).yx_im) as usize - ptr as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(JonesF32),
"::",
stringify!(yx_im)
)
);
}
test_field_yx_im();
fn test_field_yy_re() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<JonesF32>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).yy_re) as usize - ptr as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(JonesF32),
"::",
stringify!(yy_re)
)
);
}
test_field_yy_re();
fn test_field_yy_im() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<JonesF32>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).yy_im) as usize - ptr as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(JonesF32),
"::",
stringify!(yy_im)
)
);
}
test_field_yy_im();
}
#[doc = " A Jones matrix, double precision. The floats are unpacked into real and imag"]
#[doc = " components because complex numbers don't traverse the FFI boundary well."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JonesF64 {
pub xx_re: f64,
pub xx_im: f64,
pub xy_re: f64,
pub xy_im: f64,
pub yx_re: f64,
pub yx_im: f64,
pub yy_re: f64,
pub yy_im: f64,
}
#[test]
fn bindgen_test_layout_JonesF64() {
assert_eq!(
::std::mem::size_of::<JonesF64>(),
64usize,
concat!("Size of: ", stringify!(JonesF64))
);
assert_eq!(
::std::mem::align_of::<JonesF64>(),
8usize,
concat!("Alignment of ", stringify!(JonesF64))
);
fn test_field_xx_re() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<JonesF64>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).xx_re) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(JonesF64),
"::",
stringify!(xx_re)
)
);
}
test_field_xx_re();
fn test_field_xx_im() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<JonesF64>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).xx_im) as usize - ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(JonesF64),
"::",
stringify!(xx_im)
)
);
}
test_field_xx_im();
fn test_field_xy_re() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<JonesF64>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).xy_re) as usize - ptr as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(JonesF64),
"::",
stringify!(xy_re)
)
);
}
test_field_xy_re();
fn test_field_xy_im() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<JonesF64>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).xy_im) as usize - ptr as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(JonesF64),
"::",
stringify!(xy_im)
)
);
}
test_field_xy_im();
fn test_field_yx_re() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<JonesF64>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).yx_re) as usize - ptr as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(JonesF64),
"::",
stringify!(yx_re)
)
);
}
test_field_yx_re();
fn test_field_yx_im() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<JonesF64>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).yx_im) as usize - ptr as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(JonesF64),
"::",
stringify!(yx_im)
)
);
}
test_field_yx_im();
fn test_field_yy_re() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<JonesF64>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).yy_re) as usize - ptr as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(JonesF64),
"::",
stringify!(yy_re)
)
);
}
test_field_yy_re();
fn test_field_yy_im() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<JonesF64>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).yy_im) as usize - ptr as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(JonesF64),
"::",
stringify!(yy_im)
)
);
}
test_field_yy_im();
}
#[doc = " All the parameters needed to describe point-source components."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Points {
pub num_power_law_points: usize,
pub power_law_lmns: *mut LmnRime,
pub power_law_fds: *mut JonesF64,
pub power_law_sis: *mut f64,
pub num_curved_power_law_points: usize,
pub curved_power_law_lmns: *mut LmnRime,
pub curved_power_law_fds: *mut JonesF64,
pub curved_power_law_sis: *mut f64,
pub curved_power_law_qs: *mut f64,
pub num_list_points: usize,
pub list_lmns: *mut LmnRime,
pub list_fds: *mut JonesF64,
}
#[test]
fn bindgen_test_layout_Points() {
assert_eq!(
::std::mem::size_of::<Points>(),
96usize,
concat!("Size of: ", stringify!(Points))
);
assert_eq!(
::std::mem::align_of::<Points>(),
8usize,
concat!("Alignment of ", stringify!(Points))
);
fn test_field_num_power_law_points() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Points>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).num_power_law_points) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(Points),
"::",
stringify!(num_power_law_points)
)
);
}
test_field_num_power_law_points();
fn test_field_power_law_lmns() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Points>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).power_law_lmns) as usize - ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(Points),
"::",
stringify!(power_law_lmns)
)
);
}
test_field_power_law_lmns();
fn test_field_power_law_fds() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Points>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).power_law_fds) as usize - ptr as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(Points),
"::",
stringify!(power_law_fds)
)
);
}
test_field_power_law_fds();
fn test_field_power_law_sis() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Points>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).power_law_sis) as usize - ptr as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(Points),
"::",
stringify!(power_law_sis)
)
);
}
test_field_power_law_sis();
fn test_field_num_curved_power_law_points() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Points>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).num_curved_power_law_points) as usize - ptr as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(Points),
"::",
stringify!(num_curved_power_law_points)
)
);
}
test_field_num_curved_power_law_points();
fn test_field_curved_power_law_lmns() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Points>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).curved_power_law_lmns) as usize - ptr as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(Points),
"::",
stringify!(curved_power_law_lmns)
)
);
}
test_field_curved_power_law_lmns();
fn test_field_curved_power_law_fds() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Points>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).curved_power_law_fds) as usize - ptr as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(Points),
"::",
stringify!(curved_power_law_fds)
)
);
}
test_field_curved_power_law_fds();
fn test_field_curved_power_law_sis() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Points>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).curved_power_law_sis) as usize - ptr as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(Points),
"::",
stringify!(curved_power_law_sis)
)
);
}
test_field_curved_power_law_sis();
fn test_field_curved_power_law_qs() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Points>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).curved_power_law_qs) as usize - ptr as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(Points),
"::",
stringify!(curved_power_law_qs)
)
);
}
test_field_curved_power_law_qs();
fn test_field_num_list_points() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Points>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).num_list_points) as usize - ptr as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(Points),
"::",
stringify!(num_list_points)
)
);
}
test_field_num_list_points();
fn test_field_list_lmns() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Points>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).list_lmns) as usize - ptr as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(Points),
"::",
stringify!(list_lmns)
)
);
}
test_field_list_lmns();
fn test_field_list_fds() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Points>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).list_fds) as usize - ptr as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(Points),
"::",
stringify!(list_fds)
)
);
}
test_field_list_fds();
}
#[doc = " All the parameters needed to describe Gaussian components."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Gaussians {
pub num_power_law_gaussians: usize,
pub power_law_lmns: *mut LmnRime,
pub power_law_fds: *mut JonesF64,
pub power_law_sis: *mut f64,
pub power_law_gps: *mut GaussianParams,
pub num_curved_power_law_gaussians: usize,
pub curved_power_law_lmns: *mut LmnRime,
pub curved_power_law_fds: *mut JonesF64,
pub curved_power_law_sis: *mut f64,
pub curved_power_law_qs: *mut f64,
pub curved_power_law_gps: *mut GaussianParams,
pub num_list_gaussians: usize,
pub list_lmns: *mut LmnRime,
pub list_fds: *mut JonesF64,
pub list_gps: *mut GaussianParams,
}
#[test]
fn bindgen_test_layout_Gaussians() {
assert_eq!(
::std::mem::size_of::<Gaussians>(),
120usize,
concat!("Size of: ", stringify!(Gaussians))
);
assert_eq!(
::std::mem::align_of::<Gaussians>(),
8usize,
concat!("Alignment of ", stringify!(Gaussians))
);
fn test_field_num_power_law_gaussians() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Gaussians>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).num_power_law_gaussians) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(Gaussians),
"::",
stringify!(num_power_law_gaussians)
)
);
}
test_field_num_power_law_gaussians();
fn test_field_power_law_lmns() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Gaussians>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).power_law_lmns) as usize - ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(Gaussians),
"::",
stringify!(power_law_lmns)
)
);
}
test_field_power_law_lmns();
fn test_field_power_law_fds() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Gaussians>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).power_law_fds) as usize - ptr as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(Gaussians),
"::",
stringify!(power_law_fds)
)
);
}
test_field_power_law_fds();
fn test_field_power_law_sis() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Gaussians>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).power_law_sis) as usize - ptr as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(Gaussians),
"::",
stringify!(power_law_sis)
)
);
}
test_field_power_law_sis();
fn test_field_power_law_gps() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Gaussians>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).power_law_gps) as usize - ptr as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(Gaussians),
"::",
stringify!(power_law_gps)
)
);
}
test_field_power_law_gps();
fn test_field_num_curved_power_law_gaussians() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Gaussians>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).num_curved_power_law_gaussians) as usize - ptr as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(Gaussians),
"::",
stringify!(num_curved_power_law_gaussians)
)
);
}
test_field_num_curved_power_law_gaussians();
fn test_field_curved_power_law_lmns() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Gaussians>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).curved_power_law_lmns) as usize - ptr as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(Gaussians),
"::",
stringify!(curved_power_law_lmns)
)
);
}
test_field_curved_power_law_lmns();
fn test_field_curved_power_law_fds() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Gaussians>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).curved_power_law_fds) as usize - ptr as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(Gaussians),
"::",
stringify!(curved_power_law_fds)
)
);
}
test_field_curved_power_law_fds();
fn test_field_curved_power_law_sis() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Gaussians>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).curved_power_law_sis) as usize - ptr as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(Gaussians),
"::",
stringify!(curved_power_law_sis)
)
);
}
test_field_curved_power_law_sis();
fn test_field_curved_power_law_qs() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Gaussians>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).curved_power_law_qs) as usize - ptr as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(Gaussians),
"::",
stringify!(curved_power_law_qs)
)
);
}
test_field_curved_power_law_qs();
fn test_field_curved_power_law_gps() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Gaussians>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).curved_power_law_gps) as usize - ptr as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(Gaussians),
"::",
stringify!(curved_power_law_gps)
)
);
}
test_field_curved_power_law_gps();
fn test_field_num_list_gaussians() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Gaussians>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).num_list_gaussians) as usize - ptr as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(Gaussians),
"::",
stringify!(num_list_gaussians)
)
);
}
test_field_num_list_gaussians();
fn test_field_list_lmns() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Gaussians>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).list_lmns) as usize - ptr as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(Gaussians),
"::",
stringify!(list_lmns)
)
);
}
test_field_list_lmns();
fn test_field_list_fds() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Gaussians>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).list_fds) as usize - ptr as usize
},
104usize,
concat!(
"Offset of field: ",
stringify!(Gaussians),
"::",
stringify!(list_fds)
)
);
}
test_field_list_fds();
fn test_field_list_gps() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Gaussians>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).list_gps) as usize - ptr as usize
},
112usize,
concat!(
"Offset of field: ",
stringify!(Gaussians),
"::",
stringify!(list_gps)
)
);
}
test_field_list_gps();
}
#[doc = " All the parameters needed to describe Shapelet components."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Shapelets {
pub num_power_law_shapelets: usize,
pub power_law_lmns: *mut LmnRime,
pub power_law_fds: *mut JonesF64,
pub power_law_sis: *mut f64,
pub power_law_gps: *mut GaussianParams,
pub power_law_shapelet_uvs: *mut ShapeletUV,
pub power_law_shapelet_coeffs: *mut ShapeletCoeff,
pub power_law_num_shapelet_coeffs: *mut usize,
pub num_curved_power_law_shapelets: usize,
pub curved_power_law_lmns: *mut LmnRime,
pub curved_power_law_fds: *mut JonesF64,
pub curved_power_law_sis: *mut f64,
pub curved_power_law_qs: *mut f64,
pub curved_power_law_gps: *mut GaussianParams,
pub curved_power_law_shapelet_uvs: *mut ShapeletUV,
pub curved_power_law_shapelet_coeffs: *mut ShapeletCoeff,
pub curved_power_law_num_shapelet_coeffs: *mut usize,
pub num_list_shapelets: usize,
pub list_lmns: *mut LmnRime,
pub list_fds: *mut JonesF64,
pub list_gps: *mut GaussianParams,
pub list_shapelet_uvs: *mut ShapeletUV,
pub list_shapelet_coeffs: *mut ShapeletCoeff,
pub list_num_shapelet_coeffs: *mut usize,
}
#[test]
fn bindgen_test_layout_Shapelets() {
assert_eq!(
::std::mem::size_of::<Shapelets>(),
192usize,
concat!("Size of: ", stringify!(Shapelets))
);
assert_eq!(
::std::mem::align_of::<Shapelets>(),
8usize,
concat!("Alignment of ", stringify!(Shapelets))
);
fn test_field_num_power_law_shapelets() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).num_power_law_shapelets) as usize - ptr as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(num_power_law_shapelets)
)
);
}
test_field_num_power_law_shapelets();
fn test_field_power_law_lmns() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).power_law_lmns) as usize - ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(power_law_lmns)
)
);
}
test_field_power_law_lmns();
fn test_field_power_law_fds() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).power_law_fds) as usize - ptr as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(power_law_fds)
)
);
}
test_field_power_law_fds();
fn test_field_power_law_sis() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).power_law_sis) as usize - ptr as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(power_law_sis)
)
);
}
test_field_power_law_sis();
fn test_field_power_law_gps() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).power_law_gps) as usize - ptr as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(power_law_gps)
)
);
}
test_field_power_law_gps();
fn test_field_power_law_shapelet_uvs() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).power_law_shapelet_uvs) as usize - ptr as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(power_law_shapelet_uvs)
)
);
}
test_field_power_law_shapelet_uvs();
fn test_field_power_law_shapelet_coeffs() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).power_law_shapelet_coeffs) as usize - ptr as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(power_law_shapelet_coeffs)
)
);
}
test_field_power_law_shapelet_coeffs();
fn test_field_power_law_num_shapelet_coeffs() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).power_law_num_shapelet_coeffs) as usize - ptr as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(power_law_num_shapelet_coeffs)
)
);
}
test_field_power_law_num_shapelet_coeffs();
fn test_field_num_curved_power_law_shapelets() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).num_curved_power_law_shapelets) as usize - ptr as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(num_curved_power_law_shapelets)
)
);
}
test_field_num_curved_power_law_shapelets();
fn test_field_curved_power_law_lmns() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).curved_power_law_lmns) as usize - ptr as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(curved_power_law_lmns)
)
);
}
test_field_curved_power_law_lmns();
fn test_field_curved_power_law_fds() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).curved_power_law_fds) as usize - ptr as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(curved_power_law_fds)
)
);
}
test_field_curved_power_law_fds();
fn test_field_curved_power_law_sis() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).curved_power_law_sis) as usize - ptr as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(curved_power_law_sis)
)
);
}
test_field_curved_power_law_sis();
fn test_field_curved_power_law_qs() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).curved_power_law_qs) as usize - ptr as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(curved_power_law_qs)
)
);
}
test_field_curved_power_law_qs();
fn test_field_curved_power_law_gps() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).curved_power_law_gps) as usize - ptr as usize
},
104usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(curved_power_law_gps)
)
);
}
test_field_curved_power_law_gps();
fn test_field_curved_power_law_shapelet_uvs() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).curved_power_law_shapelet_uvs) as usize - ptr as usize
},
112usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(curved_power_law_shapelet_uvs)
)
);
}
test_field_curved_power_law_shapelet_uvs();
fn test_field_curved_power_law_shapelet_coeffs() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).curved_power_law_shapelet_coeffs) as usize
- ptr as usize
},
120usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(curved_power_law_shapelet_coeffs)
)
);
}
test_field_curved_power_law_shapelet_coeffs();
fn test_field_curved_power_law_num_shapelet_coeffs() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).curved_power_law_num_shapelet_coeffs) as usize
- ptr as usize
},
128usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(curved_power_law_num_shapelet_coeffs)
)
);
}
test_field_curved_power_law_num_shapelet_coeffs();
fn test_field_num_list_shapelets() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).num_list_shapelets) as usize - ptr as usize
},
136usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(num_list_shapelets)
)
);
}
test_field_num_list_shapelets();
fn test_field_list_lmns() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).list_lmns) as usize - ptr as usize
},
144usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(list_lmns)
)
);
}
test_field_list_lmns();
fn test_field_list_fds() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).list_fds) as usize - ptr as usize
},
152usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(list_fds)
)
);
}
test_field_list_fds();
fn test_field_list_gps() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).list_gps) as usize - ptr as usize
},
160usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(list_gps)
)
);
}
test_field_list_gps();
fn test_field_list_shapelet_uvs() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).list_shapelet_uvs) as usize - ptr as usize
},
168usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(list_shapelet_uvs)
)
);
}
test_field_list_shapelet_uvs();
fn test_field_list_shapelet_coeffs() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).list_shapelet_coeffs) as usize - ptr as usize
},
176usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(list_shapelet_coeffs)
)
);
}
test_field_list_shapelet_coeffs();
fn test_field_list_num_shapelet_coeffs() {
assert_eq!(
unsafe {
let uninit = ::std::mem::MaybeUninit::<Shapelets>::uninit();
let ptr = uninit.as_ptr();
::std::ptr::addr_of!((*ptr).list_num_shapelet_coeffs) as usize - ptr as usize
},
184usize,
concat!(
"Offset of field: ",
stringify!(Shapelets),
"::",
stringify!(list_num_shapelet_coeffs)
)
);
}
test_field_list_num_shapelet_coeffs();
}
pub const POWER_LAW_FD_REF_FREQ: f64 = 150000000.0;
extern "C" {
#[doc = " Generate sky-model visibilities for a single timestep given multiple"]
#[doc = " sky-model point-source components."]
#[doc = ""]
#[doc = " `points` contains coordinates and flux densities for their respective"]
#[doc = " component types. The components are further split into \"power law\", \"curved"]
#[doc = " power law\" and \"list\" types; this is done for efficiency. For the list types,"]
#[doc = " the flux densities (\"fds\") are two-dimensional arrays, of which the first"]
#[doc = " axis corresponds to frequency and the second component."]
#[doc = ""]
#[doc = " `a` is the populated `Addresses` struct needed to do any sky modelling."]
#[doc = ""]
#[doc = " `d_uvws` has one element per baseline."]
#[doc = ""]
#[doc = " `d_beam_jones` is the beam response used for each unique tile, unique"]
#[doc = " frequency and direction. The metadata within `a` allows disambiguation of"]
#[doc = " which tile and frequency should use which set of responses."]
pub fn model_points(
points: *const Points,
a: *const Addresses,
d_uvws: *const UVW,
d_beam_jones: *const ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Generate sky-model visibilities for a single timestep given multiple"]
#[doc = " sky-model Gaussian components. See the documentation of `model_points` for"]
#[doc = " more info."]
pub fn model_gaussians(
gaussians: *const Gaussians,
a: *const Addresses,
d_uvws: *const UVW,
d_beam_jones: *const ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Generate sky-model visibilities for a single timestep given multiple"]
#[doc = " sky-model shapelet components. See the documentation of `model_points` for"]
#[doc = " more info."]
pub fn model_shapelets(
shapelets: *const Shapelets,
a: *const Addresses,
d_uvws: *const UVW,
d_beam_jones: *const ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}