auto_arima.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020-2021, NVIDIA CORPORATION.
 *
 * 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
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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.
 */
 
#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