Merge branch 'dev' of code.it4i.cz:bes0030/4Neuro into tmp

# Conflicts:
#	src/LearningMethods/GradientDescent.cpp
#	src/examples/net_test_pde_1.cpp

.gitlab-ci.yml

-# Windows 10 with Boost and Exprtk 
+# Windows 10 with Boost, Exprtk and Turtle
 # downloaded and compiled locally as
 # submodules and linked statically
 win_visual_studio_static_local_deps:
@@ -9,6 +9,8 @@ win_visual_studio_static_local_deps:
         - call VsDevCmd.bat
         - cd build_scripts\windows
         - call win_download_dependencies.bat
+        - cd ..\..
+        - cd build_scripts\windows
         - set DEPENDENCIES_LINK_TYPE=static
         - set clean_after=yes
         - call win_VS_build_x64_debug.bat
@@ -19,7 +21,7 @@ win_visual_studio_static_local_deps:
         - call win_run_tests.bat
         - cd ..\..
 
-# Windows 10 with Boost and Exprtk 
+# Windows 10 with Boost, Exprtk and Turtle
 # downloaded and compiled locally as
 # submodules and link dynamically
 #
@@ -59,7 +61,7 @@ win_visual_studio_static_local_deps:
 #        - cd ..\..
 
 
-# Latest Ubuntu with Boost and Exprtk
+# Latest Ubuntu with Boost, Exprtk and Turtle
 # in system directories, Boost
 # installed from the official repository
 # => only dynamical linking possible
@@ -73,8 +75,6 @@ ubuntu_boost_system:
         - rm -rf external_dependencies/boost/*
         - rm -rf external_dependencies/exprtk/*
         - rm -rf exprtk
-        - git clone https://github.com/ArashPartow/exprtk.git
-        - cp exprtk/exprtk.hpp /usr/include
         - export TERM=xterm
         - cd build_scripts/linux
         - export DEPENDENCIES_LINK_TYPE=shared
@@ -87,7 +87,7 @@ ubuntu_boost_system:
         - './linux_run_tests.sh'
         - cd ../..
 
-# Latest Ubuntu with Boost and Exprtk
+# Latest Ubuntu with Boost, Exprtk and Turtle
 # compiled locally as submodules and
 # linked statically
 ubuntu_boost_local_static_deps:
@@ -100,6 +100,8 @@ ubuntu_boost_local_static_deps:
         - export TERM=xterm
         - cd build_scripts/linux
         - ./download_dependencies.sh
+        - cd ../..
+        - cd build_scripts/linux
         - export DEPENDENCIES_LINK_TYPE=static
         - export CLEAN_AFTER=yes
         - ./linux_gcc_build_x64_debug_local.sh
@@ -110,7 +112,7 @@ ubuntu_boost_local_static_deps:
         - './linux_run_tests.sh'
         - cd ../..
 
-# Latest Ubuntu with Boost and Exprtk
+# Latest Ubuntu with Boost, Exprtk and Turtle
 # compiled locally as submodules and
 # linked dynamically
 ubuntu_boost_local_dynamic_deps:
@@ -123,6 +125,8 @@ ubuntu_boost_local_dynamic_deps:
         - export TERM=xterm
         - cd build_scripts/linux
         - ./download_dependencies.sh
+        - cd ../..
+        - cd build_scripts/linux
         - export DEPENDENCIES_LINK_TYPE=shared
         - export CLEAN_AFTER=yes
         - ./linux_gcc_build_x64_debug_local.sh

.gitmodules

@@ -4,3 +4,6 @@
 [submodule "external_dependencies/boost"]
 	path = external_dependencies/boost
 	url = https://github.com/boostorg/boost.git
+[submodule "external_dependencies/turtle"]
+	path = external_dependencies/turtle
+	url = https://github.com/mat007/turtle.git

CMakeLists.txt

@@ -21,7 +21,7 @@ if (NOT CMAKE_BUILD_TYPE)
     set (CMAKE_BUILD_TYPE RELEASE CACHE STRING
          "Choose the type of build, options are: None Debug Release."
          FORCE)
-elseif("CMAKE_BUILD_TYPE" STREQUAL "Debug")
+elseif(CMAKE_BUILD_TYPE STREQUAL "Debug")
     #TODO rewrite to use add_compile_definitions
 endif (NOT CMAKE_BUILD_TYPE)
 
@@ -45,6 +45,8 @@ elseif( "${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC" )
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W0 /bigobj")
     add_compile_options("/D _SCL_SECURE_NO_WARNINGS")
     add_compile_options("/D_CRT_SECURE_NO_WARNINGS")
+elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MINGW")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mbig-obj")
 else()
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
 endif()
@@ -82,9 +84,12 @@ message("Boost_INCLUDE_DIRS: ${Boost_INCLUDE_DIRS}")
 message("Boost_LIBRARY_DIRS: ${Boost_LIBRARY_DIRS}")
 message("Boost_LIBRARIES: ${Boost_LIBRARIES}")
 
-message("lib4neuro LIB DIR: ${LIB4NEURO_DIR}")
-
 find_package(exprtk)
+message("EXPRTK_INCLUDE_DIRS: ${EXPRTK_INCLUDE_DIRS}")
+
+find_package(Turtle)
+message("TURTLE_INCLUDE_DIR: ${TURTLE_INCLUDE_DIR}")
+
 
 #------------------------------------------#
 # Detect maximum available number of cores #

FindBoost.cmake

@@ -59,13 +59,8 @@ find_path(
 # as Boost headers are supposed to be included like
 # #include<boost/...> according to the documentation
 set(TMP "")
-#if(WIN32)
-#    string(REPLACE "\\boost\\boost" "\\boost" TMP ${Boost_INCLUDE_DIRS})
-#    list(APPEND Boost_INCLUDE_DIRS ${TMP})
-#else()
-    string(REPLACE "/boost/boost" "/boost" TMP ${Boost_INCLUDE_DIRS})
-    list(APPEND Boost_INCLUDE_DIRS ${TMP})
-#endif()
+string(REPLACE "/boost/boost" "/boost" TMP ${Boost_INCLUDE_DIRS})
+list(APPEND Boost_INCLUDE_DIRS ${TMP})
 
 if(NOT Boost_INCLUDE_DIRS)
     message(FATAL_ERROR "Boost include directory was not found! Please, set variable BOOST_INCLUDEDIR to the correct path.")

FindTurtle.cmake

+# Find headers and libraries
+FIND_PATH(
+    TURTLE_INCLUDE_DIR
+
+    NAMES
+        mock.hpp
+
+    HINTS
+        $ENV{TURTLE_INCLUDE_DIR}
+        ${TURTLE_INCLUDE_DIR}
+        external_dependencies/turtle
+
+    PATHS
+        /usr
+        /usr/local
+        /home
+        /opt/local
+
+    PATH_SUFFIXES
+        include
+        include/turtle
+)
+# Set TURTLE_FOUND honoring the QUIET and REQUIRED arguments
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(
+    turtle
+    "Turtle was NOT found!"
+    TURTLE_INCLUDE_DIR)
+
+# Output variables
+IF(TURTLE_FOUND)
+    # Include dirs
+    SET(TURTLE_INCLUDE_DIRS ${TURTLE_INCLUDE_DIR})
+ELSE()
+    MESSAGE(FATAL_ERROR "Set, please, the environmental variable TURTLE_INCLUDE_DIR to the folder, where 'mock.hpp' is located...")
+ENDIF(TURTLE_FOUND)
+
+# Add path only to the 'include' folder
+set(TMP "")
+string(REPLACE "/include/turtle" "/include" TMP ${TURTLE_INCLUDE_DIR})
+list(APPEND TURTLE_INCLUDE_DIR ${TMP})
+
+# Advanced options for not cluttering the cmake UIs:
+MARK_AS_ADVANCED(TURTLE_INCLUDE_DIR)

build.sh

@@ -6,6 +6,6 @@ export CLEAN_AFTER=no
 
 cd build_scripts/linux
 ./download_dependencies.sh
-export DEPENDENCIES_LINK_TYPE=static
+export DEPENDENCIES_LINK_TYPE=shared
 ./linux_gcc_build_x64_debug_local.sh
 cd ../..

boost @ 67c6344e

-Subproject commit 03d255a85568f504c301a66b58edad30ae3f211d
+Subproject commit 67c6344e238d9f484dc34ab52c9de78334ec6acf

exprtk @ b3b4cee1

-Subproject commit 9836f21d07b1bf799e6877324268708f61c01f73
+Subproject commit b3b4cee1c52baf935d68fe3bb7fb1a0ec6b79694

turtle @ e92f5282

+Subproject commit e92f52821da312c5e30b447c8046893e576aefca

include/4neuro.h

@@ -8,20 +8,19 @@
 //TODO make only public interface visible
 
 #include "../src/DataSet/DataSet.h"
-#include "../src/LearningMethods/ParticleSwarm.h"
-#include "../src/NetConnection/ConnectionFunctionGeneral.h"
-#include "../src/NetConnection/ConnectionFunctionIdentity.h"
 #include "../src/Network/NeuralNetwork.h"
-//#include "../src/Network/NeuralNetworkSum.h"
+#include "../src/Network/NeuralNetworkSum.h"
 #include "../src/Neuron/Neuron.h"
+#include "../src/Neuron/NeuronConstant.h"
 #include "../src/Neuron/NeuronBinary.h"
 #include "../src/Neuron/NeuronLinear.h"
 #include "../src/Neuron/NeuronLogistic.h"
 #include "../src/Solvers/DESolver.h"
+#include "../src/ErrorFunction/ErrorFunctions.h"
 #include "../src/constants.h"
-#include "../src/settings.h"
-#include "../src/message.h"
-#include "../src/LearningMethods/GradientDescent.h"
+#include "../src/CSVReader/CSVReader.h"
 
+// Abbreaviate lib4neuro namespace to l4n
+namespace l4n = lib4neuro;
 
 #endif //INC_4NEURO_4NEURO_H

src/CMakeLists.txt

@@ -7,24 +7,22 @@ if ("${BUILD_EXAMPLES}" STREQUAL "yes")
 endif ()
 
 if ("${BUILD_LIB}" STREQUAL "yes")
-	add_library(
-        	exprtk_wrap
-		STATIC
-			General/ExprtkWrapper.cpp
-	)
+    add_library(
+        exprtk_wrap
 
-	target_include_directories(
-		exprtk_wrap
+        SHARED
 
-		PRIVATE
-	        	${EXPRTK_INCLUDE_DIR}
-			${Boost_INCLUDE_DIRS}
-	)
+        General/ExprtkWrapper.cpp
+        Exception/Exceptions.cpp
+    )
 
-	target_compile_options(
-		exprtk_wrap PRIVATE -fPIC
-	)
-	
+    target_include_directories(
+        exprtk_wrap
+
+        PRIVATE
+        	${EXPRTK_INCLUDE_DIR}
+		${Boost_INCLUDE_DIRS}
+    )
 
 	target_link_libraries(
 		exprtk_wrap
@@ -36,18 +34,21 @@ if ("${BUILD_LIB}" STREQUAL "yes")
 	add_library(lib4neuro SHARED
 		Neuron/Neuron.cpp
 		Neuron/NeuronBinary.cpp
-        	Neuron/NeuronConstant.cpp
+		Neuron/NeuronConstant.cpp
 		Neuron/NeuronLinear.cpp
 		Neuron/NeuronLogistic.cpp        
 		Network/NeuralNetwork.cpp        
 		Network/NeuralNetworkSum.cpp        
 		NetConnection/ConnectionFunctionGeneral.cpp        
 		NetConnection/ConnectionFunctionIdentity.cpp        
-        	LearningMethods/ParticleSwarm.cpp
-        	LearningMethods/GradientDescent.cpp
+        LearningMethods/ParticleSwarm.cpp
+        LearningMethods/GradientDescent.cpp
 		DataSet/DataSet.cpp
 		ErrorFunction/ErrorFunctions.cpp
 		Solvers/DESolver.cpp
+		Exception/Exceptions.cpp
+		CSVReader/CSVReader.cpp
+		CrossValidator/CrossValidator.cpp
 	)
 
     target_link_libraries(
@@ -87,7 +88,7 @@ if ("${BUILD_LIB}" STREQUAL "yes")
 		add_library(${PREFIX}boost_unit_test STATIC boost_test_lib_dummy.cpp)
 	elseif("${DEPENDENCIES_LINK_TYPE}" STREQUAL "static")
 		add_library(${PREFIX}boost_unit_test STATIC boost_test_lib_dummy.cpp)
-    elseif("${DEPENDENCIES_LINK_TYPE}" STREQUAL "shared")
+	elseif("${DEPENDENCIES_LINK_TYPE}" STREQUAL "shared")
         add_library(${PREFIX}boost_unit_test SHARED boost_test_lib_dummy.cpp)
 	endif()
 

src/CSVReader/CSVReader.cpp

+//
+// Created by martin on 14.11.18.
+//
+
+#include <string>
+#include <fstream>
+#include <sstream>
+
+#include "CSVReader.h"
+
+namespace lib4neuro {
+    CSVReader::CSVReader(std::string file_path, std::string delimiter, bool ignore_first_line) {
+        this->file_path = file_path;
+        this->delimiter = delimiter;
+        this->ignore_first_line = ignore_first_line;
+        this->header_included = ignore_first_line;
+        this->data = new std::vector<std::vector<std::string>>;
+    }
+
+    void CSVReader::read() {
+        std::ifstream ifs(this->file_path);
+        std::string line;
+
+        if(this->ignore_first_line) {
+            std::getline(ifs, line);
+        }
+
+        /* Read single line from the file */
+        while(std::getline(ifs, line)) {
+
+            /* Ignore empty line */
+            if(line == "") {
+                continue;
+            }
+
+            /* Separate elements of the line according to the delimiter */
+            size_t last = 0;
+            size_t next = 0;
+            std::vector<std::string> separated_line;
+            while ((next = line.find(this->delimiter, last)) != std::string::npos) {
+                separated_line.emplace_back(line.substr(last, next - last));
+                last = next + 1;
+            }
+            separated_line.emplace_back(line.substr(last));
+
+            /* Store the elements from the line to the vector with data */
+            this->data->emplace_back(separated_line);
+        }
+
+        ifs.close();
+    }
+
+    std::vector<std::vector<std::string>>* CSVReader::get_data() {
+        return this->data;
+    }
+
+    void CSVReader::print_data() {
+        for(auto line : *this->data) {
+            for(auto e : line) {
+                std::cout << e << " ";
+            }
+            std::cout << std::endl;
+        }
+    }
+
+    DataSet CSVReader::get_data_set(std::vector<unsigned int>* input_col_indices,
+                                    std::vector<unsigned int>* output_col_indices) {
+
+        std::vector<std::pair<std::vector<double>, std::vector<double>>> data_set_contents;
+
+        for(auto line : *this->data) {
+            //TODO check for non-numerical (or empty) values in data
+            std::vector<double> input;
+            for(auto ind : *input_col_indices) {
+                input.push_back(std::stod(line.at(ind)));
+            }
+
+            std::vector<double> output;
+            for(auto ind : *output_col_indices) {
+                output.emplace_back(std::stod(line.at(ind)));
+            }
+
+            data_set_contents.push_back(std::make_pair(input, output));
+        }
+
+        return DataSet(&data_set_contents);
+    }
+}
\ No newline at end of file

src/CSVReader/CSVReader.h

+//
+// Created by martin on 14.11.18.
+//
+
+#ifndef LIB4NEURO_CSVREADER_H
+#define LIB4NEURO_CSVREADER_H
+
+#include <string>
+
+#include "../settings.h"
+#include "../DataSet/DataSet.h"
+
+namespace lib4neuro {
+
+    /**
+     *
+     */
+    class CSVReader {
+    //TODO make more efficient - possibly with external library?
+
+    private:
+
+        /**
+         *
+         */
+        std::string file_path;
+
+        /**
+         *
+         */
+        bool header_included;
+
+        /**
+         *
+         */
+        std::string delimiter;
+
+        /**
+         *
+         */
+        bool ignore_first_line;
+
+        /**
+         *
+         */
+        std::vector<std::vector<std::string>>* data;
+
+    public:
+
+        /**
+         *
+         * @param file_path
+         * @param delimiter
+         * @param ignore_first_line
+         */
+        LIB4NEURO_API CSVReader(std::string file_path, std::string delimiter=",", bool ignore_first_line=false);
+
+        /**
+         *
+         */
+        LIB4NEURO_API void read();
+
+        /**
+         *
+         * @return
+         */
+         LIB4NEURO_API std::vector<std::vector<std::string>>* get_data();
+
+        /**
+         *
+         * @param input_col_indices
+         * @param output_col_indices
+         * @return
+         */
+        LIB4NEURO_API DataSet get_data_set(std::vector<unsigned int>* input_col_indices,
+                std::vector<unsigned int>* output_col_indices);
+
+        /**
+         *
+         */
+        LIB4NEURO_API void print_data();
+    };
+}
+
+#endif //LIB4NEURO_CSVREADER_H

src/CrossValidator/CrossValidator.cpp

+//
+// Created by martin on 14.11.18.
+//
+
+#include "CrossValidator.h"
+#include "../message.h"
+
+namespace lib4neuro {
+    LIB4NEURO_API CrossValidator::CrossValidator(ILearningMethods* optimizer, ErrorFunction* ef) {
+        this->optimizer = optimizer;
+        this->ef = ef;
+    }
+
+    LIB4NEURO_API void CrossValidator::run_k_fold_test(unsigned int k, unsigned int tests_number) {
+
+        NeuralNetwork *net = this->ef->get_network_instance();
+
+        for(unsigned int i = 0; i < tests_number; i++) {
+            std::cout << "Cross-validation run " << i+1 << std::endl;
+
+            this->ef->divide_data_train_test(1.0/k);
+            std::cout << "Cross-validation run " << i+1 << ", number of train data points: " << this->ef->get_dataset()->get_n_elements() << std::endl;
+
+            net->print_weights();
+            net->randomize_parameters();
+            net->scale_parameters( 1.0 / (net->get_n_weights() + net->get_n_biases()));
+
+            net->print_weights();
+            this->optimizer->optimize(*this->ef);
+            this->ef->return_full_data_set_for_training();
+        }
+    }
+}
\ No newline at end of file

src/CrossValidator/CrossValidator.h

+//
+// Created by martin on 14.11.18.
+//
+
+#ifndef LIB4NEURO_CROSSVALIDATOR_H
+#define LIB4NEURO_CROSSVALIDATOR_H
+
+#include "../settings.h"
+#include "../DataSet/DataSet.h"
+#include "../LearningMethods/ILearningMethods.h"
+
+namespace lib4neuro {
+
+    /**
+     *
+     */
+    class CrossValidator {
+    private:
+
+        /**
+         *
+         */
+        ILearningMethods* optimizer;
+
+        /**
+         *
+         */
+        ErrorFunction* ef;
+
+    public:
+
+        /**
+         *
+         * @param optimizer
+         * @param data_set
+         */
+        LIB4NEURO_API CrossValidator(ILearningMethods* optimizer, ErrorFunction* ef);
+
+        /**
+         *
+         * @param k
+         * @param tests_number
+         */
+        LIB4NEURO_API void run_k_fold_test(unsigned int k, unsigned int test_number);
+    };
+}
+
+#endif //LIB4NEURO_CROSSVALIDATOR_H

src/DataSet/DataSet.cpp

@@ -5,173 +5,183 @@
 
 #include "DataSetSerialization.h"
 
-InvalidDimension::InvalidDimension() : std::runtime_error("Invalid dimension specified!") {};
+namespace lib4neuro {
 
-InvalidDimension::InvalidDimension(std::string msg) : std::runtime_error(msg.c_str()) {};
+    DataSet::DataSet() {}
 
-DataSet::DataSet(std::string file_path) {
-    std::ifstream ifs (file_path);
-    boost::archive::text_iarchive ia(ifs);
-    ia >> *this;
-    ifs.close();
-}
+    DataSet::DataSet(std::string file_path) {
+        std::ifstream ifs(file_path);
+        boost::archive::text_iarchive ia(ifs);
+        ia >> *this;
+        ifs.close();
+    }
 
-DataSet::DataSet(std::vector<std::pair<std::vector<double>, std::vector<double>>> *data_ptr) {
-    this->n_elements = data_ptr->size();
-    this->data = *data_ptr;
+    DataSet::DataSet(std::vector<std::pair<std::vector<double>, std::vector<double>>> *data_ptr) {
+        this->n_elements = data_ptr->size();
+        this->data = *data_ptr;
 
-    this->input_dim = this->data[0].first.size();
-    this->output_dim = this->data[0].second.size();
+        this->input_dim = this->data[0].first.size();
+        this->output_dim = this->data[0].second.size();
 
-    //TODO check the complete data set for input/output dimensions
-}
+        //TODO check the complete data set for input/output dimensions
+    }
 
-DataSet::DataSet(double lower_bound, double upper_bound, unsigned int size, double output) {
-    std::vector<std::pair<std::vector<double>, std::vector<double>>> new_data_vec;
-    this->data = new_data_vec;
-    this->n_elements = 0;
-    this->input_dim = 1;
-    this->output_dim = 1;
+    DataSet::DataSet(double lower_bound, double upper_bound, unsigned int size, double output) {
+        std::vector<std::pair<std::vector<double>, std::vector<double>>> new_data_vec;
+        this->data = new_data_vec;
+        this->n_elements = 0;
+        this->input_dim = 1;
+        this->output_dim = 1;
 
-    this->add_isotropic_data(lower_bound, upper_bound, size, output);
-}
+        this->add_isotropic_data(lower_bound, upper_bound, size, output);
+    }
 
-DataSet::DataSet(std::vector<double> &bounds, unsigned int no_elems_in_one_dim, std::vector<double> (*output_func)(std::vector<double>&), unsigned int output_dim) {
-    std::vector<std::pair<std::vector<double>, std::vector<double>>> new_data_vec;
-    this->data = new_data_vec;
-    this->input_dim = bounds.size()/2;
-    this->output_dim = output_dim;
-    this->n_elements = 0;
+    DataSet::DataSet(std::vector<double> &bounds, unsigned int no_elems_in_one_dim,
+                     std::vector<double> (*output_func)(std::vector<double> &), unsigned int output_dim) {
+        std::vector<std::pair<std::vector<double>, std::vector<double>>> new_data_vec;
+        this->data = new_data_vec;
+        this->input_dim = bounds.size() / 2;
+        this->output_dim = output_dim;
+        this->n_elements = 0;
 
-    this->add_isotropic_data(bounds, no_elems_in_one_dim, output_func);
-}
+        this->add_isotropic_data(bounds, no_elems_in_one_dim, output_func);
+    }
 
 
-void DataSet::add_data_pair(std::vector<double> &inputs, std::vector<double> &outputs) {
-    if(inputs.size() != this->input_dim) {
-        throw InvalidDimension("Bad input dimension.");
-    } else if(outputs.size() != this->output_dim) {
-        throw InvalidDimension("Bad output dimension.");
-    }
+    void DataSet::add_data_pair(std::vector<double> &inputs, std::vector<double> &outputs) {
+        if(this->n_elements == 0 && this->input_dim == 0 && this->output_dim == 0) {
+            this->input_dim = inputs.size();
+            this->output_dim = outputs.size();
+        }
 
-    this->n_elements++;
-    this->data.emplace_back(std::make_pair(inputs, outputs));
-}
+        if (inputs.size() != this->input_dim) {
+            throw InvalidDimension("Bad input dimension.");
+        } else if (outputs.size() != this->output_dim) {
+            throw InvalidDimension("Bad output dimension.");
+        }
 
-void DataSet::add_isotropic_data(double lower_bound, double upper_bound, unsigned int size, double output) {
-    if(this->input_dim != 1 || this->output_dim != 1) {
-        throw InvalidDimension("Cannot add data with dimensionality 1:1 when the data set "
-                               "is of different dimensionality!");
+        this->n_elements++;
+        this->data.emplace_back(std::make_pair(inputs, outputs));
     }
 
-    double frac = (upper_bound - lower_bound) / (size - 1);
-    std::vector<double> inp, out;
+    void DataSet::add_isotropic_data(double lower_bound, double upper_bound, unsigned int size, double output) {
 
-    out = {output};
+        if (this->input_dim != 1 || this->output_dim != 1) {
+            throw InvalidDimension("Cannot add data with dimensionality 1:1 when the data set "
+                                   "is of different dimensionality!");
+        }
 
-    for(unsigned int i = 0; i < size; ++i){
-        inp = {frac*i};
-        this->data.emplace_back(std::make_pair(inp, out));
+        double frac = (upper_bound - lower_bound) / (size - 1);
+        std::vector<double> inp, out;
+
+        out = {output};
+
+        for (unsigned int i = 0; i < size; ++i) {
+            inp = {frac * i};
+            this->data.emplace_back(std::make_pair(inp, out));
+        }
+
+        this->n_elements += size;
     }
 
-    this->n_elements += size;
-}
+    void DataSet::add_isotropic_data(std::vector<double> &bounds, unsigned int no_elems_in_one_dim,
+                                     std::vector<double> (*output_func)(std::vector<double> &)) {
+        // TODO add check of dataset dimensions
 
-void DataSet::add_isotropic_data(std::vector<double> &bounds, unsigned int no_elems_in_one_dim, std::vector<double> (*output_func)(std::vector<double>&)) {
-    // TODO add check of dataset dimensions
+        std::vector<std::vector<double>> grid;
+        std::vector<double> tmp;
+        double frac;
 
-    std::vector<std::vector<double>> grid;
-    std::vector<double> tmp;
-    double frac;
+        for (unsigned int i = 0; i < bounds.size(); i += 2) {
+            frac = (bounds[i] + bounds[i + 1]) / (no_elems_in_one_dim - 1);
+            tmp.clear();
+            for (double j = bounds[i]; j <= bounds[i + 1]; j += frac) {
+                tmp.emplace_back(j);
+            }
 
-    for(unsigned int i = 0; i < bounds.size(); i += 2) {
-        frac = (bounds[i] + bounds[i+1]) / (no_elems_in_one_dim - 1);
-        tmp.clear();
-        for(double j = bounds[i]; j <= bounds[i+1]; j += frac) {
-            tmp.emplace_back(j);
+            grid.emplace_back(tmp);
         }
 
-        grid.emplace_back(tmp);
+        grid = this->cartesian_product(&grid);
+
+        for (auto vec : grid) {
+            this->n_elements++;
+            this->data.emplace_back(std::make_pair(vec, output_func(vec)));
+        }
     }
 
-    grid = this->cartesian_product(&grid);
+    std::vector<std::pair<std::vector<double>, std::vector<double>>> *DataSet::get_data() {
+        return &(this->data);
+    }
 
-    for(auto vec : grid) {
-        this->n_elements++;
-        this->data.emplace_back(std::make_pair(vec, output_func(vec)));
+    size_t DataSet::get_n_elements() {
+        return this->n_elements;
     }
-}
-
-std::vector<std::pair<std::vector<double>, std::vector<double>>>* DataSet::get_data() {
-    return &(this->data);
-}
-
-size_t DataSet::get_n_elements() {
-    return this->n_elements;
-}
-
-size_t DataSet::get_input_dim() {
-    return this->input_dim;
-}
-
-size_t DataSet::get_output_dim() {
-    return this->output_dim;
-}
-
-void DataSet::print_data() {
-    if (n_elements) {
-        for (auto p : this->data) {
-            /* INPUT */
-            for (auto v : std::get<0>(p)) {
-                std::cout << v << " ";
-            }
 
-            std::cout << "-> ";
+    size_t DataSet::get_input_dim() {
+        return this->input_dim;
+    }
 
-            /* OUTPUT */
-            for (auto v : std::get<1>(p)) {
-                std::cout << v << " ";
-            }
+    size_t DataSet::get_output_dim() {
+        return this->output_dim;
+    }
+
+    void DataSet::print_data() {
+        if (n_elements) {
+            for (auto p : this->data) {
+                /* INPUT */
+                for (auto v : std::get<0>(p)) {
+                    std::cout << v << " ";
+                }
+
+                std::cout << "-> ";
 
-            std::cout << std::endl;
+                /* OUTPUT */
+                for (auto v : std::get<1>(p)) {
+                    std::cout << v << " ";
+                }
+
+                std::cout << std::endl;
+            }
         }
     }
-}
-
-void DataSet::store_text(std::string &file_path) {
-    //TODO check if stream was successfully opened
-    std::ofstream ofs(file_path);
-    boost::archive::text_oarchive oa(ofs);
-    oa << *this;
-    ofs.close();
-}
-
-template <class T>
-std::vector<std::vector<T>> DataSet::cartesian_product(const std::vector<std::vector<T>>* v) {
-    std::vector<std::vector<double>> v_combined_old, v_combined, v_tmp;
-    std::vector<double> tmp;
-
-    for(const auto& e : v->at(0)) {
-        tmp = {e};
-        v_combined.emplace_back(tmp);
+
+    void DataSet::store_text(std::string &file_path) {
+        //TODO check if stream was successfully opened
+        std::ofstream ofs(file_path);
+        boost::archive::text_oarchive oa(ofs);
+        oa << *this;
+        ofs.close();
     }
 
-    for(unsigned int i = 1; i < v->size(); i++) {  // Iterate through remaining vectors of 'v'
-        v_combined_old = v_combined;
-        v_combined.clear();
+    template<class T>
+    std::vector<std::vector<T>> DataSet::cartesian_product(const std::vector<std::vector<T>> *v) {
+        std::vector<std::vector<double>> v_combined_old, v_combined, v_tmp;
+        std::vector<double> tmp;
 
-        for(const auto& e : v->at(i)) {
-            for(const auto& vec : v_combined_old) {
-                tmp = vec;
-                tmp.emplace_back(e);
+        for (const auto &e : v->at(0)) {
+            tmp = {e};
+            v_combined.emplace_back(tmp);
+        }
+
+        for (unsigned int i = 1; i < v->size(); i++) {  // Iterate through remaining vectors of 'v'
+            v_combined_old = v_combined;
+            v_combined.clear();
 
-                /* Add only unique elements */
-                if(std::find(v_combined.begin(), v_combined.end(), tmp) == v_combined.end()) {
-                    v_combined.emplace_back(tmp);
+            for (const auto &e : v->at(i)) {
+                for (const auto &vec : v_combined_old) {
+                    tmp = vec;
+                    tmp.emplace_back(e);
+
+                    /* Add only unique elements */
+                    if (std::find(v_combined.begin(), v_combined.end(), tmp) == v_combined.end()) {
+                        v_combined.emplace_back(tmp);
+                    }
                 }
             }
         }
+
+        return v_combined;
     }
 
-    return v_combined;
 }
\ No newline at end of file

src/DataSet/DataSet.cpp.orig

+//
+// Created by martin on 7/13/18.
+//
+
+
+#include "DataSetSerialization.h"
+
+namespace lib4neuro {
+
+    DataSet::DataSet(std::string file_path) {
+        std::ifstream ifs(file_path);
+        boost::archive::text_iarchive ia(ifs);
+        ia >> *this;
+        ifs.close();
+    }
+<<<<<<< HEAD
+=======
+
+	DataSet::DataSet() {
+		
+	}
+>>>>>>> 5fd0f3dcf535edfc3e3f4dd7b4cb256f2e95e8fe
+
+    DataSet::DataSet(std::vector<std::pair<std::vector<double>, std::vector<double>>> *data_ptr) {
+        this->n_elements = data_ptr->size();
+        this->data = *data_ptr;
+
+        this->input_dim = this->data[0].first.size();
+        this->output_dim = this->data[0].second.size();
+
+        //TODO check the complete data set for input/output dimensions
+    }
+
+    DataSet::DataSet(double lower_bound, double upper_bound, unsigned int size, double output) {
+        std::vector<std::pair<std::vector<double>, std::vector<double>>> new_data_vec;
+        this->data = new_data_vec;
+        this->n_elements = 0;
+        this->input_dim = 1;
+        this->output_dim = 1;
+
+        this->add_isotropic_data(lower_bound, upper_bound, size, output);
+    }
+
+    DataSet::DataSet(std::vector<double> &bounds, unsigned int no_elems_in_one_dim,
+                     std::vector<double> (*output_func)(std::vector<double> &), unsigned int output_dim) {
+        std::vector<std::pair<std::vector<double>, std::vector<double>>> new_data_vec;
+        this->data = new_data_vec;
+        this->input_dim = bounds.size() / 2;
+        this->output_dim = output_dim;
+        this->n_elements = 0;
+
+        this->add_isotropic_data(bounds, no_elems_in_one_dim, output_func);
+    }
+
+
+    void DataSet::add_data_pair(std::vector<double> &inputs, std::vector<double> &outputs) {
+        if (inputs.size() != this->input_dim) {
+            throw InvalidDimension("Bad input dimension.");
+        } else if (outputs.size() != this->output_dim) {
+            throw InvalidDimension("Bad output dimension.");
+        }
+
+        this->n_elements++;
+        this->data.emplace_back(std::make_pair(inputs, outputs));
+    }
+
+    void DataSet::add_isotropic_data(double lower_bound, double upper_bound, unsigned int size, double output) {
+        if (this->input_dim != 1 || this->output_dim != 1) {
+            throw InvalidDimension("Cannot add data with dimensionality 1:1 when the data set "
+                                   "is of different dimensionality!");
+        }
+
+        double frac = (upper_bound - lower_bound) / (size - 1);
+        std::vector<double> inp, out;
+
+        out = {output};
+
+        for (unsigned int i = 0; i < size; ++i) {
+            inp = {frac * i};
+            this->data.emplace_back(std::make_pair(inp, out));
+        }
+
+        this->n_elements += size;
+    }
+
+    void DataSet::add_isotropic_data(std::vector<double> &bounds, unsigned int no_elems_in_one_dim,
+                                     std::vector<double> (*output_func)(std::vector<double> &)) {
+        // TODO add check of dataset dimensions
+
+        std::vector<std::vector<double>> grid;
+        std::vector<double> tmp;
+        double frac;
+
+        for (unsigned int i = 0; i < bounds.size(); i += 2) {
+            frac = (bounds[i] + bounds[i + 1]) / (no_elems_in_one_dim - 1);
+            tmp.clear();
+            for (double j = bounds[i]; j <= bounds[i + 1]; j += frac) {
+                tmp.emplace_back(j);
+            }
+
+            grid.emplace_back(tmp);
+        }
+
+        grid = this->cartesian_product(&grid);
+
+        for (auto vec : grid) {
+            this->n_elements++;
+            this->data.emplace_back(std::make_pair(vec, output_func(vec)));
+        }
+    }
+
+    std::vector<std::pair<std::vector<double>, std::vector<double>>> *DataSet::get_data() {
+        return &(this->data);
+    }
+
+    size_t DataSet::get_n_elements() {
+        return this->n_elements;
+    }
+
+    size_t DataSet::get_input_dim() {
+        return this->input_dim;
+    }
+
+    size_t DataSet::get_output_dim() {
+        return this->output_dim;
+    }
+<<<<<<< HEAD
+
+    void DataSet::print_data() {
+        if (n_elements) {
+            for (auto p : this->data) {
+                /* INPUT */
+                for (auto v : std::get<0>(p)) {
+                    std::cout << v << " ";
+                }
+
+                std::cout << "-> ";
+
+                /* OUTPUT */
+                for (auto v : std::get<1>(p)) {
+                    std::cout << v << " ";
+                }
+
+=======
+
+    void DataSet::print_data() {
+        if (n_elements) {
+            for (auto p : this->data) {
+                /* INPUT */
+                for (auto v : std::get<0>(p)) {
+                    std::cout << v << " ";
+                }
+
+                std::cout << "-> ";
+
+                /* OUTPUT */
+                for (auto v : std::get<1>(p)) {
+                    std::cout << v << " ";
+                }
+
+>>>>>>> 5fd0f3dcf535edfc3e3f4dd7b4cb256f2e95e8fe
+                std::cout << std::endl;
+            }
+        }
+    }
+
+    void DataSet::store_text(std::string &file_path) {
+        //TODO check if stream was successfully opened
+        std::ofstream ofs(file_path);
+        boost::archive::text_oarchive oa(ofs);
+        oa << *this;
+        ofs.close();
+    }
+
+    template<class T>
+    std::vector<std::vector<T>> DataSet::cartesian_product(const std::vector<std::vector<T>> *v) {
+        std::vector<std::vector<double>> v_combined_old, v_combined, v_tmp;
+        std::vector<double> tmp;
+
+        for (const auto &e : v->at(0)) {
+            tmp = {e};
+            v_combined.emplace_back(tmp);
+        }
+
+        for (unsigned int i = 1; i < v->size(); i++) {  // Iterate through remaining vectors of 'v'
+            v_combined_old = v_combined;
+            v_combined.clear();
+
+            for (const auto &e : v->at(i)) {
+                for (const auto &vec : v_combined_old) {
+                    tmp = vec;
+                    tmp.emplace_back(e);
+
+                    /* Add only unique elements */
+                    if (std::find(v_combined.begin(), v_combined.end(), tmp) == v_combined.end()) {
+                        v_combined.emplace_back(tmp);
+                    }
+                }
+            }
+        }
+
+        return v_combined;
+    }
+
+}
\ No newline at end of file

src/DataSet/DataSet.h

@@ -9,181 +9,168 @@
 #include <fstream>
 #include <utility>
 #include <vector>
-#include <exception>
 #include <string>
 #include <functional>
 
 #include "../settings.h"
-
-/**
- * Class representing an error caused by an incorrect
- * input/output dimension specification
- */
-class InvalidDimension: public std::runtime_error {
-public:
-
-    /**
-     * Constructor with the general error message
-     */
-    InvalidDimension();
-
-    /**
-     * Constructor with specific error message
-     * @param msg Specific error message
-     */
-    explicit InvalidDimension(std::string msg);
-};
-
-/**
- * Class representing data, which can be used for training
- * and testing purposes.
- */
-class DataSet {
-//    friend class boost::serialization::access;
-
-private:
-
-    /**
-     * Number of elements in the data set
-     */
-    size_t n_elements;
-
-    /**
-     * Dimension of the input
-     */
-    size_t input_dim = 0;
-
-    /**
-     * Dimension of the output
-     */
-    size_t output_dim = 0;
-
-    /**
-     * Stored data in the format of pairs of corresponding
-     * input and output vectors
-     */
-    std::vector<std::pair<std::vector<double>, std::vector<double>>> data;
-
-    template <class T>
-    std::vector<std::vector<T>> cartesian_product(const std::vector<std::vector<T>>* v);
-
-public:
-
-    /**
-     * Struct used to access private properties from
-     * the serialization function
-     */
-    struct access;
-
-    /**
-     * Constructor reading data from the file
-     * @param file_path Path to the file with stored data set
-     */
-    LIB4NEURO_API DataSet(std::string file_path);
-
-    /**
-     * Constructor accepting data vector
-     * @param data_ptr Pointer to the vector containing data
-     */
-    LIB4NEURO_API DataSet(std::vector<std::pair<std::vector<double>, std::vector<double>>>* data_ptr);
-
-    /**
-     * Creates a new data set with input values equidistantly positioned
-     * over the certain interval and the output value
-     * being constant
-     *
-     * Both input and output are 1-dimensional
-     *
-     * @todo add bounds as vectors for multi-dimensional data-sets
-     *
-     * @param lower_bound Lower bound of the input data interval
-     * @param upper_bound Upper bound of the input data interval
-     * @param size Number of input-output pairs generated
-     * @param output Constant output value
-     */
-    LIB4NEURO_API DataSet(double lower_bound, double upper_bound, unsigned int size, double output);
-
-    /**
-     *
-     * @param bounds
-     * @param no_elems_in_one_dim
-     * @param output_func
-     * @param output_dim
-     */
-    LIB4NEURO_API DataSet(std::vector<double> &bounds, unsigned int no_elems_in_one_dim, std::vector<double> (*output_func)(std::vector<double>&), unsigned int output_dim);
-
-    /**
-     * Getter for number of elements
-     * @return Number of elements in the data set
-     */
-    LIB4NEURO_API size_t get_n_elements();
-
-    /**
-     * Returns the input dimension
-     * @return Input dimension
-     */
-    LIB4NEURO_API size_t get_input_dim();
-
-
-    /**
-     * Return the output dimension
-     * @return Output dimension
-     */
-    LIB4NEURO_API size_t get_output_dim();
-
-    /**
-     * Getter for the data structure
-     * @return Vector of data
-     */
-    LIB4NEURO_API std::vector<std::pair<std::vector<double>, std::vector<double>>>* get_data();
-
-    /**
-     * Adds a new pair of data to the data set
-     * @param inputs Vector of input data
-     * @param outputs Vector of output data corresponding to the input data
-     */
-    LIB4NEURO_API void add_data_pair(std::vector<double> &inputs, std::vector<double> &outputs);
-
-    //TODO expand method to generate multiple data types - chebyshev etc.
-    /**
-     * Adds a new data with input values equidistantly positioned
-     * over the certain interval and the output value
-     * being constant
-     *
-     * Both input and output are 1-dimensional
-     *
-     * @param lower_bound Lower bound of the input data interval
-     * @param upper_bound Upper bound of the input data interval
-     * @param size Number of input-output pairs generated
-     * @param output Constant output value
-     */
-    LIB4NEURO_API void add_isotropic_data(double lower_bound, double upper_bound, unsigned int size, double output);
-
-    /**
-     * Adds a new data with input values equidistantly positioned
-     * over the certain interval and the output value
-     * being constant
-     *
-     * Input can have arbitrary many dimensions,
-     * output can be an arbitrary function
-     *
-     * @param bounds Odd values are lower bounds and even values are corresponding upper bounds
-     * @param size Number of input-output pairs generated
-     * @param output_func Function determining output value
-     */
-    LIB4NEURO_API void add_isotropic_data(std::vector<double> &bounds, unsigned int no_elems_in_one_dim, std::vector<double> (*output_func)(std::vector<double>&));
-
-    //TODO Chebyshev - ch. interpolation points, i-th point = cos(i*alpha) from 0 to pi
-
-    /**
-     * Prints the data set
-     */
-    LIB4NEURO_API void print_data();
-
-    /**
-     * Stores the DataSet object to the binary file
-     */
-    LIB4NEURO_API void store_text(std::string &file_path);
-};
-
+#include "../Exception/Exceptions.h"
+
+namespace lib4neuro {
+    /**
+     * Class representing data, which can be used for training
+     * and testing purposes.
+     */
+    class DataSet {
+
+    private:
+
+        /**
+         * Number of elements in the data set
+         */
+        size_t n_elements = 0;
+
+        /**
+         * Dimension of the input
+         */
+        size_t input_dim = 0;
+
+        /**
+         * Dimension of the output
+         */
+        size_t output_dim = 0;
+
+        /**
+         * Stored data in the format of pairs of corresponding
+         * input and output vectors
+         */
+        std::vector<std::pair<std::vector<double>, std::vector<double>>> data;
+
+        template<class T>
+        std::vector<std::vector<T>> cartesian_product(const std::vector<std::vector<T>> *v);
+
+    public:
+
+        /**
+         * Struct used to access private properties from
+         * the serialization function
+         */
+        struct access;
+
+        /**
+         * Constructor for an empty DataSet
+         */
+        LIB4NEURO_API DataSet();
+
+        /**
+         * Constructor reading data from the file
+         * @param file_path Path to the file with stored data set
+         */
+        LIB4NEURO_API DataSet(std::string file_path);
+
+        /**
+         * Constructor accepting data vector
+         * @param data_ptr Pointer to the vector containing data
+         */
+        LIB4NEURO_API DataSet(std::vector<std::pair<std::vector<double>, std::vector<double>>> *data_ptr);
+
+        /**
+         * Creates a new data set with input values equidistantly positioned
+         * over the certain interval and the output value
+         * being constant
+         *
+         * Both input and output are 1-dimensional
+         *
+         * @todo add bounds as vectors for multi-dimensional data-sets
+         *
+         * @param lower_bound Lower bound of the input data interval
+         * @param upper_bound Upper bound of the input data interval
+         * @param size Number of input-output pairs generated
+         * @param output Constant output value
+         */
+        LIB4NEURO_API DataSet(double lower_bound, double upper_bound, unsigned int size, double output);
+
+        /**
+         *
+         * @param bounds
+         * @param no_elems_in_one_dim
+         * @param output_func
+         * @param output_dim
+         */
+        LIB4NEURO_API DataSet(std::vector<double> &bounds, unsigned int no_elems_in_one_dim,
+                              std::vector<double> (*output_func)(std::vector<double> &), unsigned int output_dim);
+
+        /**
+         * Getter for number of elements
+         * @return Number of elements in the data set
+         */
+        LIB4NEURO_API size_t get_n_elements();
+
+        /**
+         * Returns the input dimension
+         * @return Input dimension
+         */
+        LIB4NEURO_API size_t get_input_dim();
+
+        /**
+         * Return the output dimension
+         * @return Output dimension
+         */
+        LIB4NEURO_API size_t get_output_dim();
+
+        /**
+         * Getter for the data structure
+         * @return Vector of data
+         */
+        LIB4NEURO_API std::vector<std::pair<std::vector<double>, std::vector<double>>> *get_data();
+
+        /**
+         * Adds a new pair of data to the data set
+         * @param inputs Vector of input data
+         * @param outputs Vector of output data corresponding to the input data
+         */
+        LIB4NEURO_API void add_data_pair(std::vector<double> &inputs, std::vector<double> &outputs);
+
+        //TODO expand method to generate multiple data types - chebyshev etc.
+        /**
+         * Adds a new data with input values equidistantly positioned
+         * over the certain interval and the output value
+         * being constant
+         *
+         * Both input and output are 1-dimensional
+         *
+         * @param lower_bound Lower bound of the input data interval
+         * @param upper_bound Upper bound of the input data interval
+         * @param size Number of input-output pairs generated
+         * @param output Constant output value
+         */
+        LIB4NEURO_API void add_isotropic_data(double lower_bound, double upper_bound, unsigned int size, double output);
+
+        /**
+         * Adds a new data with input values equidistantly positioned
+         * over the certain interval and the output value
+         * being constant
+         *
+         * Input can have arbitrary many dimensions,
+         * output can be an arbitrary function
+         *
+         * @param bounds Odd values are lower bounds and even values are corresponding upper bounds
+         * @param size Number of input-output pairs generated
+         * @param output_func Function determining output value
+         */
+        LIB4NEURO_API void add_isotropic_data(std::vector<double> &bounds, unsigned int no_elems_in_one_dim,
+                                              std::vector<double> (*output_func)(std::vector<double> &));
+
+        //TODO Chebyshev - ch. interpolation points, i-th point = cos(i*alpha) from 0 to pi
+
+        /**
+         * Prints the data set
+         */
+        LIB4NEURO_API void print_data();
+
+        /**
+         * Stores the DataSet object to the binary file
+         */
+        LIB4NEURO_API void store_text(std::string &file_path);
+    };
+}
 #endif //INC_4NEURO_DATASET_H

src/DataSet/DataSet.h.orig

+//
+// Created by martin on 7/13/18.
+//
+
+#ifndef INC_4NEURO_DATASET_H
+#define INC_4NEURO_DATASET_H
+
+#include <iostream>
+#include <fstream>
+#include <utility>
+#include <vector>
+#include <string>
+#include <functional>
+
+#include "../settings.h"
+#include "../Exception/Exceptions.h"
+
+namespace lib4neuro {
+    /**
+     * Class representing data, which can be used for training
+     * and testing purposes.
+     */
+    class DataSet {
+
+    private:
+
+        /**
+         * Number of elements in the data set
+         */
+        size_t n_elements;
+
+        /**
+         * Dimension of the input
+         */
+        size_t input_dim = 0;
+
+        /**
+         * Dimension of the output
+         */
+        size_t output_dim = 0;
+
+        /**
+         * Stored data in the format of pairs of corresponding
+         * input and output vectors
+         */
+        std::vector<std::pair<std::vector<double>, std::vector<double>>> data;
+
+        template<class T>
+        std::vector<std::vector<T>> cartesian_product(const std::vector<std::vector<T>> *v);
+
+    public:
+
+        /**
+         * Struct used to access private properties from
+         * the serialization function
+         */
+        struct access;
+
+        /**
+         * Constructor reading data from the file
+         * @param file_path Path to the file with stored data set
+         */
+        LIB4NEURO_API DataSet(std::string file_path);
+
+<<<<<<< HEAD
+=======
+		LIB4NEURO_API DataSet();
+
+>>>>>>> 5fd0f3dcf535edfc3e3f4dd7b4cb256f2e95e8fe
+        /**
+         * Constructor accepting data vector
+         * @param data_ptr Pointer to the vector containing data
+         */
+        LIB4NEURO_API DataSet(std::vector<std::pair<std::vector<double>, std::vector<double>>> *data_ptr);
+
+        /**
+         * Creates a new data set with input values equidistantly positioned
+         * over the certain interval and the output value
+         * being constant
+         *
+         * Both input and output are 1-dimensional
+         *
+         * @todo add bounds as vectors for multi-dimensional data-sets
+         *
+         * @param lower_bound Lower bound of the input data interval
+         * @param upper_bound Upper bound of the input data interval
+         * @param size Number of input-output pairs generated
+         * @param output Constant output value
+         */
+        LIB4NEURO_API DataSet(double lower_bound, double upper_bound, unsigned int size, double output);
+
+        /**
+         *
+         * @param bounds
+         * @param no_elems_in_one_dim
+         * @param output_func
+         * @param output_dim
+         */
+        LIB4NEURO_API DataSet(std::vector<double> &bounds, unsigned int no_elems_in_one_dim,
+                              std::vector<double> (*output_func)(std::vector<double> &), unsigned int output_dim);
+
+        /**
+         * Getter for number of elements
+         * @return Number of elements in the data set
+         */
+        LIB4NEURO_API size_t get_n_elements();
+
+        /**
+         * Returns the input dimension
+         * @return Input dimension
+         */
+        LIB4NEURO_API size_t get_input_dim();
+
+
+        /**
+         * Return the output dimension
+         * @return Output dimension
+         */
+        LIB4NEURO_API size_t get_output_dim();
+
+        /**
+         * Getter for the data structure
+         * @return Vector of data
+         */
+        LIB4NEURO_API std::vector<std::pair<std::vector<double>, std::vector<double>>> *get_data();
+
+        /**
+         * Adds a new pair of data to the data set
+         * @param inputs Vector of input data
+         * @param outputs Vector of output data corresponding to the input data
+         */
+        LIB4NEURO_API void add_data_pair(std::vector<double> &inputs, std::vector<double> &outputs);
+
+        //TODO expand method to generate multiple data types - chebyshev etc.
+        /**
+         * Adds a new data with input values equidistantly positioned
+         * over the certain interval and the output value
+         * being constant
+         *
+         * Both input and output are 1-dimensional
+         *
+         * @param lower_bound Lower bound of the input data interval
+         * @param upper_bound Upper bound of the input data interval
+         * @param size Number of input-output pairs generated
+         * @param output Constant output value
+         */
+        LIB4NEURO_API void add_isotropic_data(double lower_bound, double upper_bound, unsigned int size, double output);
+
+        /**
+         * Adds a new data with input values equidistantly positioned
+         * over the certain interval and the output value
+         * being constant
+         *
+         * Input can have arbitrary many dimensions,
+         * output can be an arbitrary function
+         *
+         * @param bounds Odd values are lower bounds and even values are corresponding upper bounds
+         * @param size Number of input-output pairs generated
+         * @param output_func Function determining output value
+         */
+        LIB4NEURO_API void add_isotropic_data(std::vector<double> &bounds, unsigned int no_elems_in_one_dim,
+                                              std::vector<double> (*output_func)(std::vector<double> &));
+
+        //TODO Chebyshev - ch. interpolation points, i-th point = cos(i*alpha) from 0 to pi
+
+        /**
+         * Prints the data set
+         */
+        LIB4NEURO_API void print_data();
+
+        /**
+         * Stores the DataSet object to the binary file
+         */
+        LIB4NEURO_API void store_text(std::string &file_path);
+    };
+}
+#endif //INC_4NEURO_DATASET_H

src/DataSet/DataSetSerialization.h

@@ -14,15 +14,17 @@
 
 #include "DataSet.h"
 
-struct DataSet :: access {
-    template <class Archive>
-    static void serialize(Archive &ar, DataSet& ds, const unsigned int version) {
-        ar & ds.n_elements;
-        ar & ds.input_dim;
-        ar & ds.output_dim;
-        ar & ds.data;
-    }
-};
+namespace lib4neuro {
+    struct DataSet::access {
+        template<class Archive>
+        static void serialize(Archive &ar, DataSet &ds, const unsigned int version) {
+            ar & ds.n_elements;
+            ar & ds.input_dim;
+            ar & ds.output_dim;
+            ar & ds.data;
+        }
+    };
+}
 
 namespace boost {
     namespace serialization {
@@ -35,9 +37,9 @@ namespace boost {
          * @param version Boost parameter - filled automatically during serialization!
          */
         template<class Archive>
-        void serialize(Archive & ar, DataSet & ds, const unsigned int version)
+        void serialize(Archive & ar, lib4neuro::DataSet & ds, const unsigned int version)
         {
-            DataSet::access::serialize(ar, ds, version);
+            lib4neuro::DataSet::access::serialize(ar, ds, version);
         }
 
     } // namespace serialization