Mercurial > repos > pointsource_algs / file comparison

comparison: src/types.rs

src/types.rs

branch
dev
changeset 63
7a8a55fd41c0
parent 61
4f468d35fa29
equal deleted inserted replaced
61:4f468d35fa29 63:7a8a55fd41c0
19 { 19 {
20 } 20 }
21 impl ClapFloat for f32 {} 21 impl ClapFloat for f32 {}
22 impl ClapFloat for f64 {} 22 impl ClapFloat for f64 {}
23 23
24 /// Structure for storing transport statistics
25 #[derive(Debug, Clone, Serialize)]
26 pub struct TransportInfo<F: Float = f64> {
27 /// Tuple of (untransported mass, source mass)
28 pub untransported_fraction: (F, F),
29 /// Tuple of (|destination mass - transported_mass|, transported mass)
30 pub transport_error: (F, F),
31 /// Number of readjustment iterations for transport
32 pub readjustment_iters: usize,
33 /// ($∫ c_2 dγ , ∫ dγ$)
34 pub dist: (F, F),
35 }
36
37 #[replace_float_literals(F::cast_from(literal))]
38 impl<F: Float> TransportInfo<F> {
39 /// Initialise transport statistics
40 pub fn new() -> Self {
41 TransportInfo {
42 untransported_fraction: (0.0, 0.0),
43 transport_error: (0.0, 0.0),
44 readjustment_iters: 0,
45 dist: (0.0, 0.0),
46 }
47 }
48 }
49
24 /// Structure for storing iteration statistics 50 /// Structure for storing iteration statistics
25 #[derive(Debug, Clone, Serialize)] 51 #[derive(Debug, Clone, Serialize)]
26 pub struct IterInfo<F: Float = f64> { 52 pub struct IterInfo<F: Float = f64> {
27 /// Function value 53 /// Function value
28 pub value: F, 54 pub value: F,
36 pub merged: usize, 62 pub merged: usize,
37 /// Number of spikes removed by pruning since last IterInfo statistic 63 /// Number of spikes removed by pruning since last IterInfo statistic
38 pub pruned: usize, 64 pub pruned: usize,
39 /// Number of inner iterations since last IterInfo statistic 65 /// Number of inner iterations since last IterInfo statistic
40 pub inner_iters: usize, 66 pub inner_iters: usize,
41 /// Tuple of (transported mass, source mass) 67 /// Transport statistis
42 pub untransported_fraction: Option<(F, F)>, 68 pub transport: Option<TransportInfo<F>>,
43 /// Tuple of (|destination mass - untransported_mass|, transported mass)
44 pub transport_error: Option<(F, F)>,
45 /// Current tolerance 69 /// Current tolerance
46 pub ε: F, 70 pub ε: F,
47 // /// Solve fin.dim problem for this measure to get the optimal `value`. 71 // /// Solve fin.dim problem for this measure to get the optimal `value`.
48 // pub postprocessing : Option<RNDM<N, F>>, 72 // pub postprocessing : Option<RNDM<N, F>>,
49 } 73 }
59 inserted: 0, 83 inserted: 0,
60 pruned: 0, 84 pruned: 0,
61 inner_iters: 0, 85 inner_iters: 0,
62 ε: F::NAN, 86 ε: F::NAN,
63 // postprocessing : None, 87 // postprocessing : None,
64 untransported_fraction: None, 88 transport: None,
65 transport_error: None,
66 } 89 }
90 }
91
92 /// Get mutable reference to transport statistics, creating it if it is `None`.
93 pub fn get_transport_mut(&mut self) -> &mut TransportInfo<F> {
94 if self.transport.is_none() {
95 self.transport = Some(TransportInfo::new());
96 }
97 self.transport.as_mut().unwrap()
67 } 98 }
68 } 99 }
69 100
70 #[replace_float_literals(F::cast_from(literal))] 101 #[replace_float_literals(F::cast_from(literal))]
71 impl<F> LogRepr for IterInfo<F> 102 impl<F> LogRepr for IterInfo<F>
72 where 103 where
73 F: LogRepr + Float, 104 F: LogRepr + Float,
74 { 105 {
75 fn logrepr(&self) -> ColoredString { 106 fn logrepr(&self) -> ColoredString {
76 format!( 107 format!(
77 "{}\t| N = {}, ε = {:.8}, 𝔼inner_it = {}, 𝔼ins/mer/pru = {}/{}/{}{}{}", 108 "{}\t| N = {}, ε = {:.2e}, 𝔼inner_it = {}, 𝔼ins/mer/pru = {}/{}/{}{}",
78 self.value.logrepr(), 109 self.value.logrepr(),
79 self.n_spikes, 110 self.n_spikes,
80 self.ε, 111 self.ε,
81 self.inner_iters as float / self.this_iters.max(1) as float, 112 self.inner_iters as float / self.this_iters.max(1) as float,
82 self.inserted as float / self.this_iters.max(1) as float, 113 self.inserted as float / self.this_iters.max(1) as float,
83 self.merged as float / self.this_iters.max(1) as float, 114 self.merged as float / self.this_iters.max(1) as float,
84 self.pruned as float / self.this_iters.max(1) as float, 115 self.pruned as float / self.this_iters.max(1) as float,
85 match self.untransported_fraction { 116 match &self.transport {
86 None => format!(""), 117 None => format!(""),
87 Some((a, b)) => 118 Some(t) => {
88 if b > 0.0 { 119 let (a1, b1) = t.untransported_fraction;
89 format!(", untransported {:.2}%", 100.0 * a / b) 120 let (a2, b2) = t.transport_error;
90 } else { 121 let (a3, b3) = t.dist;
91 format!("") 122 format!(
92 }, 123 ", γ-un/er/d/it = {:.2}%/{:.2}%/{:.2e}/{:.2}",
93 }, 124 if b1 > 0.0 { 100.0 * a1 / b1 } else { F::NAN },
94 match self.transport_error { 125 if b2 > 0.0 { 100.0 * a2 / b2 } else { F::NAN },
95 None => format!(""), 126 if b3 > 0.0 { a3 / b3 } else { F::NAN },
96 Some((a, b)) => 127 t.readjustment_iters as float / self.this_iters.max(1) as float,
97 if b > 0.0 { 128 )
98 format!(", transport error {:.2}%", 100.0 * a / b) 129 }
99 } else {
100 format!("")
101 },
102 } 130 }
103 ) 131 )
104 .as_str() 132 .as_str()
105 .into() 133 .into()
106 } 134 }
118 } 146 }
119 147
120 #[replace_float_literals(F::cast_from(literal))] 148 #[replace_float_literals(F::cast_from(literal))]
121 impl<F: Float> Default for RefinementSettings<F> { 149 impl<F: Float> Default for RefinementSettings<F> {
122 fn default() -> Self { 150 fn default() -> Self {
123 RefinementSettings { 151 RefinementSettings { tolerance_mult: 0.1, max_steps: 50000 }
124 tolerance_mult: 0.1,
125 max_steps: 50000,
126 }
127 } 152 }
128 } 153 }
129 154
130 /// Data term type 155 /// Data term type
131 #[derive(Clone, Copy, PartialEq, Serialize, Deserialize, Debug)] 156 #[derive(Clone, Copy, PartialEq, Serialize, Deserialize, Debug)]

Mercurial Repository: pointsource_algs

mercurial