Fix formatting

Olivier · Olivier · commit ec704f1bf770 · 2017-09-25T12:29:25.000-07:00
diff --git a/src/operator/tensor/elemwise_unary_op_basic.cc b/src/operator/tensor/elemwise_unary_op_basic.cc
@@ -18,7 +18,7 @@
  */
 
 /*!
- * \file elemwise_unary_op.cc
+ * \file elemwise_unary_op_basic.cc
  * \brief CPU Implementation of unary function.
  */
 #include <mxnet/base.h>
@@ -419,7 +419,7 @@ The storage type of ``trunc`` output depends upon the input storage type:
 // fix
 MXNET_OPERATOR_REGISTER_UNARY_WITH_SPARSE(fix, cpu, mshadow_op::fix)
 MXNET_ADD_SPARSE_OP_ALIAS(fix)
-  .describe(R"code(Returns element-wise rounded value to the nearest \
+.describe(R"code(Returns element-wise rounded value to the nearest \
 integer towards zero of the input.
 
 Example::
@@ -436,7 +436,7 @@ The storage type of ``fix`` output depends upon the input storage type:
 // square
 MXNET_OPERATOR_REGISTER_UNARY_WITH_SPARSE(square, cpu, mshadow_op::square)
 MXNET_ADD_SPARSE_OP_ALIAS(square)
-  .describe(R"code(Returns element-wise squared value of the input.
+.describe(R"code(Returns element-wise squared value of the input.
 
 .. math::
    square(x) = x^2
@@ -452,15 +452,15 @@ The storage type of ``square`` output depends upon the input storage type:
    - square(csr) = csr
 
 )code" ADD_FILELINE)
-  .set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_square"});
+.set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_square"});
 
 MXNET_OPERATOR_REGISTER_BINARY_WITH_SPARSE_CPU(_backward_square,
                                                unary_bwd<mshadow_op::square_grad>);
 
 // sqrt
 MXNET_OPERATOR_REGISTER_UNARY_WITH_SPARSE(sqrt, cpu, mshadow_op::square_root)
 MXNET_ADD_SPARSE_OP_ALIAS(sqrt)
-  .describe(R"code(Returns element-wise square-root value of the input.
+.describe(R"code(Returns element-wise square-root value of the input.
 
 .. math::
    \textrm{sqrt}(x) = \sqrt{x}
@@ -475,15 +475,15 @@ The storage type of ``sqrt`` output depends upon the input storage type:
    - sqrt(row_sparse) = row_sparse
 
 )code" ADD_FILELINE)
-  .set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseOut{"_backward_sqrt"});
+.set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseOut{"_backward_sqrt"});
 
 MXNET_OPERATOR_REGISTER_BINARY_WITH_SPARSE_CPU_DR(_backward_sqrt,
                                                   unary_bwd<mshadow_op::square_root_grad>);
 
 // rsqrt
 MXNET_OPERATOR_REGISTER_UNARY_WITH_SPARSE_DR(rsqrt, cpu, mshadow_op::reciprocal_square_root)
 MXNET_ADD_SPARSE_OP_ALIAS(rsqrt)
-  .describe(R"code(Returns element-wise inverse square-root value of the input.
+.describe(R"code(Returns element-wise inverse square-root value of the input.
 
 .. math::
    rsqrt(x) = 1/\sqrt{x}
@@ -495,14 +495,14 @@ Example::
 The storage type of ``rsqrt`` output is always dense
 
 )code" ADD_FILELINE)
-  .set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_rsqrt"});
+.set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_rsqrt"});
 
-MXNET_OPERATOR_REGISTER_BINARY_WITH_SPARSE_CPU_DR(_backward_rsqrt,
-                                                  unary_bwd<mshadow_op::reciprocal_square_root_grad>);
+MXNET_OPERATOR_REGISTER_BINARY_WITH_SPARSE_CPU_DR(
+  _backward_rsqrt, unary_bwd<mshadow_op::reciprocal_square_root_grad>);
 
 // cbrt
 MXNET_OPERATOR_REGISTER_UNARY_WITH_SPARSE(cbrt, cpu, mshadow_op::cube_root)
-  .describe(R"code(Returns element-wise cube-root value of the input.
+.describe(R"code(Returns element-wise cube-root value of the input.
 
 .. math::
    cbrt(x) = \sqrt[3]{x}
@@ -512,14 +512,14 @@ Example::
    cbrt([1, 8, -125]) = [1, 2, -5]
 
 )code" ADD_FILELINE)
-  .set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseOut{"_backward_cbrt"});
+.set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseOut{"_backward_cbrt"});
 
 MXNET_OPERATOR_REGISTER_BINARY_WITH_SPARSE_CPU_DR(_backward_cbrt,
                                                   unary_bwd<mshadow_op::cube_root_grad>);
 
 // rcbrt
 MXNET_OPERATOR_REGISTER_UNARY(rcbrt)
-  .describe(R"code(Returns element-wise inverse cube-root value of the input.
+.describe(R"code(Returns element-wise inverse cube-root value of the input.
 
 .. math::
    rcbrt(x) = 1/\sqrt[3]{x}
@@ -529,17 +529,18 @@ Example::
    rcbrt([1,8,-125]) = [1.0, 0.5, -0.2]
 
 )code" ADD_FILELINE)
-  .set_attr<FCompute>("FCompute<cpu>", UnaryOp::Compute<cpu, mshadow_op::reciprocal_cube_root>)
-  .set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_rcbrt"});
+.set_attr<FCompute>("FCompute<cpu>", UnaryOp::Compute<cpu, mshadow_op::reciprocal_cube_root>)
+.set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_rcbrt"});
 
 MXNET_OPERATOR_REGISTER_BINARY(_backward_rcbrt)
 .set_attr<FCompute>("FCompute<cpu>",
-                    ElemwiseBinaryOp::Compute<cpu, unary_bwd<mshadow_op::reciprocal_cube_root_grad> >);
+                    ElemwiseBinaryOp::Compute<cpu,
+                      unary_bwd<mshadow_op::reciprocal_cube_root_grad>>);
 
 // exp
 MXNET_OPERATOR_REGISTER_UNARY_WITH_SPARSE_DR(exp, cpu, mshadow_op::exp)
 MXNET_ADD_SPARSE_OP_ALIAS(exp)
-  .describe(R"code(Returns element-wise exponential value of the input.
+.describe(R"code(Returns element-wise exponential value of the input.
 
 .. math::
    exp(x) = e^x \approx 2.718^x
@@ -551,50 +552,50 @@ Example::
 The storage type of ``exp`` output is always dense
 
 )code" ADD_FILELINE)
-  .set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseOut{"_mul"});
+.set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseOut{"_mul"});
 
 // log
 MXNET_OPERATOR_REGISTER_UNARY_WITH_SPARSE_DR(log, cpu, mshadow_op::log)
 MXNET_ADD_SPARSE_OP_ALIAS(log)
-  .describe(R"code(Returns element-wise Natural logarithmic value of the input.
+.describe(R"code(Returns element-wise Natural logarithmic value of the input.
 
 The natural logarithm is logarithm in base *e*, so that ``log(exp(x)) = x``
 
 The storage type of ``log`` output is always dense
 
 )code" ADD_FILELINE)
-  .set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_log"});
+.set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_log"});
 
 // log10
 MXNET_OPERATOR_REGISTER_UNARY_WITH_SPARSE_DR(log10, cpu, mshadow_op::log10)
 MXNET_ADD_SPARSE_OP_ALIAS(log10)
-  .describe(R"code(Returns element-wise Base-10 logarithmic value of the input.
+.describe(R"code(Returns element-wise Base-10 logarithmic value of the input.
 
 ``10**log10(x) = x``
 
 The storage type of ``log10`` output is always dense
 
 )code" ADD_FILELINE)
-  .set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_log"});
+.set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_log"});
 
 // log2
 MXNET_OPERATOR_REGISTER_UNARY_WITH_SPARSE_DR(log2, cpu, mshadow_op::log2)
 MXNET_ADD_SPARSE_OP_ALIAS(log2)
-  .describe(R"code(Returns element-wise Base-2 logarithmic value of the input.
+.describe(R"code(Returns element-wise Base-2 logarithmic value of the input.
 
 ``2**log2(x) = x``
 
 The storage type of ``log2`` output is always dense
 
 )code" ADD_FILELINE)
-  .set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_log"});
+.set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_log"});
 
 MXNET_OPERATOR_REGISTER_BINARY_WITH_SPARSE_CPU_DR(_backward_log, unary_bwd<mshadow_op::log_grad>);
 
 // log1p
 MXNET_OPERATOR_REGISTER_UNARY_WITH_SPARSE(log1p, cpu, mshadow_op::log1p)
 MXNET_ADD_SPARSE_OP_ALIAS(log1p)
-  .describe(R"code(Returns element-wise ``log(1 + x)`` value of the input.
+.describe(R"code(Returns element-wise ``log(1 + x)`` value of the input.
 
 This function is more accurate than ``log(1 + x)``  for small ``x`` so that
 :math:`1+x\approx 1`
@@ -605,15 +606,15 @@ The storage type of ``log1p`` output depends upon the input storage type:
    - log1p(row_sparse) = row_sparse
 
 )code" ADD_FILELINE)
-  .set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_log1p"});
+.set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_log1p"});
 
 MXNET_OPERATOR_REGISTER_BINARY_WITH_SPARSE_CPU_DR(_backward_log1p,
                                                   unary_bwd<mshadow_op::log1p_grad>);
 
 // expm1
 MXNET_OPERATOR_REGISTER_UNARY_WITH_SPARSE(expm1, cpu, mshadow_op::expm1)
 MXNET_ADD_SPARSE_OP_ALIAS(expm1)
-  .describe(R"code(Returns ``exp(x) - 1`` computed element-wise on the input.
+.describe(R"code(Returns ``exp(x) - 1`` computed element-wise on the input.
 
 This function provides greater precision than ``exp(x) - 1`` for small values of ``x``.
 
@@ -623,34 +624,34 @@ The storage type of ``expm1`` output depends upon the input storage type:
    - expm1(row_sparse) = row_sparse
 
 )code" ADD_FILELINE)
-  .set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_expm1"});
+.set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_expm1"});
 
 MXNET_OPERATOR_REGISTER_BINARY_WITH_SPARSE_CPU_DR(_backward_expm1, unary_bwd<mshadow_op::exp>);
 
 // gamma
 MXNET_OPERATOR_REGISTER_UNARY_WITH_SPARSE_DR(gamma, cpu, mshadow_op::gamma)
 MXNET_ADD_SPARSE_OP_ALIAS(gamma)
-  .describe(R"code(Returns the gamma function (extension of the factorial function \
+.describe(R"code(Returns the gamma function (extension of the factorial function \
 to the reals), computed element-wise on the input array.
 
 The storage type of ``gamma`` output is always dense
 
 )code")
-  .set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_gamma"});
+.set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_gamma"});
 
 MXNET_OPERATOR_REGISTER_BINARY_WITH_SPARSE_CPU_DR(_backward_gamma,
                                                   unary_bwd<mshadow_op::gamma_grad>);
 
 // gammaln
 MXNET_OPERATOR_REGISTER_UNARY_WITH_SPARSE_DR(gammaln, cpu, mshadow_op::gammaln)
 MXNET_ADD_SPARSE_OP_ALIAS(gammaln)
-  .describe(R"code(Returns element-wise log of the absolute value of the gamma function \
+.describe(R"code(Returns element-wise log of the absolute value of the gamma function \
 of the input.
 
 The storage type of ``gammaln`` output is always dense
 
 )code")
-  .set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_gammaln"});
+.set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_gammaln"});
 
 MXNET_OPERATOR_REGISTER_BINARY_WITH_SPARSE_CPU_DR(_backward_gammaln,
                                                   unary_bwd<mshadow_op::gammaln_grad>);
diff --git a/src/operator/tensor/elemwise_unary_op_basic.cu b/src/operator/tensor/elemwise_unary_op_basic.cu
@@ -18,8 +18,8 @@
  */
 
 /*!
- * \file elemwise_unary_op.cu
- * \brief GPU Implementation of unary function.
+ * \file elemwise_unary_op_trig.cu
+ * \brief GPU Implementation of unary trigometric functions.
  */
 #include "./elemwise_binary_op.h"
 
diff --git a/src/operator/tensor/elemwise_unary_op_trig.cc b/src/operator/tensor/elemwise_unary_op_trig.cc
@@ -18,8 +18,8 @@
  */
 
 /*!
- * \file elemwise_unary_op.cc
- * \brief CPU Implementation of unary function.
+ * \file elemwise_unary_op_trig.cc
+ * \brief CPU Implementation of unary trigometric functions.
  */
 #include <mxnet/base.h>
 #include "elemwise_unary_op.h"
@@ -31,7 +31,7 @@ namespace op {
 // sin
 MXNET_OPERATOR_REGISTER_UNARY_WITH_SPARSE(sin, cpu, mshadow_op::sin)
 MXNET_ADD_SPARSE_OP_ALIAS(sin)
-  .describe(R"code(Computes the element-wise sine of the input array.
+.describe(R"code(Computes the element-wise sine of the input array.
 
 The input should be in radians (:math:`2\pi` rad equals 360 degrees).
 
@@ -44,7 +44,7 @@ The storage type of ``sin`` output depends upon the input storage type:
    - sin(row_sparse) = row_sparse
 
 )code" ADD_FILELINE)
-  .set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{ "_backward_sin" });
+.set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{ "_backward_sin" });
 
 MXNET_OPERATOR_REGISTER_BINARY_WITH_SPARSE_CPU_DR(_backward_sin, unary_bwd<mshadow_op::sin_grad>);
 
