nodes_value_containers.hpp 19.9 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

    // DocString: node_vals_finalize
    /**
     * @brief Resize all storage arrays to be empty
     */
    void finialize_values_arr();

81
82
83
84
85
86
87
88
89
90
91
92
    /**
     * @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
93

Thomas Purcell's avatar
Thomas Purcell committed
94
    /**
Thomas Purcell's avatar
Thomas Purcell committed
95
     * @brief Initialize all central storage vectors/descriptive variables
Thomas Purcell's avatar
Thomas Purcell committed
96
     *
Thomas Purcell's avatar
Thomas Purcell committed
97
98
99
100
101
     * @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
102
     */
103
104
105
106
107
108
109
    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
110
111

    /**
Thomas Purcell's avatar
Thomas Purcell committed
112
     * @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
113
     *
Thomas Purcell's avatar
Thomas Purcell committed
114
115
     * @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
116
     */
Thomas Purcell's avatar
Thomas Purcell committed
117
    void resize_values_arr(const int n_dims, const int n_feat);
Thomas Purcell's avatar
Thomas Purcell committed
118

Thomas Purcell's avatar
Thomas Purcell committed
119
    // DocString: node_vals_init_param
120
121
122
    /**
     * @brief Initialize the parameter storage array
     */
Thomas Purcell's avatar
Thomas Purcell committed
123

124
125
    void initialize_param_storage();

Thomas Purcell's avatar
Thomas Purcell committed
126
    // DocString: node_vals_init_d_mat
127
    /**
128
     * @brief Initialize the descriptor matrix
129
130
131
132
133
     *
     */
    void initialize_d_matrix_arr();

    /**
Thomas Purcell's avatar
Thomas Purcell committed
134
     * @brief Resize the descriptor matrix for the new number of selected features
135
136
137
     *
     * @param n_select Number of features to select
     */
138
    void resize_d_matrix_arr(const int n_select);
139

Thomas Purcell's avatar
Thomas Purcell committed
140
141
142
143
144
    /**
     * @brief Reset the global TASK_SZ_TRAIN vector
     *
     * @param task_sz_train the new task_sz train
     */
145
    void set_task_sz_train(const std::vector<int> task_sz_train);
Thomas Purcell's avatar
Thomas Purcell committed
146
147
148
149
150
151

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

154
155
156
157
158
159
160
    /**
     * @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);

161
162
163
164
    /**
     * @brief Get the operator slot associated with a given rung/offset
     *
     * @param rung Rung of the feature
Thomas Purcell's avatar
Thomas Purcell committed
165
     * @param offset Offset used to prevent overwrites (determines where in the binary expression tree this operator is)
166
     * @param for_comp If true get a slot dedicated to comparing features
167
168
169
     *
     * @return The operator slot to use
     */
170
    inline int get_op_slot(const int rung, const int offset, const bool for_comp)
171
172
173
    {
        return std::abs(N_OP_SLOTS / (1 + !for_comp) - static_cast<int>(std::pow(2, MAX_RUNG - rung)) - offset);
    }
174

175
176
177
178
    /**
     * @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
179
     * @param offset Offset used to prevent overwrites (determines where in the binary expression tree this operator is)
180
181
182
183
184
185
186
187
188
     * @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
189
    /**
190
     * @brief Get a reference slot/feature register of the training data
Thomas Purcell's avatar
Thomas Purcell committed
191
     *
192
     * @param ind The Node's arr_ind
193
194
195
196
     * @param op_slot(int) Offset integer for TEMP_STORE_ARRAY
     *
     * @return The register element for a given feature index and op_slot
     */
197
    inline int& temp_storage_reg(const unsigned long int ind, const int op_slot=0)
198
199
    {
        return TEMP_STORAGE_REG[
Thomas Purcell's avatar
Thomas Purcell committed
200
            (ind % N_PRIMARY_FEATURES) + (op_slot % N_OP_SLOTS) * N_PRIMARY_FEATURES + omp_get_thread_num() * (N_PRIMARY_FEATURES * N_OP_SLOTS + 1)
201
202
        ];
    }
203
204
205
206
207
208
209
210
211

    /**
     * @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
     */
212
    inline int& temp_storage_test_reg(const unsigned long int ind, const int op_slot=0)
213
214
    {
        return TEMP_STORAGE_TEST_REG[
Thomas Purcell's avatar
Thomas Purcell committed
215
            (ind % N_PRIMARY_FEATURES) + (op_slot % N_OP_SLOTS) * N_PRIMARY_FEATURES + omp_get_thread_num() * (N_PRIMARY_FEATURES * N_OP_SLOTS + 1)
216
217
        ];
    }
218

Thomas Purcell's avatar
Thomas Purcell committed
219
    /**
220
     * @brief Get a reference slot/feature register of the training data
Thomas Purcell's avatar
Thomas Purcell committed
221
     *
222
     * @param ind The Node's arr_ind
223
     * @param rung Rung of the feature
Thomas Purcell's avatar
Thomas Purcell committed
224
     * @param offset Offset used to prevent overwrites (determines where in the binary expression tree this operator is)
225
     * @param for_comp If true get a slot dedicated to comparing features
Thomas Purcell's avatar
Thomas Purcell committed
226
227
228
     *
     * @return The register element for a given feature index and offset
     */
229
    inline int& temp_storage_reg(const unsigned long int ind, const int rung, const int offset, const bool for_comp)
230
231
    {
        return TEMP_STORAGE_REG[
Thomas Purcell's avatar
Thomas Purcell committed
232
233
234
            (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)
235
236
        ];
    }
Thomas Purcell's avatar
Thomas Purcell committed
237

238
    /**
239
     * @brief Get a reference slot/feature register of the test data
240
     *
241
     * @param ind The Node's arr_ind
242
     * @param rung Rung of the feature
Thomas Purcell's avatar
Thomas Purcell committed
243
     * @param offset Offset used to prevent overwrites (determines where in the binary expression tree this operator is)
244
     * @param for_comp If true get a slot dedicated to comparing features
245
246
247
     *
     * @return The register element for a given feature index and offset
     */
248
    inline int& temp_storage_test_reg(const unsigned long int ind, const int rung, const int offset, const bool for_comp)
249
250
    {
        return TEMP_STORAGE_TEST_REG[
Thomas Purcell's avatar
Thomas Purcell committed
251
            (ind % N_PRIMARY_FEATURES) +
Thomas Purcell's avatar
Thomas Purcell committed
252
253
            (get_op_slot(rung, offset, for_comp) % N_OP_SLOTS) * N_PRIMARY_FEATURES +
            omp_get_thread_num() * (N_PRIMARY_FEATURES * N_OP_SLOTS + 1)
254
255
        ];
    }
256

Thomas Purcell's avatar
Thomas Purcell committed
257
    /**
258
     * @brief Access element of the permanent training data storage array
Thomas Purcell's avatar
Thomas Purcell committed
259
     *
Thomas Purcell's avatar
Thomas Purcell committed
260
     * @param feature_ind The _feat_ind of Node to get the training data of
Thomas Purcell's avatar
Thomas Purcell committed
261
     *
262
     * @return pointer to the Node's training data
Thomas Purcell's avatar
Thomas Purcell committed
263
     */
264
    inline double* access_value_arr(const unsigned long int feature_ind){return &VALUES_ARR[feature_ind*N_SAMPLES];}
265

266
    /**
267
     * @brief Access element of the permanent test data storage array
268
     *
Thomas Purcell's avatar
Thomas Purcell committed
269
     * @param feature_ind The _feat_ind of Node to get the test data of
270
     *
271
     * @return pointer to the Node's test data
272
     */
273
    inline double* access_test_value_arr(const unsigned long int feature_ind){return &TEST_VALUES_ARR[feature_ind*N_SAMPLES_TEST];}
274

Thomas Purcell's avatar
Thomas Purcell committed
275
    /**
276
     * @brief Access element of temporary storage array for the training data
Thomas Purcell's avatar
Thomas Purcell committed
277
     *
278
     * @param slot The slot of the temporary storage array
Thomas Purcell's avatar
Thomas Purcell committed
279
     *
280
     * @return pointer to the data stored in the specified slot
Thomas Purcell's avatar
Thomas Purcell committed
281
     */
282
    inline double* access_temp_storage(const unsigned long int slot){return &TEMP_STORAGE_ARR[slot*N_SAMPLES];}
283

284
    /**
285
     * @brief Access element of temporary storage array for the test data
286
     *
287
     * @param slot The slot of the temporary storage array
288
     *
289
     * @return pointer to the data stored in the specified slot
290
     */
291
    inline double* access_temp_storage_test(const unsigned long int slot){return &TEMP_STORAGE_TEST_ARR[slot*N_SAMPLES_TEST];}
292

293
294
295
296
    /**
     * @brief Access the param storage array
     *
     * @param rung Rung of the feature
Thomas Purcell's avatar
Thomas Purcell committed
297
     * @param offset Offset used to prevent overwrites (determines where in the binary expression tree this operator is)
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
     * @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
316
     * @param offset Offset used to prevent overwrites (determines where in the binary expression tree this operator is)
317
318
319
320
321
322
323
324
325
326
327
328
329
330
     * @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
331
    /**
332
     * @brief Get a Node's value_ptr
Thomas Purcell's avatar
Thomas Purcell committed
333
     *
334
335
     * @param arr_ind Nodes _arr_ind
     * @param feat_ind Nodes _feat_ind
336
     * @param rung Rung of the feature
Thomas Purcell's avatar
Thomas Purcell committed
337
     * @param offset Offset used to prevent overwrites (determines where in the binary expression tree this operator is)
338
     * @param for_comp If true get a slot dedicated to comparing features
Thomas Purcell's avatar
Thomas Purcell committed
339
340
341
     *
     * @return The value pointer
     */
342
343
344
345
346
    double* get_value_ptr(
        const unsigned long int arr_ind,
        const unsigned long int feat_ind,
        const int rung=0,
        const int offset=0,
347
        const bool for_comp=false
348
    );
Thomas Purcell's avatar
Thomas Purcell committed
349

350
    /**
351
     * @brief Get a Node's test_value_ptr
352
     *
353
354
     * @param arr_ind Nodes _arr_ind
     * @param feat_ind Nodes _feat_ind
355
     * @param rung Rung of the feature
Thomas Purcell's avatar
Thomas Purcell committed
356
     * @param offset Offset used to prevent overwrites (determines where in the binary expression tree this operator is)
357
     * @param for_comp If true get a slot dedicated to comparing features
358
359
360
     *
     * @return The value pointer
     */
361
362
363
364
365
    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,
366
        const bool for_comp=false
367
    );
368

369
    /**
370
     * @brief Get the pointer to a particular selected Node from sis
371
     *
372
     * @param ind Index of the data in the descriptor matrix
373
     * @return The pointer to the descriptor matrix's data
374
     */
375
    inline double* get_d_matrix_ptr(const int ind){return &D_MATRIX[ind * N_SAMPLES];}
Thomas Purcell's avatar
Bug Fix    
Thomas Purcell committed
376

Thomas Purcell's avatar
Thomas Purcell committed
377
378
379
380
381
382
383
384
385
    /**
     * @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]];}

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

392
393
394
395
    /**
     * @brief Flush the temporary storage register (training data)
     * @details Reset all slots in the register to -1
     */
396
397
    inline void clear_temp_reg_thread()
    {
Thomas Purcell's avatar
Thomas Purcell committed
398
        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);
399
    }
400

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

407
408
#ifdef PY_BINDINGS

409
    // DocString: node_vals_ts_list_no_params
410
411
412
413
    /**
     * @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
414
415
416
417
     * @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
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
     */
    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
        );
    }

435
    // DocString: node_vals_ts_arr_no_params
436
437
438
439
    /**
     * @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
440
441
442
443
     * @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
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
     */
    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
        );
    }
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515

    // DocString: node_vals_ts_list
    /**
     * @brief Initialize the node value arrays
     * @details Using the size of the initial feature space constructor the storage arrays
     *
     * @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
     * @param use_params (bool): If true also initialize parameterized storage
     */
    inline void initialize_values_arr(
        py::list task_sz_train,
        py::list task_sz_test,
        int n_primary_feat,
        int max_rung,
        bool use_params
    )
    {
        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,
            use_params
        );
    }

    // DocString: node_vals_ts_arr
    /**
     * @brief Initialize the node value arrays
     * @details Using the size of the initial feature space constructor the storage arrays
     *
     * @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
     * @param use_params (bool): If true also initialize parameterized storage
     */
    inline void initialize_values_arr(
        np::ndarray task_sz_train,
        np::ndarray task_sz_test,
        int n_primary_feat,
        int max_rung,
        bool use_params
    )
    {
        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,
            use_params
        );
    }
516
#endif
Thomas Purcell's avatar
Thomas Purcell committed
517
518
}

519
#endif