text_archive.hpp 5.95 KB
Newer Older
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
//| Copyright Inria May 2015
//| This project has received funding from the European Research Council (ERC) under
//| the European Union's Horizon 2020 research and innovation programme (grant
//| agreement No 637972) - see http://www.resibots.eu
//|
//| Contributor(s):
//|   - Jean-Baptiste Mouret (jean-baptiste.mouret@inria.fr)
//|   - Antoine Cully (antoinecully@gmail.com)
//|   - Konstantinos Chatzilygeroudis (konstantinos.chatzilygeroudis@inria.fr)
//|   - Federico Allocati (fede.allocati@gmail.com)
//|   - Vaios Papaspyros (b.papaspyros@gmail.com)
//|   - Roberto Rama (bertoski@gmail.com)
//|
//| This software is a computer library whose purpose is to optimize continuous,
//| black-box functions. It mainly implements Gaussian processes and Bayesian
//| optimization.
//| Main repository: http://github.com/resibots/limbo
//| Documentation: http://www.resibots.eu/limbo
//|
//| This software is governed by the CeCILL-C license under French law and
//| abiding by the rules of distribution of free software.  You can  use,
//| modify and/ or redistribute the software under the terms of the CeCILL-C
//| license as circulated by CEA, CNRS and INRIA at the following URL
//| "http://www.cecill.info".
//|
//| As a counterpart to the access to the source code and  rights to copy,
//| modify and redistribute granted by the license, users are provided only
//| with a limited warranty  and the software's author,  the holder of the
//| economic rights,  and the successive licensors  have only  limited
//| liability.
//|
//| In this respect, the user's attention is drawn to the risks associated
//| with loading,  using,  modifying and/or developing or reproducing the
//| software by the user in light of its specific status of free software,
//| that may mean  that it is complicated to manipulate,  and  that  also
//| therefore means  that it is reserved for developers  and  experienced
//| professionals having in-depth computer knowledge. Users are therefore
//| encouraged to load and test the software's suitability as regards their
//| requirements in conditions enabling the security of their systems and/or
//| data to be ensured and,  more generally, to use and operate it in the
//| same conditions as regards security.
//|
//| The fact that you are presently reading this means that you have had
//| knowledge of the CeCILL-C license and that you accept its terms.
//|
46
47
48
49
#include <cassert>
#include <iostream>
#include <sstream>
#include <string>
50

51
52
// Quick hack for definition of 'I' in <complex.h>
#undef I
53
#include <boost/filesystem.hpp>
54

55
56
57
58
59
60
61
62
#include <Eigen/Core>

namespace limbo {
    namespace serialize {

        class TextArchive {
        public:
            TextArchive(const std::string& dir_name) : _dir_name(dir_name),
63
                                                       _fmt(Eigen::FullPrecision, Eigen::DontAlignCols, " ", "\n", "", "") {}
64
65

            /// write an Eigen::Matrix*
66
            void save(const Eigen::MatrixXd& v, const std::string& object_name) const
67
68
69
70
71
            {
                _create_directory();
                std::ofstream ofs(fname(object_name).c_str());
                ofs << v.format(_fmt) << std::endl;
            }
72

73
74
            /// write a vector of Eigen::Vector*
            template <typename T>
75
            void save(const std::vector<T>& v, const std::string& object_name) const
76
77
78
79
            {
                _create_directory();
                std::ofstream ofs(fname(object_name).c_str());
                for (auto& x : v) {
80
                    ofs << x.transpose().format(_fmt) << std::endl;
81
82
83
84
85
                }
            }

            /// load an Eigen matrix (or vector)
            template <typename M>
86
            void load(M& m, const std::string& object_name) const
87
88
89
90
91
92
93
94
95
96
            {
                auto values = _load(object_name);
                m.resize(values.size(), values[0].size());
                for (size_t i = 0; i < values.size(); ++i)
                    for (size_t j = 0; j < values[i].size(); ++j)
                        m(i, j) = values[i][j];
            }

            /// load a vector of Eigen::Vector*
            template <typename V>
97
            void load(std::vector<V>& m_list, const std::string& object_name) const
98
99
            {
                m_list.clear();
100
                auto values = _load(object_name);
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
                assert(!values.empty());
                for (size_t i = 0; i < values.size(); ++i) {
                    V v(values[i].size());
                    for (size_t j = 0; j < values[i].size(); ++j)
                        v(j) = values[i][j];
                    m_list.push_back(v);
                }
                assert(!m_list.empty());
            }

            std::string fname(const std::string& object_name) const
            {
                return _dir_name + "/" + object_name + ".dat";
            }

116
            const std::string& directory() const
117
118
119
120
            {
                return _dir_name;
            }

121
122
        protected:
            std::string _dir_name;
123
124
            Eigen::IOFormat _fmt;

125
            void _create_directory() const
126
127
            {
                boost::filesystem::path my_path(_dir_name);
128
                boost::filesystem::create_directories(my_path);
129
            }
130

131
            std::vector<std::vector<double>> _load(const std::string& object_name) const
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
            {
                std::ifstream ifs(fname(object_name).c_str());
                assert(ifs.good() && "file not found");
                std::string line;
                std::vector<std::vector<double>> v;
                while (std::getline(ifs, line)) {
                    std::stringstream line_stream(line);
                    std::string cell;
                    std::vector<double> line;
                    while (std::getline(line_stream, cell, ' '))
                        line.push_back(std::stod(cell));
                    v.push_back(line);
                }
                assert(!v.empty() && "empty file");
                return v;
            }
        };
    } // namespace serialize
} // namespace limbo