compiles and runs (incorrect, but without run time errors)

src/mesomie.hpp

@@ -63,12 +63,12 @@ void MesoMie<FloatType>::calc_ab(int nmax,
                                  FloatType R,
                                  FloatType xd,
                                  FloatType xm,
-                                 FloatType eps_d,
-                                 FloatType eps_m,
-                                 FloatType d_parallel,
-                                 FloatType d_perp) {
-  an_.resize(nmax, static_cast<FloatType>(0.0));
-  bn_.resize(nmax, static_cast<FloatType>(0.0));
+                                 std::complex<FloatType> eps_d,
+                                 std::complex<FloatType> eps_m,
+                                 std::complex<FloatType> d_parallel,
+                                 std::complex<FloatType> d_perp) {
+  an_.resize(nmax + 1, static_cast<FloatType>(0.0));
+  bn_.resize(nmax + 1, static_cast<FloatType>(0.0));
   std::vector<std::complex<FloatType>>      //
       D1_xd(nmax + 1), D3_xd(nmax + 1),     //
       D1_xm(nmax + 1), D3_xm(nmax + 1),     //
@@ -80,24 +80,24 @@ void MesoMie<FloatType>::calc_ab(int nmax,
 
   for (int n = 1; n <= nmax; n++) {
     an_[n] = Psi_xd[n] *
-             (                                                       //
-                 eps_m * xd * D1_xd[n] - eps_d * xm * D1_xm[n] +     //
-                 (eps_m - eps_d) *                                   //
-                     (                                               //
-                         n * (n + 1) * d_perp +                      //
-                         xd * D1_xd[n] * xm * D1_xm[n] * d_parallel  //
-                         ) /                                         //
-                     R                                               //
-                 ) /                                                 //
+             (                                                           //
+                 eps_m * xd * D1_xd[n] - eps_d * xm * D1_xm[n] +         //
+                 (eps_m - eps_d) *                                       //
+                     (                                                   //
+                         static_cast<FloatType>(n * (n + 1)) * d_perp +  //
+                         xd * D1_xd[n] * xm * D1_xm[n] * d_parallel      //
+                         ) /                                             //
+                     R                                                   //
+                 ) /                                                     //
              Zeta_xd[n] *
-             (                                                       //
-                 eps_m * xd * D3_xd[n] - eps_d * xm * D1_xm[n] +     //
-                 (eps_m - eps_d) *                                   //
-                     (                                               //
-                         n * (n + 1) * d_perp +                      //
-                         xd * D3_xd[n] * xm * D1_xm[n] * d_parallel  //
-                         ) /                                         //
-                     R                                               //
+             (                                                           //
+                 eps_m * xd * D3_xd[n] - eps_d * xm * D1_xm[n] +         //
+                 (eps_m - eps_d) *                                       //
+                     (                                                   //
+                         static_cast<FloatType>(n * (n + 1)) * d_perp +  //
+                         xd * D3_xd[n] * xm * D1_xm[n] * d_parallel      //
+                         ) /                                             //
+                     R                                                   //
              );
     bn_[n] = Psi_xd[n] *
              (                                         //

src/nmie.hpp

@@ -541,10 +541,10 @@ class MesoMie {
                FloatType R,
                FloatType xd,
                FloatType xm,
-               FloatType eps_d,
-               FloatType eps_m,
-               FloatType d_parallel,
-               FloatType d_perp);
+               std::complex<FloatType> eps_d,
+               std::complex<FloatType> eps_m,
+               std::complex<FloatType> d_parallel,
+               std::complex<FloatType> d_perp);
 };  // end of class MesoMie
 
 }  // end of namespace nmie

tests/CMakeLists.txt

@@ -27,7 +27,9 @@ target_link_libraries("test_Riccati_Bessel_logarithmic_derivative" ${LIBS})
 add_test(NAME "test_Riccati_Bessel_logarithmic_derivative"
         COMMAND "test_Riccati_Bessel_logarithmic_derivative")
 
-
+#TODO remove -Wno
+set_source_files_properties(test_bulk_sphere.cc
+        PROPERTIES COMPILE_FLAGS "-Wno-overflow -Wno-unused-parameter")
 add_executable("test_bulk_sphere" test_bulk_sphere.cc)
 target_link_libraries("test_bulk_sphere" ${LIBS})
 add_test(NAME "test_bulk_sphere"

tests/test_bulk_sphere.cc

@@ -95,11 +95,11 @@ TEST(BulkSphere, MesoMie) {
     nmie.calcScattCoeffs();
     auto an_nmie = nmie.GetAn();
     int nmax = an_nmie.size();
-    mesomie.calc_ab(nmax + 2, 1, 1, x, 1, std::sqrt(m).real(), 0, 0);
-    // auto an_meso = mesomie.GetAn();
+    mesomie.calc_ab(nmax + 2, 1, 2, x, {1, 0}, std::sqrt(m), {0, 0}, {0, 0});
+    auto an_meso = mesomie.GetAn();
     for (int n = 0; n < nmax; n++) {
-      if (an_nmie[n].real() > 0.1)
-        std::cout << an_nmie[n] << std::endl;
+      if (an_meso[n + 1].real() > 0.1)
+        std::cout << an_nmie[n] << ' ' << an_meso[n + 1] << std::endl;
     }
 
     // double Qext = static_cast<double>(nmie.GetQext());