nmr-schedule 0.2.1

Algorithms for NMR Non-Uniform Sampling
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use core::{fmt::Display, marker::PhantomData};

use crate::{
    generators::{Generator, Trace},
    modifier, Schedule,
};

pub(crate) mod generators {
    use core::marker::PhantomData;

    use ndarray::Dimension;

    use crate::Schedule;

    /// The generator after applying [`super::Iterate`]
    #[derive(Debug)]
    pub struct IterateGenerator<Dim: Dimension, T, F: Fn(&Schedule<Dim>) -> f64> {
        pub(crate) generator: T,
        pub(crate) iterations: u64,
        pub(crate) scorer: F,
        pub(crate) phantom: PhantomData<Dim>,
    }
}

use alloc::borrow::ToOwned;
use generators::*;
use ndarray::Dimension;

use super::Modifier;

/// Debug information for `Iterate`
#[derive(Clone, Copy, Debug)]
pub struct IterateTrace {
    /// Which `iteration` value gave the highest score
    pub best_iteration: u64,
    /// What the best score was
    pub best_score: f64,
}

impl Display for IterateTrace {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(
            f,
            "Best iteration: {}, Best score: {}",
            self.best_iteration, self.best_score
        )
    }
}

impl<Dim: Dimension, T: Generator<Dim>, F: Fn(&Schedule<Dim>) -> f64> Generator<Dim>
    for IterateGenerator<Dim, T, F>
{
    fn _generate(&self, count: usize, dims: Dim, iteration: u64) -> Trace<Dim> {
        assert!(self.iterations > 0);
        let mut best_iteration = 0;
        let mut best_trace = None;
        let mut best_score = f64::INFINITY;

        for i in 0..self.iterations {
            let trace = self.generator.generate_with_iter_and_trace(
                count,
                dims.to_owned(),
                i + iteration * self.iterations,
            );
            let score = (self.scorer)(trace.sched());

            if score < best_score {
                best_iteration = i;
                best_trace = Some(trace);
                best_score = score;
            }
        }

        let best_trace = best_trace.unwrap();

        let sched = best_trace.sched().to_owned();

        best_trace.with(
            sched,
            IterateTrace {
                best_iteration,
                best_score,
            },
        )
    }
}

modifier!(
    Dim <F: Fn(&Schedule<Dim>) -> f64> Iterate,
    IterateBuilder,
    r"Generate many schedules each using different iteration parameters and choose the one that minimizes the value returned by `scorer`.",
    iterate,
    iterations: u64,
    scorer: F
);
// modifier!(
//     Dim <F: Fn(&Schedule<Dim>) -> f64> Iterate,
//     IterateBuilder,
//     r"Generate many schedules each using different iteration parameters and choose the one that minimizes the value returned by `scorer`.",
//     iterate,
//     iterations: usize,
//     scorer: F
// );

impl<Dim: Dimension, F: Fn(&Schedule<Dim>) -> f64> Modifier<Dim> for Iterate<Dim, F> {
    type Output<T: Generator<Dim>> = IterateGenerator<Dim, T, F>;

    fn modify<T: Generator<Dim>>(self, generator: T) -> Self::Output<T> {
        IterateGenerator {
            generator,
            iterations: self.0,
            scorer: self.1,
            phantom: PhantomData,
        }
    }
}