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

61
62
63
64
    extern std::vector<double> STANDARDIZED_D_MATRIX; //!< The descriptor matrix filled with standardized feature values (Central storage for the selected feature space)
    extern std::vector<double> STANDARDIZED_STORAGE_ARR; //!< //!< The vector used to temporarily store the values of the standardized feature training values
    extern std::vector<double> STANDARDIZED_TEST_STORAGE_ARR; //!< //!< The vector used to temporarily store the values of the standardized feature test values

Thomas Purcell's avatar
Thomas Purcell committed
65
    extern int N_SELECTED; //!< Number of selected features
66
    extern int SZ_STAND_FEAT; //!< std::max(N_SELECTED, N_SAMPLES)
Thomas Purcell's avatar
Thomas Purcell committed
67
68
69
70
71

    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
72
    extern int N_STORE_FEATURES; //!< Number of features with stored values
Thomas Purcell's avatar
Thomas Purcell committed
73
    extern int N_RUNGS_STORED; //!< Maximum rung for permanently storing a features value
74
    extern int MAX_RUNG; //!< The maximum rung for all features
Thomas Purcell's avatar
Thomas Purcell committed
75

Thomas Purcell's avatar
Thomas Purcell committed
76
77
78
    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
79
80
81
82
83

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

86
87
88
89
90
91
92
93
94
95
96
97
    /**
     * @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
98

Thomas Purcell's avatar
Thomas Purcell committed
99
    /**
Thomas Purcell's avatar
Thomas Purcell committed
100
     * @brief Initialize all central storage vectors/descriptive variables
Thomas Purcell's avatar
Thomas Purcell committed
101
     *
Thomas Purcell's avatar
Thomas Purcell committed
102
103
104
105
106
     * @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
107
     */
108
109
110
111
112
113
114
    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
115
116

    /**
Thomas Purcell's avatar
Thomas Purcell committed
117
     * @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
118
     *
Thomas Purcell's avatar
Thomas Purcell committed
119
120
     * @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
121
     */
Thomas Purcell's avatar
Thomas Purcell committed
122
    void resize_values_arr(const int n_dims, const int n_feat);
Thomas Purcell's avatar
Thomas Purcell committed
123

Thomas Purcell's avatar
Thomas Purcell committed
124
    // DocString: node_vals_init_param
125
126
127
    /**
     * @brief Initialize the parameter storage array
     */
Thomas Purcell's avatar
Thomas Purcell committed
128

129
130
    void initialize_param_storage();

Thomas Purcell's avatar
Thomas Purcell committed
131
    // DocString: node_vals_init_d_mat
132
    /**
133
     * @brief Initialize the descriptor matrix
134
135
136
137
138
     *
     */
    void initialize_d_matrix_arr();

    /**
Thomas Purcell's avatar
Thomas Purcell committed
139
     * @brief Resize the descriptor matrix for the new number of selected features
140
141
142
     *
     * @param n_select Number of features to select
     */
143
    void resize_d_matrix_arr(const int n_select);
144

Thomas Purcell's avatar
Thomas Purcell committed
145
146
147
148
149
    /**
     * @brief Reset the global TASK_SZ_TRAIN vector
     *
     * @param task_sz_train the new task_sz train
     */
150
    void set_task_sz_train(const std::vector<int> task_sz_train);
Thomas Purcell's avatar
Thomas Purcell committed
151
152
153
154
155
156

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

159
160
161
162
163
164
165
    /**
     * @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);

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

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

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

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

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

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

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

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

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

298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
    /**
     * @brief Access element of temporary standardized 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_stand_storage(const unsigned long int slot){return &STANDARDIZED_STORAGE_ARR[slot*SZ_STAND_FEAT];}

    /**
     * @brief Access element of temporary standardized 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_stand_storage_test(const unsigned long int slot){return &STANDARDIZED_TEST_STORAGE_ARR[slot*N_SAMPLES_TEST];}

316
317
318
319
    /**
     * @brief Access the param storage array
     *
     * @param rung Rung of the feature
Thomas Purcell's avatar
Thomas Purcell committed
320
     * @param offset Offset used to prevent overwrites (determines where in the binary expression tree this operator is)
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
     * @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
339
     * @param offset Offset used to prevent overwrites (determines where in the binary expression tree this operator is)
340
341
342
343
344
345
346
347
348
349
350
351
352
353
     * @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
354
    /**
355
     * @brief Get a Node's value_ptr
Thomas Purcell's avatar
Thomas Purcell committed
356
     *
357
358
     * @param arr_ind Nodes _arr_ind
     * @param feat_ind Nodes _feat_ind
359
     * @param rung Rung of the feature
Thomas Purcell's avatar
Thomas Purcell committed
360
     * @param offset Offset used to prevent overwrites (determines where in the binary expression tree this operator is)
361
     * @param for_comp If true get a slot dedicated to comparing features
Thomas Purcell's avatar
Thomas Purcell committed
362
363
364
     *
     * @return The value pointer
     */
365
366
367
368
369
    double* get_value_ptr(
        const unsigned long int arr_ind,
        const unsigned long int feat_ind,
        const int rung=0,
        const int offset=0,
370
        const bool for_comp=false
371
    );
Thomas Purcell's avatar
Thomas Purcell committed
372

373
    /**
374
     * @brief Get a Node's test_value_ptr
375
     *
376
377
     * @param arr_ind Nodes _arr_ind
     * @param feat_ind Nodes _feat_ind
378
     * @param rung Rung of the feature
Thomas Purcell's avatar
Thomas Purcell committed
379
     * @param offset Offset used to prevent overwrites (determines where in the binary expression tree this operator is)
380
     * @param for_comp If true get a slot dedicated to comparing features
381
382
383
     *
     * @return The value pointer
     */
384
385
386
387
388
    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,
389
        const bool for_comp=false
390
    );
391

392
    /**
393
     * @brief Get the pointer to a particular selected Node's data from sis
394
     *
395
     * @param ind Index of the data in the descriptor matrix
396
     * @return The pointer to the descriptor matrix's data
397
     */
398
    inline double* get_d_matrix_ptr(const int ind){return &D_MATRIX[ind * N_SAMPLES];}
Thomas Purcell's avatar
Bug Fix    
Thomas Purcell committed
399

Thomas Purcell's avatar
Thomas Purcell committed
400
    /**
401
     * @brief Get the pointer to a particular selected Node's data from sis
Thomas Purcell's avatar
Thomas Purcell committed
402
403
404
405
406
407
408
     *
     * @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]];}

409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
    /**
     * @brief Get the pointer to a particular selected Node's standardized from sis
     *
     * @param ind Index of the data in the descriptor matrix
     * @return The pointer to the descriptor matrix's standardized data
     */
    inline double* get_stand_d_matrix_ptr(const int ind){return &STANDARDIZED_D_MATRIX[ind * N_SAMPLES];}

    /**
     * @brief Get the pointer to a particular selected Node's standardized 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 standardized data
     */
    inline double* get_stand_d_matrix_ptr(const int ind, const int taskind){return &STANDARDIZED_D_MATRIX[ind * N_SAMPLES + TASK_START_TRAIN[taskind]];}

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

432
433
434
435
    /**
     * @brief Flush the temporary storage register (training data)
     * @details Reset all slots in the register to -1
     */
436
437
    inline void clear_temp_reg_thread()
    {
Thomas Purcell's avatar
Thomas Purcell committed
438
        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);
439
    }
440

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

447
448
#ifdef PY_BINDINGS

449
    // DocString: node_vals_ts_list_no_params
450
451
452
453
    /**
     * @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
454
455
456
457
     * @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
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
     */
    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
        );
    }

475
    // DocString: node_vals_ts_arr_no_params
476
477
478
479
    /**
     * @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
480
481
482
483
     * @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
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
     */
    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
        );
    }
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555

    // 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
        );
    }
556
#endif
Thomas Purcell's avatar
Thomas Purcell committed
557
558
}

559
#endif