copied the templates

mgrid_2/utils.h

@@ -0,0 +1,212 @@
+#pragma once
+
+#include <algorithm>
+#include <cassert>
+#include <iomanip>       // setw
+#include <iostream>
+#include <map>
+#include <numeric>
+#include <utility>        // swap()
+#include <vector>
+
+///**
+ //* Output of a vector of @p v.
+ //*
+ //* @param[in,out] s    output stream
+ //* @param[in]     v    vector
+ //* @return             output stream 
+ //*/
+//template <class T>
+//std::ostream& operator<<(std::ostream &s, const std::vector<T> &v)
+//{
+    //for (auto it: v) { std::cout << "  " << std::setw(5) << it; }
+    //return s;
+//}
+
+
+/**
+ * Determines the permutation vector for sorting @p v ascending with operator< .
+ *
+ * @param[in] v    vector to permute
+ * @return         index vector for permutation, 
+ *                 @p v[idx[0]] denotes the smallest element of original data.
+ */
+template <typename T>
+std::vector<int> sort_indexes(const std::vector<T> &v)
+{
+    // initialize original index locations
+    std::vector<int> idx(v.size());
+    iota(begin(idx),end(idx),0);
+
+    // sort indexes based on comparing values in v
+    sort(idx.begin(), idx.end(),
+           [&v](int i1, int i2) -> bool
+            { return v[i1] < v[i2]; }
+        );
+
+    return idx;
+}
+
+
+/**
+ * Determines the permutation vector for sorting @p v descending with operator> .
+ *
+ * @param[in] v    vector to permute
+ * @return         index vector for permutation, 
+ *                 @p v[idx[0]] denotes the smallest element of original data.
+ */
+template <typename T>
+std::vector<int> sort_indexes_desc(const std::vector<T> &v)
+{
+    // initialize original index locations
+    std::vector<int> idx(v.size());
+    iota(begin(idx),end(idx),0);
+
+    // sort indexes based on comparing values in v
+    sort(idx.begin(), idx.end(),
+           [&v](int i1, int i2) -> bool
+            { return v[i1] > v[i2]; }
+        );
+
+    return idx;
+}
+
+/**
+ * Generates the inverse permutation vector of @p idx.
+ *
+ * @param[in] idx  permutation vector
+ * @return         inverse permutation, 
+ */
+template <typename T>
+std::vector<T> inverse_indexes(const std::vector<T> &idx)
+{
+    static_assert(std::is_integral<T>(),"Vector elements have to be integral numbers.");
+    return sort_indexes(idx);
+}
+
+
+/**
+ * Resort elements of vector @p x according to permutation @p old2new.
+ *
+ * @param[in]     old2new    permutation vector
+ * @param[in,out] x          vector[]
+ */
+template <class T>
+void permute(std::vector<int> const& old2new, std::vector<T> & x)
+{
+    assert(x.size()==old2new.size());
+
+    auto old(x);
+    for (size_t k=0; k<old2new.size(); ++k)
+    {
+        const size_t &k_old = old2new[k];
+        x[k] = old[k_old];
+    }
+}
+
+/**
+ * Resort a vector @p x storing two entries per element 
+ * according to permutation @p old2new.
+ *
+ * @param[in]     old2new    permutation vector
+ * @param[in,out] x          vector[][2]
+ */
+template <class T>
+void permute_2(std::vector<int> const& old2new, std::vector<T> & x)
+{
+    assert(x.size()==2*old2new.size());
+
+    auto old(x);
+    for (size_t k=0; k<old2new.size(); ++k)
+    {
+        const size_t &k_old = old2new[k];
+        x[2*k  ] = old[2*k_old  ];
+        x[2*k+1] = old[2*k_old+1];
+    }
+}
+
+/**
+ * Changes the entries in @p x according to renumbering @p  old2new.
+ *
+ * @param[in]     old2new    renumbering vector
+ * @param[in,out] x          vector
+ */
+template <class T>
+void reNumberEntries(std::vector<T> const& old2new, std::vector<T> & x)
+{
+    static_assert(std::is_integral<T>(),"Vector elements have to be integral numbers.");
+    assert( *max_element(cbegin(x),cend(x)) < static_cast<int>(old2new.size()) );
+    auto old(x);
+    auto const n2o = inverse_indexes(old2new);
+    for (size_t k=0; k<x.size(); ++k)
+    {
+        T const k_old = old[k];
+        x[k] = n2o[k_old];        
+    }
+}
+
+/**
+ * Changes the entries in @p x according to renumbering @p  old2new.
+ *
+ * @param[in]     old2new    renumbering vector
+ * @param[in,out] x          vector
+ */
+template <class T>
+void reNumberEntries(std::vector<T> const& old2new, std::map<T,T> & x)
+{
+    static_assert(std::is_integral<T>(),"Vector elements have to be integral numbers.");
+    assert( max_element(cbegin(x),cend(x))->second < static_cast<int>(old2new.size()) );
+    auto old(x);
+    auto const n2o = inverse_indexes(old2new);   
+    for ( auto &[key,val] : x)
+    {
+        val = n2o[val];
+    }
+}
+
+/**
+ * Sort the two entries per element of vector @p x ascending. 
+ *
+ * @param[in] x          vector[][2]
+ */
+template <class T>
+void sortAscending_2(std::vector<T> & x)
+{
+    static_assert(std::is_integral<T>(),"Vector elements have to be integral numbers.");
+    //for (auto it=begin(x); it!=end(x); it += 2)    // general solution
+    //{
+        //sort(it,it+1);
+    //}
+    
+    for (size_t k=0; k<x.size(); k+=2)               // for only 2 entries
+    {
+        if (x[k]>x[k+1]) { std::swap(x[k],x[k+1]); }
+    }
+}
+
+
+#include <chrono>           // contains timing routines
+typedef std::chrono::system_clock Time;
+typedef std::chrono::milliseconds ms;
+typedef std::chrono::duration<double> dsec;
+
+class MyTimer
+{
+    public:
+    
+    MyTimer() : _tstart(Time::now()) {}
+    
+    void tic()
+    { _tstart = Time::now(); }
+    
+    auto toc()
+    {
+        dsec timed = Time::now() - _tstart;
+        return timed.count();
+    }
+    
+    
+    private:
+    std::chrono::time_point<Time> _tstart;
+    
+};