nodes_value_containers.hpp

/** @file feature_creation/node/value_storage/node_value_containers.hpp
 *  @brief Centeral storage area for all descriptor matrix data
 *
 *  This file contains definitions where all descriptor/feature data is stored permanently or in temporary storage arrays
 *  All Nodes's (except ModelNodes) value_ptr/test_value_ptrs point to data here.
 *
 *  @author Thomas A. R. Purcell (tpurcell)
 *  @bug No known bugs.
 */
#ifndef NODE_VALUE_ARR
#define NODE_VALUE_ARR

#include <algorithm>
#include <memory>
#include <numeric>
#include <vector>

#include <omp.h>

#include<utils/enum.hpp>

namespace node_value_arrs
{
    extern std::vector<double> TEMP_STORAGE_ARR; //!< Array to temporarily store feature training data
    extern std::vector<double> VALUES_ARR; //!< Training data of the stored features
    extern std::vector<double> TEMP_STORAGE_TEST_ARR; //!< Array to temporarily store feature test data
    extern std::vector<double> TEST_VALUES_ARR; //!< Value of the stored features test data
    extern std::vector<double> D_MATRIX; //!< The descriptor matrix
    extern std::vector<int> TEMP_STORAGE_REG; //!< Register to see which feature is stored in each slot for the training data
    extern std::vector<int> TEMP_STORAGE_TEST_REG; //!< Register to see which feature is stored in each slot for the test data

    extern std::vector<int> TASK_SZ_TRAIN; //!< Number of training samples per task
    extern std::vector<int> TASK_SZ_TEST; //!< Number of test sample per task

    extern int N_SELECTED; //!< Number of features selected
    extern int N_SAMPLES; //!< Number of training samples for each feature
    extern int N_SAMPLES_TEST; //!< Number of test samples for each feature
    extern unsigned long int N_STORE_FEATURES; //!< Number of features with stored values
    extern int N_RUNGS_STORED; //!< Number of rungs with values stored
    extern int MAX_N_THREADS; //!< Get the maximum number of threads possible
    extern unsigned long int NEXT_IND; //!< The next array index to use

    /**
     * @brief Initialize the node value arrays
     * @details Using the size of the initial feature space constructor the storage arrays
     *
     * @param n_samples Number of training samples for each feature
     * @param n_samples_test Number of test samples for each feature
     * @param n_primary_feat Number of primary features
     * @param set_test_task_sz If True reset the task_sz vectors
     */
    void initialize_values_arr(int n_samples, int n_samples_test, int n_primary_feat, bool et_task_sz);

    /**
     * @brief Initialize the node value arrays
     * @details Using the size of the initial feature space constructor the storage arrays
     *
     * @param n_samples Number of training samples for each feature
     * @param n_samples_test Number of test samples for each feature
     * @param n_primary_feat Number of primary features
     */
    inline void initialize_values_arr(int n_samples, int n_samples_test, int n_primary_feat)
    {
        initialize_values_arr(n_samples, n_samples_test, n_primary_feat, true);
    }

    /**
     * @brief Initialize the node value arrays
     * @details Using the size of the initial feature space constructor the storage arrays
     *
     * @param task_sz_train Number of training samples per task
     * @param task_sz_test Number of test sample per task
     * @param n_primary_feat Number of primary features
     */
    void initialize_values_arr(std::vector<int> task_sz_train, std::vector<int> task_sz_test, int n_primary_feat);

    /**
     * @brief Resize the node value arrays
     * @details Using the updated number of features increase the size of the storage arrays
     *
     * @param n_dims Number of dimensions to store
     * @param n_feat number of features to store
     * @param use_temp If true keep the temporary_storage
     */
    void resize_values_arr(int n_dims, unsigned long int n_feat, bool use_temp);

    /**
     * @brief Initialize the descriptor matrix
     * @details Initialize an empty descriptor matrix
     *
     */
    void initialize_d_matrix_arr();

    /**
     * @brief Resize the descriptor matrix
     * @details Using the number of newly selected features increase the size of the descriptor matrix
     *
     * @param n_select Number of features to select
     */
    void resize_d_matrix_arr(int n_select);

    /**
     * @brief Reset the global TASK_SZ_TRAIN vector
     *
     * @param task_sz_train the new task_sz train
     */
    void set_task_sz_train(std::vector<int> task_sz_train);

    /**
     * @brief Reset the global TASK_SZ_TEST vector
     *
     * @param task_sz_train the new test_sz train
     */
    void set_task_sz_test(std::vector<int> task_sz_test);

    /**
     * @brief Get a reference slot/feature register of the training data
     *
     * @param ind The Node's arr_ind
     * @param offset(int) Offset integer for TEMP_STORE_ARRAY
     *
     * @return The register element for a given feature index and offset
     */
    inline int& temp_storage_reg(unsigned long int ind, int offset = 0){return TEMP_STORAGE_REG[(ind % N_STORE_FEATURES) + (offset % 3) * N_STORE_FEATURES + omp_get_thread_num() * (N_STORE_FEATURES * 3 + 1)];}

    /**
     * @brief Get a reference slot/feature register of the test data
     *
     * @param ind The Node's arr_ind
     * @param offset(int) Offset integer for TEMP_STORE_TEST_ARRAY
     *
     * @return The register element for a given feature index and offset
     */
    inline int& temp_storage_test_reg(unsigned long int ind, int offset = 0){return TEMP_STORAGE_TEST_REG[(ind % N_STORE_FEATURES) + (offset % 3) * N_STORE_FEATURES + omp_get_thread_num() * (N_STORE_FEATURES * 3 + 1)];}

    /**
     * @brief Access element of the permanent training data storage array
     *
     * @param feature_ind The _arr_ind of Node to get the training data of
     *
     * @return pointer to the Node's training data
     */
    inline double* access_value_arr(unsigned long int feature_ind){return VALUES_ARR.data() + feature_ind*N_SAMPLES;}

    /**
     * @brief Access element of the permanent test data storage array
     *
     * @param feature_ind The _arr_ind of Node to get the test data of
     *
     * @return pointer to the Node's test data
     */
    inline double* access_test_value_arr(unsigned long int feature_ind){return TEST_VALUES_ARR.data() + feature_ind*N_SAMPLES_TEST;}

    /**
     * @brief Access element of temporary storage array for the training data
     *
     * @param slot The slot of the temporary storage array
     *
     * @return pointer to the data stored in the specified slot
     */
    inline double* access_temp_storage(unsigned long int slot){return TEMP_STORAGE_ARR.data() + slot*N_SAMPLES;}

    /**
     * @brief Access element of temporary storage array for the test data
     *
     * @param slot The slot of the temporary storage array
     *
     * @return pointer to the data stored in the specified slot
     */
    inline double* access_temp_storage_test(unsigned long int slot){return TEMP_STORAGE_TEST_ARR.data() + slot*N_SAMPLES_TEST;}

    /**
     * @brief Get a Node's value_ptr
     *
     * @param arr_ind Nodes _arr_ind
     * @param feat_ind Nodes _feat_ind
     * @param offset(int) the offset for temporary storage access
     *
     * @return The value pointer
     */
    double* get_value_ptr(unsigned long int arr_ind, unsigned long int feat_ind, int offset = 0);

    /**
     * @brief Get a Node's test_value_ptr
     *
     * @param arr_ind Nodes _arr_ind
     * @param feat_ind Nodes _feat_ind
     * @param offset(int) the offset for temporary storage access
     *
     * @return The value pointer
     */
    double* get_test_value_ptr(unsigned long int arr_ind, unsigned long int feat_ind, int offset = 0);

    /**
     * @brief Get the pointer to a particular selected Node from sis
     *
     * @param ind Index of the data in the descriptor matrix
     * @return The pointer to the descriptor matrix's data
     */
    inline double* get_d_matrix_ptr(int ind)
    {
        return D_MATRIX.data() + ind * N_SAMPLES;
    }

    /**
     * @brief Flush the temporary storage register (training data)
     * @details Reset all slots in the register to -1
     */
    inline void clear_temp_reg(){std::fill_n(TEMP_STORAGE_REG.data(), TEMP_STORAGE_REG.size(), -1);}

    /**
     * @brief Flush the temporary storage register (training data)
     * @details Reset all slots in the register to -1
     */
    inline void clear_temp_reg_thread(){std::fill_n(TEMP_STORAGE_REG.data() + N_STORE_FEATURES * 3 * omp_get_thread_num(), N_STORE_FEATURES * 3, -1);}

    /**
     * @brief Flush the temporary storage register (test data)
     * @details Reset all slots in the register to -1
     */
    inline void clear_temp_test_reg(){std::fill_n(TEMP_STORAGE_TEST_REG.data(), TEMP_STORAGE_TEST_REG.size(), -1);}

}

#endif