Add comments, cpplint

Author: andrjohns

.github/workflows/main.yml

@@ -222,64 +222,3 @@ jobs:
       with:
         name: gtest_outputs_xml
         path: '**/*_test.xml'
-
-  clang-qual-non-mix:
-    name: Clang Qualification Version - non mix tests
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v3
-    - uses: actions/setup-python@v4
-      with:
-        python-version: '3.x'
-
-    - name: Install Clang qualification version
-      run: |
-        wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/apt.llvm.org.asc
-        sudo apt-get update
-        sudo apt-get install clang lld
-        echo "CXX=clang++" > make/local
-
-    - name: Run non mix tests
-      run: |
-        python runTests.py -j2 test/unit/*_test.cpp
-        python runTests.py -j2 test/unit/math/*_test.cpp
-        python runTests.py -j2 test/unit/math/prim
-        python runTests.py -j2 test/unit/math/rev
-        python runTests.py -j2 test/unit/math/fwd
-        python runTests.py -j2 test/unit/math/memory
-
-    - name: Upload gtest_output xml
-      uses: actions/upload-artifact@v3
-      if: failure()
-      with:
-        name: gtest_outputs_xml
-        path: '**/*_test.xml'
-
-  clang-qual-mix:
-    name: Clang Qualification Version - Mix tests
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v3
-    - uses: actions/setup-python@v4
-      with:
-        python-version: '3.x'
-
-    - name: Install Clang qualification version
-      run: |
-        wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/apt.llvm.org.asc
-        sudo apt-get update
-        sudo apt-get install clang lld
-        echo "CXX=clang++" > make/local
-
-    - name: Run non mix tests
-      run: |
-        python runTests.py -j2 test/unit/math/mix
-
-    - name: Upload gtest_output xml
-      uses: actions/upload-artifact@v3
-      if: failure()
-      with:
-        name: gtest_outputs_xml
-        path: '**/*_test.xml'

stan/math/fwd/core/operator_multiplication.hpp

@@ -46,20 +46,47 @@ inline fvar<T> operator*(const fvar<T>& x, double y) {
   return fvar<T>(x.val_ * y, x.d_ * y);
 }
 
+
+/**
+ * Return the product of the two complex fvar<T> arguments.
+ *
+ * @tparam value and tangent type for variables
+ * @param[in] x first argument
+ * @param[in] y second argument
+ * @return product of arguments
+ */
 template <typename T>
 inline std::complex<stan::math::fvar<T>>
 operator*(const std::complex<stan::math::fvar<T>>& x,
           const std::complex<stan::math::fvar<T>>& y) {
   return internal::complex_multiply(x, y);
 }
 
+/**
+ * Return the product of std::complex<double> and
+ * std::complex<fvar<T>> arguments.
+ *
+ * @tparam value and tangent type for variables
+ * @param[in] x first argument
+ * @param[in] y second argument
+ * @return product of arguments
+ */
 template <typename T>
 inline std::complex<stan::math::fvar<T>>
 operator*(const std::complex<double>& x,
           const std::complex<stan::math::fvar<T>>& y) {
   return internal::complex_multiply(x, y);
 }
 
+/**
+ * Return the product of std::complex<double> and
+ * std::complex<fvar<T>> arguments.
+ *
+ * @tparam value and tangent type for variables
+ * @param[in] x first argument
+ * @param[in] y second argument
+ * @return product of arguments
+ */
 template <typename T>
 inline std::complex<stan::math::fvar<T>>
 operator*(const std::complex<stan::math::fvar<T>>& x,

stan/math/rev/core/operator_multiplication.hpp

@@ -113,18 +113,44 @@ inline var operator*(Arith a, const var& b) {
   return {new internal::multiply_vd_vari(b.vi_, a)};  // by symmetry
 }
 
-inline std::complex<stan::math::var> operator*(const std::complex<stan::math::var>& x,
-                                              const std::complex<stan::math::var>& y) {
+/**
+ * Return the product of std::complex<var> arguments.
+ *
+ * @param[in] x first argument
+ * @param[in] y second argument
+ * @return product of arguments
+ */
+inline std::complex<stan::math::var>
+operator*(const std::complex<stan::math::var>& x,
+          const std::complex<stan::math::var>& y) {
   return internal::complex_multiply(x, y);
 }
 
-inline std::complex<stan::math::var> operator*(const std::complex<double>& x,
-                                              const std::complex<stan::math::var>& y) {
+/**
+ * Return the product of std::complex<double> and
+ * std::complex<var> arguments.
+ *
+ * @param[in] x first argument
+ * @param[in] y second argument
+ * @return product of arguments
+ */
+inline std::complex<stan::math::var>
+operator*(const std::complex<double>& x,
+          const std::complex<stan::math::var>& y) {
   return internal::complex_multiply(x, y);
 }
 
-inline std::complex<stan::math::var> operator*(const std::complex<stan::math::var>& x,
-                                        const std::complex<double>& y) {
+/**
+ * Return the product of std::complex<double> and
+ * std::complex<var> arguments.
+ *
+ * @param[in] x first argument
+ * @param[in] y second argument
+ * @return product of arguments
+ */
+inline std::complex<stan::math::var>
+operator*(const std::complex<stan::math::var>& x,
+          const std::complex<double>& y) {
   return internal::complex_multiply(x, y);
 }