auto_arima.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2020-2021, NVIDIA CORPORATION.
 * SPDX-License-Identifier: Apache-2.0
 */
 
#pragma once
 
namespace raft {
class handle_t;
}
 
namespace ML {
 
int divide_by_mask_build_index(const raft::handle_t& handle,
                               const bool* d_mask,
                               int* d_index,
                               int batch_size);
 
void divide_by_mask_execute(const raft::handle_t& handle,
                            const float* d_in,
                            const bool* d_mask,
                            const int* d_index,
                            float* d_out0,
                            float* d_out1,
                            int batch_size,
                            int n_obs);
void divide_by_mask_execute(const raft::handle_t& handle,
                            const double* d_in,
                            const bool* d_mask,
                            const int* d_index,
                            double* d_out0,
                            double* d_out1,
                            int batch_size,
                            int n_obs);
void divide_by_mask_execute(const raft::handle_t& handle,
                            const int* d_in,
                            const bool* d_mask,
                            const int* d_index,
                            int* d_out0,
                            int* d_out1,
                            int batch_size,
                            int n_obs);
 
void divide_by_min_build_index(const raft::handle_t& handle,
                               const float* d_matrix,
                               int* d_batch,
                               int* d_index,
                               int* h_size,
                               int batch_size,
                               int n_sub);
void divide_by_min_build_index(const raft::handle_t& handle,
                               const double* d_matrix,
                               int* d_batch,
                               int* d_index,
                               int* h_size,
                               int batch_size,
                               int n_sub);
 
void divide_by_min_execute(const raft::handle_t& handle,
                           const float* d_in,
                           const int* d_batch,
                           const int* d_index,
                           float** hd_out,
                           int batch_size,
                           int n_sub,
                           int n_obs);
void divide_by_min_execute(const raft::handle_t& handle,
                           const double* d_in,
                           const int* d_batch,
                           const int* d_index,
                           double** hd_out,
                           int batch_size,
                           int n_sub,
                           int n_obs);
void divide_by_min_execute(const raft::handle_t& handle,
                           const int* d_in,
                           const int* d_batch,
                           const int* d_index,
                           int** hd_out,
                           int batch_size,
                           int n_sub,
                           int n_obs);
 
void build_division_map(const raft::handle_t& handle,
                        const int* const* hd_id,
                        const int* h_size,
                        int* d_id_to_pos,
                        int* d_id_to_model,
                        int batch_size,
                        int n_sub);
 
void merge_series(const raft::handle_t& handle,
                  const float* const* hd_in,
                  const int* d_id_to_pos,
                  const int* d_id_to_sub,
                  float* d_out,
                  int batch_size,
                  int n_sub,
                  int n_obs);
void merge_series(const raft::handle_t& handle,
                  const double* const* hd_in,
                  const int* d_id_to_pos,
                  const int* d_id_to_sub,
                  double* d_out,
                  int batch_size,
                  int n_sub,
                  int n_obs);
 
}  // namespace ML