oat_rust 0.2.0

User-friendly tools for applied topology
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! Permutations on simplices induced by permutations on vertices

use crate::utilities::indexing_and_bijection::{compose_f_after_g, sort_perm_by_key};




//  ===========================================================================
//  ===========================================================================
//  SIMPLEX - AS - SORTED VECTOR
//  ===========================================================================
//  ===========================================================================

//  ---------------------------------------------------------------------------
//  PERMUTATION ON SIMPLICES INDUCED BY PERMUTATION ON VERTICES
//  ---------------------------------------------------------------------------


/// Obtain an argsort permutation on simplices from a permutation on vertices.
/// 
/// Given a vector f = [f0, .., fn] representing a function of form 
/// f: old_vertex_number -> new_vertex_number, obtain the vector 
/// g: old_simplex_number -> new_simplex_number; here "number" refers to 
/// lexicographic order. 
/// 
/// This function does not assume that the `simplex_sequence` has lexicogrphic 
/// order, but it **does** assume that the new simplex sequence has lexicographic
/// order.
pub fn simplex_perm_o2n_from_vertex_perm_o2n( 
    simplex_sequence:           &   Vec< Vec< usize > >,
    vertex_perm_old_to_new:     &   Vec< usize >
    ) 
    ->
    Vec< usize >
{
    // let mut get_key = 
    //     | x | 
    //     {
    //         let mut new = compose_f_after_g( &vertex_perm_old_to_new, x );
    //         new.sort();
    //         new
    //     };

    sort_perm_by_key( simplex_sequence, 
            | x | 
            {
                let mut new = compose_f_after_g( vertex_perm_old_to_new, x );
                new.sort();
                new
            } 
        )
    // // Create vector of new simplices
    // let mut new_simplex_sequence =  Vec::from_iter(
    //                                     simplex_sequence
    //                                         .iter()
    //                                         .cloned()
    //                                         .map(
    //                                             |x|
    //                                             Simplex{ 
    //                                                 vertices:  compose_f_after_g( &vertex_perm_old_to_new, &x )
    //                                             }
    //                                         )
    //                                 );

    // // We must remember to sort the new vertices                                    
    // for simplex in new_simplex_sequence.iter_mut() { simplex.vertices.sort()}

    // // Obtain the sort permutation
    // sort_perm( &new_simplex_sequence )
}







#[cfg(test)]
mod tests {
    // Note this useful idiom: importing names from outer (for mod tests) scope.
    use super::*;
    use crate::topology::simplicial::simplices::unweighted::Simplex;
    use crate::topology::simplicial::simplices::vector::dimension_0_through_d_simplices_in_dimensionwise_lexicographic_order_list;
    use crate::utilities::indexing_and_bijection::{inverse_perm};
    use crate::utilities::sequences_and_ordinals::SortedVec;
    use std::iter::FromIterator;

    #[test]
    fn test_simplex_perm_o2n_from_vertex_perm_o2n() {

        // sequence_old:          [[0], [1], [2], [3], [0, 1], [0, 2], [0, 3], [1, 2]]
        // sequence_old_permuted: [[0], [1], [3], [2], [0, 1], [0, 3], [0, 2], [1, 2]]
        // new_sequence:          [[0], [1], [2], [3], [0, 1], [0, 2], [0, 3], [1, 3]]
        // permutation: simplex old -> new 
        //                        [ 0,   1,   3,   2,   4,      6,      5,      7]


        let complex_facets          =   vec![  vec![0,1,2], vec![0, 3] ];
        let complex_facets  =   complex_facets.into_iter().map(|x| SortedVec::new(x).unwrap() ).collect();
        let simplex_sequence_old    =   dimension_0_through_d_simplices_in_dimensionwise_lexicographic_order_list( &complex_facets, 1);   
        let perm_v_o2n              =   vec![0, 1, 3, 2];

        let mut simplex_sequence_new =  Vec::from_iter(
            simplex_sequence_old
                .iter()
                .cloned()
                .map(
                    |x|
                    Simplex{ 
                        vertices:  compose_f_after_g( &perm_v_o2n, &x )
                    }
                )
        );        

        // We must remember to sort the new vertices                                    
        for simplex in simplex_sequence_new.iter_mut() { simplex.vertices.sort() }        

        // perm: simplex OLD -> NEW
        let perm_s_o2n              =   simplex_perm_o2n_from_vertex_perm_o2n( &simplex_sequence_old, &perm_v_o2n );
        // perm: simplex NEW -> OLD
        let perm_s_n2o               =   inverse_perm( &perm_s_o2n );

        let simplex_sequence_permuted    =   compose_f_after_g( &simplex_sequence_old, &perm_s_n2o );

        let mut simplex_sequence_permuted_vertex_translated     =   simplex_sequence_permuted.clone();
        for i in 0..simplex_sequence_permuted_vertex_translated.len() { simplex_sequence_permuted_vertex_translated[i] = compose_f_after_g( & perm_v_o2n, & simplex_sequence_permuted[i]) };
        for i in 0..simplex_sequence_permuted_vertex_translated.len() { simplex_sequence_permuted_vertex_translated[i].sort() };        
        

        println!("sequence_old:          {:?}",     & simplex_sequence_old );
        println!("sequence_old_permuted: {:?}",     & simplex_sequence_permuted );        
        println!("new_sequence:          {:?}",     & simplex_sequence_permuted_vertex_translated );     
        println!("permutation: simplex old -> new {:?}", & perm_s_o2n);           

    }


}