autofixes: Refactor if expression and clangformat (#4081)

* Refactor `if` expression

* update clang format

Signed-off-by: Wenqi Li <[email protected]>

* [MONAI] python code formatting

Signed-off-by: monai-bot <[email protected]>

Co-authored-by: deepsource-autofix[bot] <62050782+deepsource-autofix[bot]@users.noreply.github.com>
Co-authored-by: monai-bot <[email protected]>

Author: deepsource-autofix[bot]

monai/_extensions/gmm/gmm.cpp

@@ -15,75 +15,71 @@ limitations under the License.
 
 #include "gmm.h"
 
-py::tuple init()
-{
-    torch::Tensor gmm_tensor = torch::zeros({GMM_COUNT, GMM_COMPONENT_COUNT}, torch::dtype(torch::kFloat32).device(torch::kCUDA));
-    torch::Tensor scratch_tensor = torch::empty({1}, torch::dtype(torch::kFloat32).device(torch::kCUDA));
-    return py::make_tuple(gmm_tensor, scratch_tensor);
+py::tuple init() {
+  torch::Tensor gmm_tensor =
+      torch::zeros({GMM_COUNT, GMM_COMPONENT_COUNT}, torch::dtype(torch::kFloat32).device(torch::kCUDA));
+  torch::Tensor scratch_tensor = torch::empty({1}, torch::dtype(torch::kFloat32).device(torch::kCUDA));
+  return py::make_tuple(gmm_tensor, scratch_tensor);
 }
 
-void learn(torch::Tensor gmm_tensor, torch::Tensor scratch_tensor, torch::Tensor input_tensor, torch::Tensor label_tensor)
-{
-    c10::DeviceType device_type = input_tensor.device().type();
-
-    unsigned int batch_count = input_tensor.size(0);
-    unsigned int element_count = input_tensor.stride(1);
-
-    unsigned int scratch_size = batch_count * (element_count + GMM_COMPONENT_COUNT * GMM_COUNT * (element_count / (32 * 32)));
-
-    if (scratch_tensor.size(0) < scratch_size)
-    {
-        scratch_tensor.resize_({scratch_size});
-    }
-
-    float* gmm = gmm_tensor.data_ptr<float>();
-    float* scratch = scratch_tensor.data_ptr<float>();
-    float* input = input_tensor.data_ptr<float>();
-    int* labels = label_tensor.data_ptr<int>();
-
-    if(device_type == torch::kCUDA)
-    {
-        learn_cuda(input, labels, gmm, scratch, batch_count, element_count);
-    }
-    else
-    {
-        learn_cpu(input, labels, gmm, scratch, batch_count, element_count);
-    }
+void learn(
+    torch::Tensor gmm_tensor,
+    torch::Tensor scratch_tensor,
+    torch::Tensor input_tensor,
+    torch::Tensor label_tensor) {
+  c10::DeviceType device_type = input_tensor.device().type();
+
+  unsigned int batch_count = input_tensor.size(0);
+  unsigned int element_count = input_tensor.stride(1);
+
+  unsigned int scratch_size =
+      batch_count * (element_count + GMM_COMPONENT_COUNT * GMM_COUNT * (element_count / (32 * 32)));
+
+  if (scratch_tensor.size(0) < scratch_size) {
+    scratch_tensor.resize_({scratch_size});
+  }
+
+  float* gmm = gmm_tensor.data_ptr<float>();
+  float* scratch = scratch_tensor.data_ptr<float>();
+  float* input = input_tensor.data_ptr<float>();
+  int* labels = label_tensor.data_ptr<int>();
+
+  if (device_type == torch::kCUDA) {
+    learn_cuda(input, labels, gmm, scratch, batch_count, element_count);
+  } else {
+    learn_cpu(input, labels, gmm, scratch, batch_count, element_count);
+  }
 }
 
-torch::Tensor apply(torch::Tensor gmm_tensor, torch::Tensor input_tensor)
-{
-    c10::DeviceType device_type = input_tensor.device().type();
-
-    unsigned int dim = input_tensor.dim();
-    unsigned int batch_count = input_tensor.size(0);
-    unsigned int element_count = input_tensor.stride(1);
-
-    long int* output_size = new long int[dim];
-    memcpy(output_size, input_tensor.sizes().data(), dim * sizeof(long int));
-    output_size[1] = MIXTURE_COUNT;
-    torch::Tensor output_tensor = torch::empty(c10::IntArrayRef(output_size, dim), torch::dtype(torch::kFloat32).device(device_type));
-    delete output_size;
-
-    const float* gmm = gmm_tensor.data_ptr<float>();
-    const float* input = input_tensor.data_ptr<float>();
-    float* output = output_tensor.data_ptr<float>();
-
-    if(device_type == torch::kCUDA)
-    {
-        apply_cuda(gmm, input, output, batch_count, element_count);
-    }
-    else
-    {
-        apply_cpu(gmm, input, output, batch_count, element_count);
-    }
-
-    return output_tensor;
+torch::Tensor apply(torch::Tensor gmm_tensor, torch::Tensor input_tensor) {
+  c10::DeviceType device_type = input_tensor.device().type();
+
+  unsigned int dim = input_tensor.dim();
+  unsigned int batch_count = input_tensor.size(0);
+  unsigned int element_count = input_tensor.stride(1);
+
+  long int* output_size = new long int[dim];
+  memcpy(output_size, input_tensor.sizes().data(), dim * sizeof(long int));
+  output_size[1] = MIXTURE_COUNT;
+  torch::Tensor output_tensor =
+      torch::empty(c10::IntArrayRef(output_size, dim), torch::dtype(torch::kFloat32).device(device_type));
+  delete output_size;
+
+  const float* gmm = gmm_tensor.data_ptr<float>();
+  const float* input = input_tensor.data_ptr<float>();
+  float* output = output_tensor.data_ptr<float>();
+
+  if (device_type == torch::kCUDA) {
+    apply_cuda(gmm, input, output, batch_count, element_count);
+  } else {
+    apply_cpu(gmm, input, output, batch_count, element_count);
+  }
+
+  return output_tensor;
 }
 
-PYBIND11_MODULE(TORCH_EXTENSION_NAME, m)
-{
-    m.def("init", torch::wrap_pybind_function(init));
-    m.def("learn", torch::wrap_pybind_function(learn));
-    m.def("apply", torch::wrap_pybind_function(apply));
+PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
+  m.def("init", torch::wrap_pybind_function(init));
+  m.def("learn", torch::wrap_pybind_function(learn));
+  m.def("apply", torch::wrap_pybind_function(apply));
 }

monai/_extensions/gmm/gmm.h

@@ -24,9 +24,30 @@ limitations under the License.
 #define GMM_COMPONENT_COUNT (MATRIX_COMPONENT_COUNT + 1)
 #define GMM_COUNT (MIXTURE_COUNT * MIXTURE_SIZE)
 
+void learn_cpu(
+    const float* input,
+    const int* labels,
+    float* gmm,
+    float* scratch_memory,
+    unsigned int batch_count,
+    unsigned int element_count);
+void apply_cpu(
+    const float* gmm,
+    const float* input,
+    float* output,
+    unsigned int batch_count,
+    unsigned int element_count);
 
-void learn_cpu(const float* input, const int* labels, float* gmm, float* scratch_memory, unsigned int batch_count, unsigned int element_count);
-void apply_cpu(const float* gmm, const float* input, float* output, unsigned int batch_count, unsigned int element_count);
-
-void learn_cuda(const float* input, const int* labels, float* gmm, float* scratch_memory, unsigned int batch_count, unsigned int element_count);
-void apply_cuda(const float* gmm, const float* input, float* output, unsigned int batch_count, unsigned int element_count);
+void learn_cuda(
+    const float* input,
+    const int* labels,
+    float* gmm,
+    float* scratch_memory,
+    unsigned int batch_count,
+    unsigned int element_count);
+void apply_cuda(
+    const float* gmm,
+    const float* input,
+    float* output,
+    unsigned int batch_count,
+    unsigned int element_count);

monai/_extensions/gmm/gmm_cpu.cpp

@@ -15,12 +15,21 @@ limitations under the License.
 
 #include "gmm.h"
 
-void learn_cpu(const float* input, const int* labels, float* gmm, float* scratch_memory, unsigned int batch_count, unsigned int element_count)
-{
-    throw std::invalid_argument("GMM received a cpu tensor but is not yet implemented for the cpu");
+void learn_cpu(
+    const float* input,
+    const int* labels,
+    float* gmm,
+    float* scratch_memory,
+    unsigned int batch_count,
+    unsigned int element_count) {
+  throw std::invalid_argument("GMM received a cpu tensor but is not yet implemented for the cpu");
 }
 
-void apply_cpu(const float* gmm, const float* input, float* output, unsigned int batch_count, unsigned int element_count)
-{
-    throw std::invalid_argument("GMM received a cpu tensor but is not yet implemented for the cpu");
+void apply_cpu(
+    const float* gmm,
+    const float* input,
+    float* output,
+    unsigned int batch_count,
+    unsigned int element_count) {
+  throw std::invalid_argument("GMM received a cpu tensor but is not yet implemented for the cpu");
 }