[skip ci] enforce code format

taichi-dev · May 3, 2020 · eb7bdc1 · eb7bdc1
1 parent cd8e7c2
commit eb7bdc1
Show file tree

Hide file tree

Showing 12 changed files with 56 additions and 37 deletions.
diff --git a/docs/gui.rst b/docs/gui.rst
@@ -230,7 +230,7 @@ A *event filter* is a list combined of *key*, *type* and *(type, key)* tuple, e.
     :parameter gui: (GUI)
     :parameter key: (EventKey) keys you want to detect
     :return: (bool) ``True`` if one of the keys pressed, vice versa
-    
+
     .. warning::
 
         Must be used together with ``gui.get_event``, or it won't be updated!

diff --git a/docs/snode.rst b/docs/snode.rst
@@ -30,11 +30,11 @@ See :ref:`layout` for more details about data layout.
     :parameter snode: (SNode)
     :parameter index: alone which axis? (0 for ``i`` and 1 for ``j``)
     :return: (scalar) the size of tensor alone that axis
-    
+
     Equivalent to snode.shape[i]
-    
+
     ::
-        
+
         ti.root.dense(ti.ijk, (3, 5, 4)).place(x)
         x.get_shape(0)  # 3
         x.get_shape(1)  # 5
@@ -44,11 +44,11 @@ See :ref:`layout` for more details about data layout.
 
     :parameter snode: (SNode or tensor)
     :return: (scalar) the dimension of node / tensor
-    
+
     Equivalent to `len(snode.shape)`.
-    
+
     ::
-        
+
         ti.root.dense(ti.ijk, (8, 9, 10)).place(x)
         x.dim()  # 3
 

diff --git a/misc/ci_setup.py b/misc/ci_setup.py
@@ -172,9 +172,23 @@ def run(self):
             execute_command('rm get-pip.py')
 
         subprocess.run([
-            get_python_executable(), "-m", "pip", "install", "--user",
-            "colorama", "numpy", "Pillow", "scipy", "pybind11", "GitPython",
-            "yapf", "distro", "pytest", "autograd", "astor", "pytest-xdist",
+            get_python_executable(),
+            "-m",
+            "pip",
+            "install",
+            "--user",
+            "colorama",
+            "numpy",
+            "Pillow",
+            "scipy",
+            "pybind11",
+            "GitPython",
+            "yapf",
+            "distro",
+            "pytest",
+            "autograd",
+            "astor",
+            "pytest-xdist",
             "pytest-rerunfailures",
         ])
         print("importing numpy test:")

diff --git a/python/taichi/lang/ops.py b/python/taichi/lang/ops.py
@@ -53,6 +53,7 @@ def cast(obj, type):
     else:
         return Expr(taichi_lang_core.value_cast(Expr(obj).ptr, type))
 
+
 def bit_cast(obj, type):
     if is_taichi_class(obj):
         raise ValueError('Cannot apply bit_cast on Taichi classes')

diff --git a/python/taichi/main.py b/python/taichi/main.py
@@ -35,8 +35,10 @@ def test_python(args):
         pytest_args += ['-s', '-v']
     if args.rerun:
         pytest_args += ['--reruns', args.rerun]
-    if int(pytest.main([os.path.join(root_dir, 'misc/empty_pytest.py'),
-                        '-n1', '-q'])) == 0:  # test if pytest has xdist or not
+    if int(
+            pytest.main(
+                [os.path.join(root_dir, 'misc/empty_pytest.py'), '-n1',
+                 '-q'])) == 0:  # test if pytest has xdist or not
         try:
             from multiprocessing import cpu_count
             threads = min(8, cpu_count())  # To prevent running out of memory
@@ -73,9 +75,7 @@ def make_argument_parser():
                         '--verbose',
                         action='store_true',
                         help='Run with verbose outputs')
-    parser.add_argument('-r',
-                        '--rerun',
-                        help='Rerun failed tests once again')
+    parser.add_argument('-r', '--rerun', help='Rerun failed tests once again')
     parser.add_argument('-t',
                         '--threads',
                         help='Number of threads for parallel testing')

diff --git a/taichi/backends/metal/codegen_metal.cpp b/taichi/backends/metal/codegen_metal.cpp
@@ -326,18 +326,18 @@ class KernelCodegen : public IRVisitor {
 
   void visit(UnaryOpStmt *stmt) override {
     if (stmt->op_type == UnaryOpType::cast_value) {
-        emit("const {} {} = static_cast<{}>({});",
-             metal_data_type_name(stmt->element_type()), stmt->raw_name(),
-             metal_data_type_name(stmt->cast_type), stmt->operand->raw_name());
+      emit("const {} {} = static_cast<{}>({});",
+           metal_data_type_name(stmt->element_type()), stmt->raw_name(),
+           metal_data_type_name(stmt->cast_type), stmt->operand->raw_name());
     } else if (stmt->op_type == UnaryOpType::cast_bits) {
-        // reinterpret the bit pattern
-        const auto to_type = to_metal_type(stmt->cast_type);
-        const auto to_type_name = metal_data_type_name(to_type);
-        TI_ASSERT(metal_data_type_bytes(
-                      to_metal_type(stmt->operand->element_type())) ==
-                  metal_data_type_bytes(to_type));
-        emit("const {} {} = union_cast<{}>({});", to_type_name,
-             stmt->raw_name(), to_type_name, stmt->operand->raw_name());
+      // reinterpret the bit pattern
+      const auto to_type = to_metal_type(stmt->cast_type);
+      const auto to_type_name = metal_data_type_name(to_type);
+      TI_ASSERT(
+          metal_data_type_bytes(to_metal_type(stmt->operand->element_type())) ==
+          metal_data_type_bytes(to_type));
+      emit("const {} {} = union_cast<{}>({});", to_type_name, stmt->raw_name(),
+           to_type_name, stmt->operand->raw_name());
     } else {
       emit("const {} {} = {}({});", metal_data_type_name(stmt->element_type()),
            stmt->raw_name(), metal_unary_op_type_symbol(stmt->op_type),

diff --git a/taichi/backends/opengl/codegen_opengl.cpp b/taichi/backends/opengl/codegen_opengl.cpp
@@ -350,12 +350,11 @@ class KernelGen : public IRVisitor {
       emit("{} {} = {}(~{});", dt_name, stmt->short_name(), dt_name,
            stmt->operand->short_name());
     } else if (stmt->op_type == UnaryOpType::cast_value) {
-        emit("{} {} = {}({});", dt_name, stmt->short_name(),
-             opengl_data_type_name(stmt->cast_type),
-             stmt->operand->short_name());
+      emit("{} {} = {}({});", dt_name, stmt->short_name(),
+           opengl_data_type_name(stmt->cast_type), stmt->operand->short_name());
     } else if (stmt->op_type == UnaryOpType::cast_bits) {
       if (stmt->cast_type == DataType::f32 &&
-                 stmt->operand->element_type() == DataType::i32) {
+          stmt->operand->element_type() == DataType::i32) {
         emit("{} {} = intBitsToFloat({});", dt_name, stmt->short_name(),
              stmt->operand->short_name());
       } else if (stmt->cast_type == DataType::i32 &&

diff --git a/taichi/ir/expr.cpp b/taichi/ir/expr.cpp
@@ -35,7 +35,8 @@ Expr operator~(const Expr &expr) {
 }
 
 Expr cast(const Expr &input, DataType dt) {
-  auto ret = std::make_shared<UnaryOpExpression>(UnaryOpType::cast_value, input);
+  auto ret =
+      std::make_shared<UnaryOpExpression>(UnaryOpType::cast_value, input);
   ret->cast_type = dt;
   return Expr(ret);
 }

diff --git a/taichi/python/export_lang.cpp b/taichi/python/export_lang.cpp
@@ -326,7 +326,8 @@ void export_lang(py::module &m) {
   m.def("layout", layout);
 
   m.def("value_cast", static_cast<Expr (*)(const Expr &expr, DataType)>(cast));
-  m.def("bits_cast", static_cast<Expr (*)(const Expr &expr, DataType)>(bit_cast));
+  m.def("bits_cast",
+        static_cast<Expr (*)(const Expr &expr, DataType)>(bit_cast));
 
   m.def("expr_atomic_add", [&](const Expr &a, const Expr &b) {
     return Expr::make<AtomicOpExpression>(AtomicOpType::add, ptr_if_global(a),

diff --git a/taichi/transforms/ir_printer.cpp b/taichi/transforms/ir_printer.cpp
@@ -127,8 +127,8 @@ class IRPrinter : public IRVisitor {
 
   void visit(UnaryOpStmt *stmt) override {
     if (stmt->is_cast()) {
-      std::string reint = stmt->op_type == UnaryOpType::cast_value ?
-        "" : "reinterpret_";
+      std::string reint =
+          stmt->op_type == UnaryOpType::cast_value ? "" : "reinterpret_";
       print("{}{} = {}{}<{}> {}", stmt->type_hint(), stmt->name(), reint,
             unary_op_type_name(stmt->op_type),
             data_type_short_name(stmt->cast_type), stmt->operand->name());

diff --git a/taichi/transforms/make_adjoint.cpp b/taichi/transforms/make_adjoint.cpp
@@ -242,7 +242,8 @@ class MakeAdjoint : public IRVisitor {
       accumulate(stmt->operand,
                  mul(adjoint(stmt), div(constant(0.5f), sqrt(stmt->operand))));
     } else if (stmt->op_type == UnaryOpType::cast_value) {
-      if (is_real(stmt->cast_type) && is_real(stmt->operand->ret_type.data_type)) {
+      if (is_real(stmt->cast_type) &&
+          is_real(stmt->operand->ret_type.data_type)) {
         accumulate(stmt->operand, adjoint(stmt));
       }
     } else if (stmt->op_type == UnaryOpType::logic_not) {

diff --git a/taichi/transforms/type_check.cpp b/taichi/transforms/type_check.cpp
@@ -186,7 +186,8 @@ class TypeCheck : public IRVisitor {
   Stmt *insert_type_cast_before(Stmt *anchor,
                                 Stmt *input,
                                 DataType output_type) {
-    auto &&cast_stmt = Stmt::make_typed<UnaryOpStmt>(UnaryOpType::cast_value, input);
+    auto &&cast_stmt =
+        Stmt::make_typed<UnaryOpStmt>(UnaryOpType::cast_value, input);
     cast_stmt->cast_type = output_type;
     cast_stmt->accept(this);
     auto stmt = cast_stmt.get();
@@ -197,7 +198,8 @@ class TypeCheck : public IRVisitor {
   Stmt *insert_type_cast_after(Stmt *anchor,
                                Stmt *input,
                                DataType output_type) {
-    auto &&cast_stmt = Stmt::make_typed<UnaryOpStmt>(UnaryOpType::cast_value, input);
+    auto &&cast_stmt =
+        Stmt::make_typed<UnaryOpStmt>(UnaryOpType::cast_value, input);
     cast_stmt->cast_type = output_type;
     cast_stmt->accept(this);
     auto stmt = cast_stmt.get();