Skip to main content

iasinat_lib/
utils.rs

1use super::*;
2
3pub fn u16_to_f32(x:u16,s:f32)->f32 {
4    if x == u16::MAX {
5	f32::NAN
6    } else {
7	x as f32 / s
8    }
9}
10
11pub fn u32_to_f64(x:u32,s:f64)->f64 {
12    if x == u32::MAX {
13	f64::NAN
14    } else {
15	x as f64 / s
16    }
17}
18
19pub fn i16_to_f32(x:i16,s:f32)->f32 {
20    if x == i16::MIN || x == i16::MAX {
21	f32::NAN
22    } else {
23	x as f32 / s
24    }
25}
26
27pub fn i32_to_f64(x:i32,s:f64)->f64 {
28    if x == i32::MIN {
29	f64::NAN
30    } else {
31	x as f64 / s
32    }
33}
34
35pub fn read_vec_map<R,T,U,F>(rd:&mut NatReader<R>,n:usize,mut f:F)->Result<Vec<U>>
36where
37    R:Read + Seek,
38    T:ReadBinBig,
39    F:FnMut(&T)->U
40{
41    let mut v = Vec::with_capacity(n);
42    for _ in 0..n {
43	let x = T::read_bin(rd)?;
44	let y = f(&x);
45	v.push(y);
46    }
47    Ok(v)
48}
49
50pub fn read_vec_and_scale<R:Read+Seek>(rd:&mut NatReader<R>,scale:f64)
51				   ->Result<Vec<f64>>
52{
53    let n = u8::read_bin(rd)? as usize;
54    read_vec_map(rd,n,|&x:&u32|->f64 { x as f64 / scale })
55}
56
57pub fn read_a2_map<R,T,U,F>(rd:&mut NatReader<R>,
58			(d1,d2):(usize,usize),
59			f:F)->Result<Array2<U>>
60where
61    R:Read + Seek,
62    T:ReadBinBig,
63    F:FnMut(&T)->U
64{
65    let v = read_vec_map(rd,d1*d2,f)?;
66    let a : Array2<U> = Array2::from_shape_vec((d1,d2),v)?;
67    Ok(a)
68}
69
70pub fn read_a3_map<R,T,U,F>(rd:&mut NatReader<R>,
71			(d1,d2,d3):(usize,usize,usize),
72			f:F)->Result<Array3<U>>
73where
74    R:Read + Seek,
75    T:ReadBinBig,
76    F:FnMut(&T)->U
77{
78    let v = read_vec_map(rd,d1*d2*d3,f)?;
79    let a : Array3<U> = Array3::from_shape_vec((d1,d2,d3),v)?;
80    Ok(a)
81}
82
83#[derive(Debug)]
84pub struct VInteger4 {
85    pub sf:i8,
86    pub value:i32
87}
88
89impl VInteger4 {
90    pub fn read_bin<R:Read>(mut rd:&mut NatReader<R>)->Result<Self> {
91	let sf = i8::read_bin(&mut rd)?;
92	let value = i32::read_bin(&mut rd)?;
93	Ok(Self { sf,value })
94    }
95}
96
97impl From<VInteger4> for f32 {
98    fn from(v:VInteger4)->f32 {
99	v.value as f32 / 10.0_f32.powi(v.sf as i32)
100    }
101}