nodes_value_containers.hpp 19.3 KB
Newer Older
1
// Copyright 2021 Thomas A. R. Purcell
2
//
3
4
5
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
6
//
7
//     http://www.apache.org/licenses/LICENSE-2.0
8
//
9
10
11
12
13
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
14

15
/** @file feature_creation/node/value_storage/node_value_containers.hpp
16
 *  @brief Creates a central storage area for the feature's input data and the descriptor matrix
17
 *
18
 *  @author Thomas A. R. Purcell (tpurcell90)
19
20
 *  @bug No known bugs.
 */
21

22
23
#ifndef NODE_VALUE_ARR
#define NODE_VALUE_ARR
Thomas Purcell's avatar
Thomas Purcell committed
24

Thomas Purcell's avatar
Thomas Purcell committed
25
#include <algorithm>
26
#include <cmath>
Thomas Purcell's avatar
Thomas Purcell committed
27
#include <memory>
Thomas Purcell's avatar
Thomas Purcell committed
28
#include <numeric>
Thomas Purcell's avatar
Thomas Purcell committed
29
#include <vector>
30
#include <iostream>
Thomas Purcell's avatar
Thomas Purcell committed
31

32
33
#include <omp.h>

Thomas Purcell's avatar
Thomas Purcell committed
34
#include"utils/enum.hpp"
Thomas Purcell's avatar
Thomas Purcell committed
35

36
#ifdef PY_BINDINGS
37
#include "python/py_binding_cpp_def/conversion_utils.hpp"
38
39
40
41
namespace np = boost::python::numpy;
namespace py = boost::python;
#endif

Thomas Purcell's avatar
Thomas Purcell committed
42
43
namespace node_value_arrs
{
Thomas Purcell's avatar
Thomas Purcell committed
44
45
46
47
48
49
50
51
52
53
54
55
56
    extern std::vector<double> VALUES_ARR; //!< The central storage location for the values of the training data for each feature with a rung <= N_RUNGS_STORED
    extern std::vector<double> TEST_VALUES_ARR; //!< The central storage location for the values of the test data for each feature with a rung <= N_RUNGS_STORED

    extern std::vector<double> TEMP_STORAGE_ARR; //!< The vector used to temporarily store the values of each feature with a rung > N_RUNGS_STORED (These are calculated on the fly when the values are required)
    extern std::vector<double> TEMP_STORAGE_TEST_ARR; //!< The vector used to temporarily store the values of each feature with a rung > N_RUNGS_STORED (These are calculated on the fly when the values are required)
    extern std::vector<int> TEMP_STORAGE_REG; //!< Register that maps the slots in TEMP_STORAGE_ARR to the index of the feature whose data is currently stored there (reset by setting all elements of this vector to -1)
    extern std::vector<int> TEMP_STORAGE_TEST_REG; //!< Register that maps the slots in TEMP_STORAGE_TEST_ARR to the index of the feature whose data is currently stored there (reset by setting all elements of this vector to -1)

    extern std::vector<double> PARAM_STORAGE_ARR; //!< The vector used to temporarily store the values of each feature that has free-parameters (These are calculated on the fly when the values are required)
    extern std::vector<double> PARAM_STORAGE_TEST_ARR; //!< The vector used to temporarily store the values of each feature that has free-parameters (These are calculated on the fly when the values are required)

    extern std::vector<double> D_MATRIX; //!< The descriptor matrix (Central storage for the selected feature space)

Thomas Purcell's avatar
Thomas Purcell committed
57
    extern std::vector<int> TASK_SZ_TRAIN; //!< Number of training samples per task
Thomas Purcell's avatar
Thomas Purcell committed
58
    extern std::vector<int> TASK_START_TRAIN; //!< The starting point for each task in the training data
Thomas Purcell's avatar
Thomas Purcell committed
59
60
    extern std::vector<int> TASK_SZ_TEST; //!< Number of test sample per task

Thomas Purcell's avatar
Thomas Purcell committed
61
62
63
64
65
66
    extern int N_SELECTED; //!< Number of selected features

    extern int N_SAMPLES; //!< Number of training samples for each feature (Sum of all elements in TASK_SZ_TRAIN)
    extern int N_SAMPLES_TEST; //!< Number of test samples for each feature (Sum of all elements in TASK_SZ_TEST)

    extern int N_PRIMARY_FEATURES; //!< Number of primary features
Thomas Purcell's avatar
Thomas Purcell committed
67
    extern int N_STORE_FEATURES; //!< Number of features with stored values
Thomas Purcell's avatar
Thomas Purcell committed
68
    extern int N_RUNGS_STORED; //!< Maximum rung for permanently storing a features value
69
    extern int MAX_RUNG; //!< The maximum rung for all features
Thomas Purcell's avatar
Thomas Purcell committed
70

Thomas Purcell's avatar
Thomas Purcell committed
71
72
73
    extern int MAX_N_THREADS; //!< Get the maximum number of threads possible for a calculation
    extern int N_OP_SLOTS; //!< The number of possible nodes of the binary expression tree that maybe calculated on the fly
    extern int N_PARAM_OP_SLOTS; //!< The number of possible non-leaf nodes of the binary expression tree
74
75
76
77
78
79
80
81
82
83
84
85
    /**
     * @brief Initialize all central storage vectors/descriptive variables without changing MAX_RUNG
     *
     * @param n_samples The number of training samples for each feature (Sum of all elements in TASK_SZ_TRAIN)
     * @param n_samples_test The number of test samples for each feature (Sum of all elements in TASK_SZ_TEST)
     * @param n_primary_feat The number of primary features
     */
    void initialize_values_arr(
        const int n_samples,
        const int n_samples_test,
        const int n_primary_feat
    );
Thomas Purcell's avatar
Thomas Purcell committed
86

Thomas Purcell's avatar
Thomas Purcell committed
87
    /**
Thomas Purcell's avatar
Thomas Purcell committed
88
     * @brief Initialize all central storage vectors/descriptive variables
Thomas Purcell's avatar
Thomas Purcell committed
89
     *
Thomas Purcell's avatar
Thomas Purcell committed
90
91
92
93
     * @param n_samples The number of training samples for each feature (Sum of all elements in TASK_SZ_TRAIN)
     * @param n_samples_test The number of test samples for each feature (Sum of all elements in TASK_SZ_TEST)
     * @param n_primary_feat The number of primary features
     * @param max_rung The maximum rung for all features
Thomas Purcell's avatar
Thomas Purcell committed
94
     * @param set_test_task_sz If True reset the task_sz vectors
Thomas Purcell's avatar
Thomas Purcell committed
95
     * @param use_params If True set up parameterized feature storage as well
Thomas Purcell's avatar
Thomas Purcell committed
96
     */
97
98
99
100
101
102
103
104
    void initialize_values_arr(
        const int n_samples,
        const int n_samples_test,
        const int n_primary_feat,
        const int max_rung,
        const bool set_task_sz,
        const bool use_params
    );
Thomas Purcell's avatar
Thomas Purcell committed
105

106
    // DocString: node_vals_init_no_ts
Thomas Purcell's avatar
Thomas Purcell committed
107
    /**
Thomas Purcell's avatar
Thomas Purcell committed
108
     * @brief Initialize all central storage vectors/descriptive variables
Thomas Purcell's avatar
Thomas Purcell committed
109
     *
Thomas Purcell's avatar
Thomas Purcell committed
110
111
112
113
     * @param n_samples The number of training samples for each feature (Sum of all elements in TASK_SZ_TRAIN)
     * @param n_samples_test The number of test samples for each feature (Sum of all elements in TASK_SZ_TEST)
     * @param n_primary_feat The number of primary features
     * @param max_rung The maximum rung for all features
Thomas Purcell's avatar
Thomas Purcell committed
114
     */
115
116
117
118
119
120
    inline void initialize_values_arr(
        const int n_samples,
        const int n_samples_test,
        const int n_primary_feat,
        const int max_rung
    )
Thomas Purcell's avatar
Thomas Purcell committed
121
    {
122
        initialize_values_arr(n_samples, n_samples_test, n_primary_feat, max_rung, true, false);
Thomas Purcell's avatar
Thomas Purcell committed
123
124
125
    }

    /**
Thomas Purcell's avatar
Thomas Purcell committed
126
     * @brief Initialize all central storage vectors/descriptive variables
Thomas Purcell's avatar
Thomas Purcell committed
127
     *
Thomas Purcell's avatar
Thomas Purcell committed
128
129
130
131
132
     * @param task_sz_train The number of training samples per task
     * @param task_sz_test The number of test sample per task
     * @param n_primary_feat The number of primary features
     * @param max_rung The maximum rung for all features
     * @param use_params If True set up parameterized feature storage as well
Thomas Purcell's avatar
Thomas Purcell committed
133
     */
134
135
136
137
138
139
140
    void initialize_values_arr(
        const std::vector<int> task_sz_train,
        const std::vector<int> task_sz_test,
        const int n_primary_feat,
        const int max_rung,
        const bool use_params
    );
Thomas Purcell's avatar
Thomas Purcell committed
141
142

    /**
Thomas Purcell's avatar
Thomas Purcell committed
143
     * @brief Resize the central storage array given a new number of features and the current rung of the features
Thomas Purcell's avatar
Thomas Purcell committed
144
     *
Thomas Purcell's avatar
Thomas Purcell committed
145
146
     * @param n_rung The current rung of the generated features
     * @param n_feat The new number of features to store
Thomas Purcell's avatar
Thomas Purcell committed
147
     */
Thomas Purcell's avatar
Thomas Purcell committed
148
    void resize_values_arr(const int n_dims, const int n_feat);
Thomas Purcell's avatar
Thomas Purcell committed
149

Thomas Purcell's avatar
Thomas Purcell committed
150
    // DocString: node_vals_init_param
151
152
153
    /**
     * @brief Initialize the parameter storage array
     */
Thomas Purcell's avatar
Thomas Purcell committed
154

155
156
    void initialize_param_storage();

Thomas Purcell's avatar
Thomas Purcell committed
157
    // DocString: node_vals_init_d_mat
158
    /**
159
     * @brief Initialize the descriptor matrix
160
161
162
163
164
     *
     */
    void initialize_d_matrix_arr();

    /**
Thomas Purcell's avatar
Thomas Purcell committed
165
     * @brief Resize the descriptor matrix for the new number of selected features
166
167
168
     *
     * @param n_select Number of features to select
     */
169
    void resize_d_matrix_arr(const int n_select);
170

Thomas Purcell's avatar
Thomas Purcell committed
171
172
173
174
175
    /**
     * @brief Reset the global TASK_SZ_TRAIN vector
     *
     * @param task_sz_train the new task_sz train
     */
176
    void set_task_sz_train(const std::vector<int> task_sz_train);
Thomas Purcell's avatar
Thomas Purcell committed
177
178
179
180
181
182

    /**
     * @brief Reset the global TASK_SZ_TEST vector
     *
     * @param task_sz_train the new test_sz train
     */
183
    void set_task_sz_test(const std::vector<int> task_sz_test);
Thomas Purcell's avatar
Thomas Purcell committed
184

185
186
187
188
189
190
191
    /**
     * @brief Set max_rung and initialize the temporary storage arrays
     *
     * @param max_rung The maximum rung for the calculation
     */
    void set_max_rung(const int max_rung, bool use_params=false);

192
193
194
195
    /**
     * @brief Get the operator slot associated with a given rung/offset
     *
     * @param rung Rung of the feature
Thomas Purcell's avatar
Thomas Purcell committed
196
     * @param offset Offset used to prevent overwrites (determines where in the binary expression tree this operator is)
197
     * @param for_comp If true get a slot dedicated to comparing features
198
199
200
     *
     * @return The operator slot to use
     */
201
    inline int get_op_slot(const int rung, const int offset, const bool for_comp)
202
203
204
    {
        return std::abs(N_OP_SLOTS / (1 + !for_comp) - static_cast<int>(std::pow(2, MAX_RUNG - rung)) - offset);
    }
205

206
207
208
209
    /**
     * @brief Get the parameter operator slot associated with a given rung/offset
     *
     * @param rung Rung of the feature
Thomas Purcell's avatar
Thomas Purcell committed
210
     * @param offset Offset used to prevent overwrites (determines where in the binary expression tree this operator is)
211
212
213
214
215
216
217
218
219
     * @param for_comp If true get a slot dedicated to comparing features
     *
     * @return The operator slot to use
     */
    inline int get_param_op_slot(const int rung, const int offset, const bool for_comp)
    {
        return std::abs(N_PARAM_OP_SLOTS / (1 + !for_comp) - static_cast<int>(std::pow(2, MAX_RUNG - rung)) - offset);
    }

Thomas Purcell's avatar
Thomas Purcell committed
220
    /**
221
     * @brief Get a reference slot/feature register of the training data
Thomas Purcell's avatar
Thomas Purcell committed
222
     *
223
     * @param ind The Node's arr_ind
224
225
226
227
     * @param op_slot(int) Offset integer for TEMP_STORE_ARRAY
     *
     * @return The register element for a given feature index and op_slot
     */
228
    inline int& temp_storage_reg(const unsigned long int ind, const int op_slot=0)
229
230
    {
        return TEMP_STORAGE_REG[
Thomas Purcell's avatar
Thomas Purcell committed
231
            (ind % N_PRIMARY_FEATURES) + (op_slot % N_OP_SLOTS) * N_PRIMARY_FEATURES + omp_get_thread_num() * (N_PRIMARY_FEATURES * N_OP_SLOTS + 1)
232
233
        ];
    }
234
235
236
237
238
239
240
241
242

    /**
     * @brief Get a reference slot/feature register of the test data
     *
     * @param ind The Node's arr_ind
     * @param op_slot(int) Offset integer for TEMP_STORE_TEST_ARRAY
     *
     * @return The register element for a given feature index and op_slot
     */
243
    inline int& temp_storage_test_reg(const unsigned long int ind, const int op_slot=0)
244
245
    {
        return TEMP_STORAGE_TEST_REG[
Thomas Purcell's avatar
Thomas Purcell committed
246
            (ind % N_PRIMARY_FEATURES) + (op_slot % N_OP_SLOTS) * N_PRIMARY_FEATURES + omp_get_thread_num() * (N_PRIMARY_FEATURES * N_OP_SLOTS + 1)
247
248
        ];
    }
249

Thomas Purcell's avatar
Thomas Purcell committed
250
    /**
251
     * @brief Get a reference slot/feature register of the training data
Thomas Purcell's avatar
Thomas Purcell committed
252
     *
253
     * @param ind The Node's arr_ind
254
     * @param rung Rung of the feature
Thomas Purcell's avatar
Thomas Purcell committed
255
     * @param offset Offset used to prevent overwrites (determines where in the binary expression tree this operator is)
256
     * @param for_comp If true get a slot dedicated to comparing features
Thomas Purcell's avatar
Thomas Purcell committed
257
258
259
     *
     * @return The register element for a given feature index and offset
     */
260
    inline int& temp_storage_reg(const unsigned long int ind, const int rung, const int offset, const bool for_comp)
261
262
    {
        return TEMP_STORAGE_REG[
Thomas Purcell's avatar
Thomas Purcell committed
263
264
265
            (ind % N_PRIMARY_FEATURES) +
            (get_op_slot(rung, offset, for_comp) % N_OP_SLOTS) * N_PRIMARY_FEATURES +
            omp_get_thread_num() * (N_PRIMARY_FEATURES * N_OP_SLOTS + 1)
266
267
        ];
    }
Thomas Purcell's avatar
Thomas Purcell committed
268

269
    /**
270
     * @brief Get a reference slot/feature register of the test data
271
     *
272
     * @param ind The Node's arr_ind
273
     * @param rung Rung of the feature
Thomas Purcell's avatar
Thomas Purcell committed
274
     * @param offset Offset used to prevent overwrites (determines where in the binary expression tree this operator is)
275
     * @param for_comp If true get a slot dedicated to comparing features
276
277
278
     *
     * @return The register element for a given feature index and offset
     */
279
    inline int& temp_storage_test_reg(const unsigned long int ind, const int rung, const int offset, const bool for_comp)
280
281
    {
        return TEMP_STORAGE_TEST_REG[
Thomas Purcell's avatar
Thomas Purcell committed
282
            (ind % N_PRIMARY_FEATURES) +
Thomas Purcell's avatar
Thomas Purcell committed
283
284
            (get_op_slot(rung, offset, for_comp) % N_OP_SLOTS) * N_PRIMARY_FEATURES +
            omp_get_thread_num() * (N_PRIMARY_FEATURES * N_OP_SLOTS + 1)
285
286
        ];
    }
287

Thomas Purcell's avatar
Thomas Purcell committed
288
    /**
289
     * @brief Access element of the permanent training data storage array
Thomas Purcell's avatar
Thomas Purcell committed
290
     *
Thomas Purcell's avatar
Thomas Purcell committed
291
     * @param feature_ind The _feat_ind of Node to get the training data of
Thomas Purcell's avatar
Thomas Purcell committed
292
     *
293
     * @return pointer to the Node's training data
Thomas Purcell's avatar
Thomas Purcell committed
294
     */
295
    inline double* access_value_arr(const unsigned long int feature_ind){return &VALUES_ARR[feature_ind*N_SAMPLES];}
296

297
    /**
298
     * @brief Access element of the permanent test data storage array
299
     *
Thomas Purcell's avatar
Thomas Purcell committed
300
     * @param feature_ind The _feat_ind of Node to get the test data of
301
     *
302
     * @return pointer to the Node's test data
303
     */
304
    inline double* access_test_value_arr(const unsigned long int feature_ind){return &TEST_VALUES_ARR[feature_ind*N_SAMPLES_TEST];}
305

Thomas Purcell's avatar
Thomas Purcell committed
306
    /**
307
     * @brief Access element of temporary storage array for the training data
Thomas Purcell's avatar
Thomas Purcell committed
308
     *
309
     * @param slot The slot of the temporary storage array
Thomas Purcell's avatar
Thomas Purcell committed
310
     *
311
     * @return pointer to the data stored in the specified slot
Thomas Purcell's avatar
Thomas Purcell committed
312
     */
313
    inline double* access_temp_storage(const unsigned long int slot){return &TEMP_STORAGE_ARR[slot*N_SAMPLES];}
314

315
    /**
316
     * @brief Access element of temporary storage array for the test data
317
     *
318
     * @param slot The slot of the temporary storage array
319
     *
320
     * @return pointer to the data stored in the specified slot
321
     */
322
    inline double* access_temp_storage_test(const unsigned long int slot){return &TEMP_STORAGE_TEST_ARR[slot*N_SAMPLES_TEST];}
323

324
325
326
327
    /**
     * @brief Access the param storage array
     *
     * @param rung Rung of the feature
Thomas Purcell's avatar
Thomas Purcell committed
328
     * @param offset Offset used to prevent overwrites (determines where in the binary expression tree this operator is)
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
     * @param for_comp If true get a slot dedicated to comparing features
     * @return pointer to the correct element of the PARAM_STORAGE_ARR
     */
    inline double* access_param_storage(const int rung=0, const int offset=0, const bool for_comp=false)
    {
        return &PARAM_STORAGE_ARR[
            N_SAMPLES *
            (
                (get_param_op_slot(rung, offset, for_comp) % N_PARAM_OP_SLOTS) +
                omp_get_thread_num() * (N_PARAM_OP_SLOTS + 1)
            )
        ];
    }

    /**
     * @brief Access the param storage array for the test set
     *
     * @param rung Rung of the feature
Thomas Purcell's avatar
Thomas Purcell committed
347
     * @param offset Offset used to prevent overwrites (determines where in the binary expression tree this operator is)
348
349
350
351
352
353
354
355
356
357
358
359
360
361
     * @param for_comp If true get a slot dedicated to comparing features
     * @return pointer to the correct element of the PARAM_STORAGE_ARR
     */
    inline double* access_param_storage_test(const int rung=0, const int offset=0, const bool for_comp=false)
    {
        return &PARAM_STORAGE_TEST_ARR[
            N_SAMPLES_TEST *
            (
                (get_param_op_slot(rung, offset, for_comp) % N_PARAM_OP_SLOTS) +
                omp_get_thread_num() * (N_PARAM_OP_SLOTS + 1)
            )
        ];
    }

Thomas Purcell's avatar
Thomas Purcell committed
362
    /**
363
     * @brief Get a Node's value_ptr
Thomas Purcell's avatar
Thomas Purcell committed
364
     *
365
366
     * @param arr_ind Nodes _arr_ind
     * @param feat_ind Nodes _feat_ind
367
     * @param rung Rung of the feature
Thomas Purcell's avatar
Thomas Purcell committed
368
     * @param offset Offset used to prevent overwrites (determines where in the binary expression tree this operator is)
369
     * @param for_comp If true get a slot dedicated to comparing features
Thomas Purcell's avatar
Thomas Purcell committed
370
371
372
     *
     * @return The value pointer
     */
373
374
375
376
377
    double* get_value_ptr(
        const unsigned long int arr_ind,
        const unsigned long int feat_ind,
        const int rung=0,
        const int offset=0,
378
        const bool for_comp=false
379
    );
Thomas Purcell's avatar
Thomas Purcell committed
380

381
    /**
382
     * @brief Get a Node's test_value_ptr
383
     *
384
385
     * @param arr_ind Nodes _arr_ind
     * @param feat_ind Nodes _feat_ind
386
     * @param rung Rung of the feature
Thomas Purcell's avatar
Thomas Purcell committed
387
     * @param offset Offset used to prevent overwrites (determines where in the binary expression tree this operator is)
388
     * @param for_comp If true get a slot dedicated to comparing features
389
390
391
     *
     * @return The value pointer
     */
392
393
394
395
396
    double* get_test_value_ptr(
        const unsigned long int arr_ind,
        const unsigned long int feat_ind,
        const int rung=0,
        const int offset=0,
397
        const bool for_comp=false
398
    );
399

400
    /**
401
     * @brief Get the pointer to a particular selected Node from sis
402
     *
403
     * @param ind Index of the data in the descriptor matrix
404
     * @return The pointer to the descriptor matrix's data
405
     */
406
    inline double* get_d_matrix_ptr(const int ind){return &D_MATRIX[ind * N_SAMPLES];}
Thomas Purcell's avatar
Bug Fix    
Thomas Purcell committed
407

Thomas Purcell's avatar
Thomas Purcell committed
408
409
410
411
412
413
414
415
416
    /**
     * @brief Get the pointer to a particular selected Node from sis
     *
     * @param ind Index of the data in the descriptor matrix
     * @param taskind The index for the given task
     * @return The pointer to the descriptor matrix's data
     */
    inline double* get_d_matrix_ptr(const int ind, const int taskind){return &D_MATRIX[ind * N_SAMPLES + TASK_START_TRAIN[taskind]];}

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

423
424
425
426
    /**
     * @brief Flush the temporary storage register (training data)
     * @details Reset all slots in the register to -1
     */
427
428
    inline void clear_temp_reg_thread()
    {
Thomas Purcell's avatar
Thomas Purcell committed
429
        std::fill_n(TEMP_STORAGE_REG.begin() + (N_PRIMARY_FEATURES * N_OP_SLOTS + 1) * omp_get_thread_num(), N_PRIMARY_FEATURES * N_OP_SLOTS + 1, -1);
430
    }
431

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

438
439
440
441
442
443
444
#ifdef PY_BINDINGS

    // DocString: node_vals_ts_list
    /**
     * @brief Initialize the node value arrays
     * @details Using the size of the initial feature space constructor the storage arrays
     *
Thomas Purcell's avatar
Thomas Purcell committed
445
446
447
448
     * @param task_sz_train (list) The number of training samples per task
     * @param task_sz_test (list) The number of test sample per task
     * @param n_primary_feat (int) The number of primary features
     * @param max_rung (int) The maximum rung for all features
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
     */
    inline void initialize_values_arr(
        py::list task_sz_train,
        py::list task_sz_test,
        int n_primary_feat,
        int max_rung
    )
    {
        initialize_values_arr(
            python_conv_utils::from_list<int>(task_sz_train),
            python_conv_utils::from_list<int>(task_sz_test),
            n_primary_feat,
            max_rung,
            false
        );
    }

    // DocString: node_vals_ts_arr
    /**
     * @brief Initialize the node value arrays
     * @details Using the size of the initial feature space constructor the storage arrays
     *
Thomas Purcell's avatar
Thomas Purcell committed
471
472
473
474
     * @param task_sz_train (np.ndarray) The number of training samples per task
     * @param task_sz_test (np.ndarray) The number of test sample per task
     * @param n_primary_feat (int) The number of primary features
     * @param max_rung (int) The maximum rung for all features
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
     */
    inline void initialize_values_arr(
        np::ndarray task_sz_train,
        np::ndarray task_sz_test,
        int n_primary_feat,
        int max_rung
    )
    {
        initialize_values_arr(
            python_conv_utils::from_ndarray<int>(task_sz_train),
            python_conv_utils::from_ndarray<int>(task_sz_test),
            n_primary_feat,
            max_rung,
            false
        );
    }
#endif
Thomas Purcell's avatar
Thomas Purcell committed
492
493
}

494
#endif