Merge branch 'next' of https://github.com/gnss-sdr/gnss-sdr into next

CONTRIBUTING.md

@@ -128,6 +128,9 @@ $ git pull --rebase upstream next
 
 ### How to submit a pull request
 
+Before submitting you code, please be sure to apply clang-format
+(see http://gnss-sdr.org/coding-style/#use-tools-for-automated-code-formatting).
+
 When the contribution is ready, you can [submit a pull
 request](https://github.com/gnss-sdr/gnss-sdr/compare/). Head to your
 GitHub repository, switch to your `my_feature` branch, and click the

docs/PULL_REQUEST_TEMPLATE.md

@@ -5,7 +5,8 @@ Before submitting your pull request, please make sure the following is done:
  2. If you are a first-time contributor, after your pull request you will be asked to sign an Individual Contributor License Agreement ([CLA](https://en.wikipedia.org/wiki/Contributor_License_Agreement)) before your code gets accepted into `master`. This license is for your protection as a Contributor as well as for the protection of [CTTC](http://www.cttc.es/); it does not change your rights to use your own contributions for any other purpose. Except for the license granted therein to CTTC and recipients of software distributed by CTTC, you reserve all right, title, and interest in and to your contributions. The information you provide in that CLA will be maintained in accordance with [CTTC's privacy policy](http://www.cttc.es/privacy/).
  3. You have read the [Contributing Guidelines](https://github.com/gnss-sdr/gnss-sdr/blob/master/CONTRIBUTING.md).
  4. You have read the [coding style guide](http://gnss-sdr.org/coding-style/).
- 5. You have forked the [gnss-sdr upstream repository](https://github.com/gnss-sdr/gnss-sdr) and have created your branch from `next` (or any other currently living branch in the upstream repository).
- 6. Please include a description of your changes here.
+ 5. Specifically, you have read [about clang-format](http://gnss-sdr.org/coding-style/#use-tools-for-automated-code-formatting) and you have applied it.
+ 6. You have forked the [gnss-sdr upstream repository](https://github.com/gnss-sdr/gnss-sdr) and have created your branch from `next` (or any other currently living branch in the upstream repository).
+ 7. Please include a description of your changes here.
 
 **Please feel free to delete this line and the above text once you have read it and in case you want to go on with your pull request.**

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/apps/volk_gnsssdr-config-info.cc

@@ -20,30 +20,30 @@
 #include <config.h>
 #endif
 
-#include "volk_gnsssdr/volk_gnsssdr.h"   // for volk_gnsssdr_get_alignment, volk_gnsssdr_get_machine
-#include "volk_gnsssdr_option_helpers.h" // for option_list, option_t
-#include <volk_gnsssdr/constants.h>      // for volk_gnsssdr_available_machines, volk_gnsssdr_c_compiler ...
-#include <iostream>                      // for operator<<, endl, cout, ostream
-#include <string>                        // for string
+#include "volk_gnsssdr/volk_gnsssdr.h"    // for volk_gnsssdr_get_alignment, volk_gnsssdr_get_machine
+#include "volk_gnsssdr_option_helpers.h"  // for option_list, option_t
+#include <volk_gnsssdr/constants.h>       // for volk_gnsssdr_available_machines, volk_gnsssdr_c_compiler ...
+#include <iostream>                       // for operator<<, endl, cout, ostream
+#include <string>                         // for string
 
 void print_alignment()
 {
-  std::cout << "Alignment in bytes: " << volk_gnsssdr_get_alignment() << std::endl;
+    std::cout << "Alignment in bytes: " << volk_gnsssdr_get_alignment() << std::endl;
 }
 
 
 void print_malloc()
 {
-  // You don't want to change the volk_malloc code, so just copy the if/else
-  // structure from there and give an explanation for the implementations
-  std::cout << "Used malloc implementation: ";
-  #if _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600 || HAVE_POSIX_MEMALIGN
-  std::cout << "posix_memalign" << std::endl;
-  #elif _MSC_VER >= 1400
-  std::cout << "aligned_malloc" << std::endl;
-  #else
-      std::cout << "No standard handler available, using own implementation." << std::endl;
-  #endif
+    // You don't want to change the volk_malloc code, so just copy the if/else
+    // structure from there and give an explanation for the implementations
+    std::cout << "Used malloc implementation: ";
+#if _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600 || HAVE_POSIX_MEMALIGN
+    std::cout << "posix_memalign" << std::endl;
+#elif _MSC_VER >= 1400
+    std::cout << "aligned_malloc" << std::endl;
+#else
+    std::cout << "No standard handler available, using own implementation." << std::endl;
+#endif
 }
 
 
@@ -54,22 +54,24 @@ int main(int argc, char **argv)
     our_options.add(option_t("cc", "", "print the VOLK_GNSSDR C compiler version", volk_gnsssdr_c_compiler()));
     our_options.add(option_t("cflags", "", "print the VOLK_GNSSSDR CFLAGS", volk_gnsssdr_compiler_flags()));
     our_options.add(option_t("all-machines", "", "print VOLK_GNSSSDR machines built", volk_gnsssdr_available_machines()));
-    our_options.add(option_t("avail-machines", "", "print VOLK_GNSSSDR machines on the current "
-            "platform", volk_gnsssdr_list_machines));
+    our_options.add(option_t("avail-machines", "",
+        "print VOLK_GNSSSDR machines on the current "
+        "platform",
+        volk_gnsssdr_list_machines));
     our_options.add(option_t("machine", "", "print the current VOLK_GNSSSDR machine that will be used",
-            volk_gnsssdr_get_machine()));
+        volk_gnsssdr_get_machine()));
     our_options.add(option_t("alignment", "", "print the memory alignment", print_alignment));
     our_options.add(option_t("malloc", "", "print the malloc implementation used in volk_gnsssdr_malloc",
-            print_malloc));
+        print_malloc));
     our_options.add(option_t("version", "v", "print the VOLK_GNSSSDR version", volk_gnsssdr_version()));
 
     try
-    {
+        {
             our_options.parse(argc, argv);
-    }
-    catch(...)
-    {
+        }
+    catch (...)
+        {
             return 1;
-    }
+        }
     return 0;
 }

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/apps/volk_gnsssdr_option_helpers.cc

@@ -17,157 +17,182 @@
  */
 
 #include "volk_gnsssdr_option_helpers.h"
-#include <climits>      // IWYU pragma: keep
-#include <cstdlib>      // IWYU pragma: keep
-#include <cstring>      // IWYU pragma: keep
-#include <exception>    // for exception
-#include <iostream>     // for operator<<, endl, basic_ostream, cout, ostream
-#include <utility>      // for pair
-
+#include <climits>    // IWYU pragma: keep
+#include <cstdlib>    // IWYU pragma: keep
+#include <cstring>    // IWYU pragma: keep
+#include <exception>  // for exception
+#include <iostream>   // for operator<<, endl, basic_ostream, cout, ostream
+#include <utility>    // for pair
 
 
 /*
  * Option type
  */
 option_t::option_t(std::string longform, std::string shortform, std::string msg, void (*callback)())
-        : longform("--" + longform),
-          shortform("-" + shortform),
-          msg(msg),
-          callback(callback) { option_type = VOID_CALLBACK; }
+    : longform("--" + longform),
+      shortform("-" + shortform),
+      msg(msg),
+      callback(callback) { option_type = VOID_CALLBACK; }
 
 option_t::option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(int))
-        : longform("--" + longform),
-          shortform("-" + shortform),
-          msg(msg),
-          callback((void (*)()) callback) { option_type = INT_CALLBACK; }
+    : longform("--" + longform),
+      shortform("-" + shortform),
+      msg(msg),
+      callback((void (*)())callback) { option_type = INT_CALLBACK; }
 
 option_t::option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(float))
-        : longform("--" + longform),
-          shortform("-" + shortform),
-          msg(msg),
-          callback((void (*)()) callback) { option_type = FLOAT_CALLBACK; }
+    : longform("--" + longform),
+      shortform("-" + shortform),
+      msg(msg),
+      callback((void (*)())callback) { option_type = FLOAT_CALLBACK; }
 
 option_t::option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(bool))
-        : longform("--" + longform),
-          shortform("-" + shortform),
-          msg(msg),
-          callback((void (*)()) callback) { option_type = BOOL_CALLBACK; }
+    : longform("--" + longform),
+      shortform("-" + shortform),
+      msg(msg),
+      callback((void (*)())callback) { option_type = BOOL_CALLBACK; }
 
 option_t::option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(std::string))
-        : longform("--" + longform),
-          shortform("-" + shortform),
-          msg(msg),
-          callback((void (*)()) callback) { option_type = STRING_CALLBACK; }
+    : longform("--" + longform),
+      shortform("-" + shortform),
+      msg(msg),
+      callback((void (*)())callback) { option_type = STRING_CALLBACK; }
 
 option_t::option_t(std::string longform, std::string shortform, std::string msg, std::string printval)
-        : longform("--" + longform),
-          shortform("-" + shortform),
-          msg(msg),
-          printval(printval) { option_type = STRING; }
+    : longform("--" + longform),
+      shortform("-" + shortform),
+      msg(msg),
+      printval(printval) { option_type = STRING; }
 
 
 /*
  * Option List
  */
 
-option_list::option_list(std::string program_name) :
-        program_name(program_name) {
-    { internal_list = std::vector<option_t>(); }
-}
-
-void option_list::add(const option_t & opt) { internal_list.push_back(opt); }
-
-void option_list::parse(int argc, char **argv) {
-    for (int arg_number = 0; arg_number < argc; ++arg_number) {
-        for (std::vector<option_t>::iterator this_option = internal_list.begin();
-             this_option != internal_list.end();
-             this_option++) {
-            if (this_option->longform == std::string(argv[arg_number]) ||
-                this_option->shortform == std::string(argv[arg_number])) {
-                switch (this_option->option_type) {
-                    case VOID_CALLBACK:
-                        this_option->callback();
-                        break;
-                    case INT_CALLBACK:
-                        try {
-                            int int_val = std::stoi(argv[++arg_number]);
-                            ((void (*)(int)) this_option->callback)(int_val);
-                        } catch (std::exception &exc) {
-                            std::cout << "An int option can only receive a number" << std::endl;
-                            throw std::exception();
-                        };
-                        break;
-                    case FLOAT_CALLBACK:
-                        try {
-                            int int_val = std::stof(argv[++arg_number]);
-                            ((void (*)(float)) this_option->callback)(int_val);
-                        } catch (std::exception &exc) {
-                            std::cout << "A float option can only receive a number" << std::endl;
-                            throw std::exception();
-                        };
-                        break;
-                    case BOOL_CALLBACK:
-                        try {
-                            bool int_val = (bool) std::stoi(argv[++arg_number]);
-                            ((void (*)(bool)) this_option->callback)(int_val);
-                        } catch (std::exception &exc) {
-                            std::cout << "A bool option can only receive 0 or 1" << std::endl;
-                            throw std::exception();
-                        };
-                        break;
-                    case STRING_CALLBACK:
-                        try {
-                            ((void (*)(std::string)) this_option->callback)(argv[++arg_number]);
-                        } catch (std::exception &exc) {
-                            throw std::exception();
-                        };
-                        break;
-                    case STRING:
-                        std::cout << this_option->printval << std::endl;
-                        break;
-                    default:
-                        this_option->callback();
-                        break;
-                }
-            }
-        }
-        if (std::string("--help") == std::string(argv[arg_number]) ||
-            std::string("-h") == std::string(argv[arg_number])) {
-            help();
-        }
+option_list::option_list(std::string program_name) : program_name(program_name)
+{
+    {
+        internal_list = std::vector<option_t>();
     }
 }
 
-void option_list::help() {
+void option_list::add(const option_t &opt) { internal_list.push_back(opt); }
+
+void option_list::parse(int argc, char **argv)
+{
+    for (int arg_number = 0; arg_number < argc; ++arg_number)
+        {
+            for (std::vector<option_t>::iterator this_option = internal_list.begin();
+                 this_option != internal_list.end();
+                 this_option++)
+                {
+                    if (this_option->longform == std::string(argv[arg_number]) ||
+                        this_option->shortform == std::string(argv[arg_number]))
+                        {
+                            switch (this_option->option_type)
+                                {
+                                case VOID_CALLBACK:
+                                    this_option->callback();
+                                    break;
+                                case INT_CALLBACK:
+                                    try
+                                        {
+                                            int int_val = std::stoi(argv[++arg_number]);
+                                            ((void (*)(int))this_option->callback)(int_val);
+                                        }
+                                    catch (std::exception &exc)
+                                        {
+                                            std::cout << "An int option can only receive a number" << std::endl;
+                                            throw std::exception();
+                                        };
+                                    break;
+                                case FLOAT_CALLBACK:
+                                    try
+                                        {
+                                            int int_val = std::stof(argv[++arg_number]);
+                                            ((void (*)(float))this_option->callback)(int_val);
+                                        }
+                                    catch (std::exception &exc)
+                                        {
+                                            std::cout << "A float option can only receive a number" << std::endl;
+                                            throw std::exception();
+                                        };
+                                    break;
+                                case BOOL_CALLBACK:
+                                    try
+                                        {
+                                            bool int_val = (bool)std::stoi(argv[++arg_number]);
+                                            ((void (*)(bool))this_option->callback)(int_val);
+                                        }
+                                    catch (std::exception &exc)
+                                        {
+                                            std::cout << "A bool option can only receive 0 or 1" << std::endl;
+                                            throw std::exception();
+                                        };
+                                    break;
+                                case STRING_CALLBACK:
+                                    try
+                                        {
+                                            ((void (*)(std::string))this_option->callback)(argv[++arg_number]);
+                                        }
+                                    catch (std::exception &exc)
+                                        {
+                                            throw std::exception();
+                                        };
+                                    break;
+                                case STRING:
+                                    std::cout << this_option->printval << std::endl;
+                                    break;
+                                default:
+                                    this_option->callback();
+                                    break;
+                                }
+                        }
+                }
+            if (std::string("--help") == std::string(argv[arg_number]) ||
+                std::string("-h") == std::string(argv[arg_number]))
+                {
+                    help();
+                }
+        }
+}
+
+void option_list::help()
+{
     std::cout << program_name << std::endl;
     std::cout << "  -h [ --help ] \t\tDisplay this help message" << std::endl;
     for (std::vector<option_t>::iterator this_option = internal_list.begin();
          this_option != internal_list.end();
-         this_option++) {
-        std::string help_line("  ");
-        if (this_option->shortform == "-") {
-            help_line += this_option->longform + " ";
-        } else {
-            help_line += this_option->shortform + " [ " + this_option->longform + " ]";
-        }
+         this_option++)
+        {
+            std::string help_line("  ");
+            if (this_option->shortform == "-")
+                {
+                    help_line += this_option->longform + " ";
+                }
+            else
+                {
+                    help_line += this_option->shortform + " [ " + this_option->longform + " ]";
+                }
 
-        switch (help_line.size() / 8) {
-            case 0:
-                help_line += "\t\t\t\t";
-                break;
-            case 1:
-                help_line += "\t\t\t";
-                break;
-            case 2:
-                help_line += "\t\t";
-                break;
-            case 3:
-                help_line += "\t";
-                break;
-            default:
-                break;
+            switch (help_line.size() / 8)
+                {
+                case 0:
+                    help_line += "\t\t\t\t";
+                    break;
+                case 1:
+                    help_line += "\t\t\t";
+                    break;
+                case 2:
+                    help_line += "\t\t";
+                    break;
+                case 3:
+                    help_line += "\t";
+                    break;
+                default:
+                    break;
+                }
+            help_line += this_option->msg;
+            std::cout << help_line << std::endl;
         }
-        help_line += this_option->msg;
-        std::cout << help_line << std::endl;
-    }
 }

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/apps/volk_gnsssdr_option_helpers.h

@@ -36,7 +36,8 @@ typedef enum
     STRING,
 } VOLK_OPTYPE;
 
-class option_t {
+class option_t
+{
 public:
     option_t(std::string longform, std::string shortform, std::string msg, void (*callback)());
     option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(int));
@@ -51,7 +52,6 @@ public:
     VOLK_OPTYPE option_type;
     std::string printval;
     void (*callback)();
-
 };
 
 class option_list
@@ -59,15 +59,16 @@ class option_list
 public:
     option_list(std::string program_name);
 
-    void add(const option_t & opt);
+    void add(const option_t &opt);
 
     void parse(int argc, char **argv);
 
     void help();
+
 private:
     std::string program_name;
     std::vector<option_t> internal_list;
 };
 
 
-#endif //VOLK_VOLK_OPTION_HELPERS_H
+#endif  //VOLK_VOLK_OPTION_HELPERS_H

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/apps/volk_gnsssdr_profile.cc

@@ -16,23 +16,22 @@
  * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "kernel_tests.h"                      // for init_test_list
-#include "qa_utils.h"                          // for volk_gnsssdr_test_results_t
-#include "volk_gnsssdr/volk_gnsssdr_complex.h" // for lv_32fc_t
-#include "volk_gnsssdr_option_helpers.h"       // for option_list, option_t
+#include "kernel_tests.h"                       // for init_test_list
+#include "qa_utils.h"                           // for volk_gnsssdr_test_results_t
+#include "volk_gnsssdr/volk_gnsssdr_complex.h"  // for lv_32fc_t
+#include "volk_gnsssdr_option_helpers.h"        // for option_list, option_t
 #include "volk_gnsssdr_profile.h"
-#include "volk_gnsssdr/volk_gnsssdr_prefs.h"   // for volk_gnsssdr_get_config_path
-#include <boost/filesystem/operations.hpp>     // for create_directories, exists
-#include <boost/filesystem/path.hpp>           // for path, operator<<
-#include <boost/filesystem/path_traits.hpp>    // for filesystem
-#include <sys/stat.h>                          // for stat
-#include <cstddef>                             // for size_t
-#include <iostream>                            // for operator<<, basic_ostream
-#include <fstream>                             // IWYU pragma: keep
-#include <map>                                 // for map, map<>::iterator
-#include <utility>                             // for pair
-#include <vector>                              // for vector, vector<>::const_..
-
+#include "volk_gnsssdr/volk_gnsssdr_prefs.h"  // for volk_gnsssdr_get_config_path
+#include <boost/filesystem/operations.hpp>    // for create_directories, exists
+#include <boost/filesystem/path.hpp>          // for path, operator<<
+#include <boost/filesystem/path_traits.hpp>   // for filesystem
+#include <sys/stat.h>                         // for stat
+#include <cstddef>                            // for size_t
+#include <iostream>                           // for operator<<, basic_ostream
+#include <fstream>                            // IWYU pragma: keep
+#include <map>                                // for map, map<>::iterator
+#include <utility>                            // for pair
+#include <vector>                             // for vector, vector<>::const_..
 
 
 namespace fs = boost::filesystem;
@@ -67,92 +66,112 @@ int main(int argc, char *argv[])
     profile_options.add((option_t("path", "p", "Specify the volk_config path", set_volk_config)));
 
     try
-    {
+        {
             profile_options.parse(argc, argv);
-    }
-    catch(...)
-    {
-           return 1;
-    }
+        }
+    catch (...)
+        {
+            return 1;
+        }
 
-    for (int arg_number = 0; arg_number < argc; ++arg_number) {
+    for (int arg_number = 0; arg_number < argc; ++arg_number)
+        {
             if (std::string("--help") == std::string(argv[arg_number]) ||
-                    std::string("-h") == std::string(argv[arg_number])) {
+                std::string("-h") == std::string(argv[arg_number]))
+                {
                     return 0;
-            }
-    }
+                }
+        }
     // Adding program options
     std::ofstream json_file;
     std::string config_file;
 
-    if ( json_filename != "" ) {
-        json_file.open( json_filename.c_str() );
-    }
+    if (json_filename != "")
+        {
+            json_file.open(json_filename.c_str());
+        }
 
-    if ( volk_config_path != "" ) {
-        config_file = volk_config_path + "/volk_config";
-    }
+    if (volk_config_path != "")
+        {
+            config_file = volk_config_path + "/volk_config";
+        }
 
     // Run tests
     std::vector<volk_gnsssdr_test_results_t> results;
-    if(update_mode) {
-        if( config_file != "" ) read_results(&results, config_file);
-        else read_results(&results);
-    }
+    if (update_mode)
+        {
+            if (config_file != "")
+                read_results(&results, config_file);
+            else
+                read_results(&results);
+        }
 
     // Initialize the list of tests
     std::vector<volk_gnsssdr_test_case_t> test_cases = init_test_list(test_params);
 
     // Iterate through list of tests running each one
     std::string substr_to_match(test_params.kernel_regex());
-    for(unsigned int ii = 0; ii < test_cases.size(); ++ii) {
-        bool regex_match = true;
+    for (unsigned int ii = 0; ii < test_cases.size(); ++ii)
+        {
+            bool regex_match = true;
 
-        volk_gnsssdr_test_case_t test_case = test_cases[ii];
-        // if the kernel name matches regex then do the test
-        std::string test_case_name = test_case.name();
-        if(test_case_name.find(substr_to_match) == std::string::npos) {
-            regex_match = false;
-        }
-
-        // if we are in update mode check if we've already got results
-        // if we have any, then no need to test that kernel
-        bool update = true;
-        if(update_mode) {
-            for(unsigned int jj=0; jj < results.size(); ++jj) {
-                if(results[jj].name == test_case.name() ||
-                    results[jj].name == test_case.puppet_master_name()) {
-                    update = false;
-                    break;
+            volk_gnsssdr_test_case_t test_case = test_cases[ii];
+            // if the kernel name matches regex then do the test
+            std::string test_case_name = test_case.name();
+            if (test_case_name.find(substr_to_match) == std::string::npos)
+                {
+                    regex_match = false;
                 }
-            }
-        }
 
-        if( regex_match && update ) {
-            try {
-            run_volk_gnsssdr_tests(test_case.desc(), test_case.kernel_ptr(), test_case.name(),
-                test_case.test_parameters(), &results, test_case.puppet_master_name());
-            }
-            catch (std::string &error) {
-                std::cerr << "Caught Exception in 'run_volk_gnssdr_tests': " << error << std::endl;
-            }
+            // if we are in update mode check if we've already got results
+            // if we have any, then no need to test that kernel
+            bool update = true;
+            if (update_mode)
+                {
+                    for (unsigned int jj = 0; jj < results.size(); ++jj)
+                        {
+                            if (results[jj].name == test_case.name() ||
+                                results[jj].name == test_case.puppet_master_name())
+                                {
+                                    update = false;
+                                    break;
+                                }
+                        }
+                }
+
+            if (regex_match && update)
+                {
+                    try
+                        {
+                            run_volk_gnsssdr_tests(test_case.desc(), test_case.kernel_ptr(), test_case.name(),
+                                test_case.test_parameters(), &results, test_case.puppet_master_name());
+                        }
+                    catch (std::string &error)
+                        {
+                            std::cerr << "Caught Exception in 'run_volk_gnssdr_tests': " << error << std::endl;
+                        }
+                }
         }
-    }
 
 
     // Output results according to provided options
-    if(json_filename != "") {
-        write_json(json_file, results);
-        json_file.close();
-    }
+    if (json_filename != "")
+        {
+            write_json(json_file, results);
+            json_file.close();
+        }
 
-    if(!dry_run) {
-        if(config_file != "") write_results(&results, false, config_file);
-        else write_results(&results, false);
-    }
-    else {
-        std::cout << "Warning: this was a dry-run. Config not generated" << std::endl;
-    }
+    if (!dry_run)
+        {
+            if (config_file != "")
+                write_results(&results, false, config_file);
+            else
+                write_results(&results, false);
+        }
+    else
+        {
+            std::cout << "Warning: this was a dry-run. Config not generated" << std::endl;
+        }
 }
 
 
@@ -167,51 +186,55 @@ void read_results(std::vector<volk_gnsssdr_test_results_t> *results)
 void read_results(std::vector<volk_gnsssdr_test_results_t> *results, std::string path)
 {
     struct stat buffer;
-    bool config_status = (stat (path.c_str(), &buffer) == 0);
+    bool config_status = (stat(path.c_str(), &buffer) == 0);
 
-    if( config_status ) {
-        // a config exists and we are reading results from it
-        std::ifstream config(path.c_str());
-        char config_line[256];
-        while(config.getline(config_line, 255)) {
-            // tokenize the input line by kernel_name unaligned aligned
-            // then push back in the results vector with fields filled in
+    if (config_status)
+        {
+            // a config exists and we are reading results from it
+            std::ifstream config(path.c_str());
+            char config_line[256];
+            while (config.getline(config_line, 255))
+                {
+                    // tokenize the input line by kernel_name unaligned aligned
+                    // then push back in the results vector with fields filled in
 
-            std::vector<std::string> single_kernel_result;
-            std::string config_str(config_line);
-            std::size_t str_size = config_str.size();
-            std::size_t found = 1;
+                    std::vector<std::string> single_kernel_result;
+                    std::string config_str(config_line);
+                    std::size_t str_size = config_str.size();
+                    std::size_t found = 1;
 
-            found = config_str.find(' ');
-            // Split line by spaces
-            while(found && found < str_size) {
                     found = config_str.find(' ');
-                    // kernel names MUST be less than 128 chars, which is
-                    // a length restricted by volk/volk_prefs.c
-                    // on the last token in the parsed string we won't find a space
-                    // so make sure we copy at most 128 chars.
-                    if(found > 127) {
-                            found = 127;
-                    }
-                    str_size = config_str.size();
-                    char buffer[128] = {'\0'};
-                    config_str.copy(buffer, found + 1, 0);
-                    buffer[found] = '\0';
-                    single_kernel_result.push_back(std::string(buffer));
-                    config_str.erase(0, found+1);
-            }
+                    // Split line by spaces
+                    while (found && found < str_size)
+                        {
+                            found = config_str.find(' ');
+                            // kernel names MUST be less than 128 chars, which is
+                            // a length restricted by volk/volk_prefs.c
+                            // on the last token in the parsed string we won't find a space
+                            // so make sure we copy at most 128 chars.
+                            if (found > 127)
+                                {
+                                    found = 127;
+                                }
+                            str_size = config_str.size();
+                            char buffer[128] = {'\0'};
+                            config_str.copy(buffer, found + 1, 0);
+                            buffer[found] = '\0';
+                            single_kernel_result.push_back(std::string(buffer));
+                            config_str.erase(0, found + 1);
+                        }
 
-            if(single_kernel_result.size() == 3) {
-                volk_gnsssdr_test_results_t kernel_result;
-                kernel_result.name = std::string(single_kernel_result[0]);
-                kernel_result.config_name = std::string(single_kernel_result[0]);
-                kernel_result.best_arch_u = std::string(single_kernel_result[1]);
-                kernel_result.best_arch_a = std::string(single_kernel_result[2]);
-                results->push_back(kernel_result);
-            }
+                    if (single_kernel_result.size() == 3)
+                        {
+                            volk_gnsssdr_test_results_t kernel_result;
+                            kernel_result.name = std::string(single_kernel_result[0]);
+                            kernel_result.config_name = std::string(single_kernel_result[0]);
+                            kernel_result.best_arch_u = std::string(single_kernel_result[1]);
+                            kernel_result.best_arch_a = std::string(single_kernel_result[2]);
+                            results->push_back(kernel_result);
+                        }
+                }
         }
-    }
-
 }
 
 void write_results(const std::vector<volk_gnsssdr_test_results_t> *results, bool update_result)
@@ -219,7 +242,7 @@ void write_results(const std::vector<volk_gnsssdr_test_results_t> *results, bool
     char path[1024];
     volk_gnsssdr_get_config_path(path);
 
-    write_results( results, update_result, std::string(path));
+    write_results(results, update_result, std::string(path));
 }
 
 void write_results(const std::vector<volk_gnsssdr_test_results_t> *results, bool update_result, const std::string path)
@@ -227,39 +250,44 @@ void write_results(const std::vector<volk_gnsssdr_test_results_t> *results, bool
     const fs::path config_path(path);
     // Until we can update the config on a kernel by kernel basis
     // do not overwrite volk_gnsssdr_config when using a regex.
-    if (! fs::exists(config_path.branch_path()))
-    {
-        std::cout << "Creating " << config_path.branch_path() << " ..." << std::endl;
-        fs::create_directories(config_path.branch_path());
-    }
+    if (!fs::exists(config_path.branch_path()))
+        {
+            std::cout << "Creating " << config_path.branch_path() << " ..." << std::endl;
+            fs::create_directories(config_path.branch_path());
+        }
 
     std::ofstream config;
-    if(update_result) {
-        std::cout << "Updating " << path << " ..." << std::endl;
-        config.open(path.c_str(), std::ofstream::app);
-        if (!config.is_open()) { //either we don't have write access or we don't have the dir yet
-            std::cout << "Error opening file " << path << std::endl;
-        }
-    }
-    else {
-        std::cout << "Writing " << path << " ..." << std::endl;
-        config.open(path.c_str());
-        if (!config.is_open()) { //either we don't have write access or we don't have the dir yet
-            std::cout << "Error opening file " << path << std::endl;
+    if (update_result)
+        {
+            std::cout << "Updating " << path << " ..." << std::endl;
+            config.open(path.c_str(), std::ofstream::app);
+            if (!config.is_open())
+                {  //either we don't have write access or we don't have the dir yet
+                    std::cout << "Error opening file " << path << std::endl;
+                }
         }
+    else
+        {
+            std::cout << "Writing " << path << " ..." << std::endl;
+            config.open(path.c_str());
+            if (!config.is_open())
+                {  //either we don't have write access or we don't have the dir yet
+                    std::cout << "Error opening file " << path << std::endl;
+                }
 
-        config << "\
+            config << "\
 #this file is generated by volk_gnsssdr_profile.\n\
 #the function name is followed by the preferred architecture.\n\
 ";
-    }
+        }
 
     std::vector<volk_gnsssdr_test_results_t>::const_iterator profile_results;
-    for(profile_results = results->begin(); profile_results != results->end(); ++profile_results) {
-        config << profile_results->config_name << " "
-            << profile_results->best_arch_a << " "
-            << profile_results->best_arch_u << std::endl;
-    }
+    for (profile_results = results->begin(); profile_results != results->end(); ++profile_results)
+        {
+            config << profile_results->config_name << " "
+                   << profile_results->best_arch_a << " "
+                   << profile_results->best_arch_u << std::endl;
+        }
     config.close();
 }
 
@@ -270,43 +298,45 @@ void write_json(std::ofstream &json_file, std::vector<volk_gnsssdr_test_results_
     size_t len = results.size();
     size_t i = 0;
     std::vector<volk_gnsssdr_test_results_t>::iterator result;
-    for(result = results.begin(); result != results.end(); ++result) {
-        json_file << "  {" << std::endl;
-        json_file << "   \"name\": \"" << result->name << "\"," << std::endl;
-        json_file << "   \"vlen\": " << (int)(result->vlen) << "," << std::endl;
-        json_file << "   \"iter\": " << result->iter << "," << std::endl;
-        json_file << "   \"best_arch_a\": \"" << result->best_arch_a
-            << "\"," << std::endl;
-        json_file << "   \"best_arch_u\": \"" << result->best_arch_u
-            << "\"," << std::endl;
-        json_file << "   \"results\": {" << std::endl;
-        size_t results_len = result->results.size();
-        size_t ri = 0;
+    for (result = results.begin(); result != results.end(); ++result)
+        {
+            json_file << "  {" << std::endl;
+            json_file << "   \"name\": \"" << result->name << "\"," << std::endl;
+            json_file << "   \"vlen\": " << (int)(result->vlen) << "," << std::endl;
+            json_file << "   \"iter\": " << result->iter << "," << std::endl;
+            json_file << "   \"best_arch_a\": \"" << result->best_arch_a
+                      << "\"," << std::endl;
+            json_file << "   \"best_arch_u\": \"" << result->best_arch_u
+                      << "\"," << std::endl;
+            json_file << "   \"results\": {" << std::endl;
+            size_t results_len = result->results.size();
+            size_t ri = 0;
 
-        std::map<std::string, volk_gnsssdr_test_time_t>::iterator kernel_time_pair;
-        for(kernel_time_pair = result->results.begin(); kernel_time_pair != result->results.end(); ++kernel_time_pair) {
-            volk_gnsssdr_test_time_t time = kernel_time_pair->second;
-            json_file << "    \"" << time.name << "\": {" << std::endl;
-            json_file << "     \"name\": \"" << time.name << "\"," << std::endl;
-            json_file << "     \"time\": " << time.time << "," << std::endl;
-            json_file << "     \"units\": \"" << time.units << "\"" << std::endl;
-            json_file << "    }" ;
-            if(ri+1 != results_len) {
-                json_file << ",";
-            }
+            std::map<std::string, volk_gnsssdr_test_time_t>::iterator kernel_time_pair;
+            for (kernel_time_pair = result->results.begin(); kernel_time_pair != result->results.end(); ++kernel_time_pair)
+                {
+                    volk_gnsssdr_test_time_t time = kernel_time_pair->second;
+                    json_file << "    \"" << time.name << "\": {" << std::endl;
+                    json_file << "     \"name\": \"" << time.name << "\"," << std::endl;
+                    json_file << "     \"time\": " << time.time << "," << std::endl;
+                    json_file << "     \"units\": \"" << time.units << "\"" << std::endl;
+                    json_file << "    }";
+                    if (ri + 1 != results_len)
+                        {
+                            json_file << ",";
+                        }
+                    json_file << std::endl;
+                    ri++;
+                }
+            json_file << "   }" << std::endl;
+            json_file << "  }";
+            if (i + 1 != len)
+                {
+                    json_file << ",";
+                }
             json_file << std::endl;
-            ri++;
+            i++;
         }
-        json_file << "   }" << std::endl;
-        json_file << "  }";
-        if(i+1 != len) {
-            json_file << ",";
-        }
-        json_file << std::endl;
-        i++;
-    }
     json_file << " ]" << std::endl;
     json_file << "}" << std::endl;
 }
-
-

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/apps/volk_gnsssdr_profile.h

@@ -27,10 +27,10 @@
  * -------------------------------------------------------------------------
  */
 
-#include <cstdbool>   // for bool
-#include <iosfwd>     // for ofstream
-#include <string>     // for string
-#include <vector>     // for vector
+#include <cstdbool>  // for bool
+#include <iosfwd>    // for ofstream
+#include <string>    // for string
+#include <vector>    // for vector
 
 class volk_test_results_t;
 

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/include/volk_gnsssdr/saturation_arithmetic.h

@@ -29,7 +29,7 @@
 
 static inline int16_t sat_adds16i(int16_t x, int16_t y)
 {
-    int32_t res = (int32_t) x + (int32_t) y;
+    int32_t res = (int32_t)x + (int32_t)y;
 
     if (res < SHRT_MIN) res = SHRT_MIN;
     if (res > SHRT_MAX) res = SHRT_MAX;
@@ -39,7 +39,7 @@ static inline int16_t sat_adds16i(int16_t x, int16_t y)
 
 static inline int16_t sat_muls16i(int16_t x, int16_t y)
 {
-    int32_t res = (int32_t) x * (int32_t) y;
+    int32_t res = (int32_t)x * (int32_t)y;
 
     if (res < SHRT_MIN) res = SHRT_MIN;
     if (res > SHRT_MAX) res = SHRT_MAX;

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/include/volk_gnsssdr/volk_gnsssdr_avx_intrinsics.h

@@ -30,38 +30,42 @@
 static inline __m256
 _mm256_complexmul_ps(__m256 x, __m256 y)
 {
-  __m256 yl, yh, tmp1, tmp2;
-  yl = _mm256_moveldup_ps(y); // Load yl with cr,cr,dr,dr ...
-  yh = _mm256_movehdup_ps(y); // Load yh with ci,ci,di,di ...
-  tmp1 = _mm256_mul_ps(x, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr ...
-  x = _mm256_shuffle_ps(x, x, 0xB1); // Re-arrange x to be ai,ar,bi,br ...
-  tmp2 = _mm256_mul_ps(x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-  return _mm256_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+    __m256 yl, yh, tmp1, tmp2;
+    yl = _mm256_moveldup_ps(y);           // Load yl with cr,cr,dr,dr ...
+    yh = _mm256_movehdup_ps(y);           // Load yh with ci,ci,di,di ...
+    tmp1 = _mm256_mul_ps(x, yl);          // tmp1 = ar*cr,ai*cr,br*dr,bi*dr ...
+    x = _mm256_shuffle_ps(x, x, 0xB1);    // Re-arrange x to be ai,ar,bi,br ...
+    tmp2 = _mm256_mul_ps(x, yh);          // tmp2 = ai*ci,ar*ci,bi*di,br*di
+    return _mm256_addsub_ps(tmp1, tmp2);  // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
 }
 
 static inline __m256
-_mm256_conjugate_ps(__m256 x){
-  const __m256 conjugator = _mm256_setr_ps(0, -0.f, 0, -0.f, 0, -0.f, 0, -0.f);
-  return _mm256_xor_ps(x, conjugator); // conjugate y
+_mm256_conjugate_ps(__m256 x)
+{
+    const __m256 conjugator = _mm256_setr_ps(0, -0.f, 0, -0.f, 0, -0.f, 0, -0.f);
+    return _mm256_xor_ps(x, conjugator);  // conjugate y
 }
 
 static inline __m256
-_mm256_complexconjugatemul_ps(__m256 x, __m256 y){
-  y = _mm256_conjugate_ps(y);
-  return _mm256_complexmul_ps(x, y);
+_mm256_complexconjugatemul_ps(__m256 x, __m256 y)
+{
+    y = _mm256_conjugate_ps(y);
+    return _mm256_complexmul_ps(x, y);
 }
 
 static inline __m256
-_mm256_magnitudesquared_ps(__m256 cplxValue1, __m256 cplxValue2){
-  __m256 complex1, complex2;
-  cplxValue1 = _mm256_mul_ps(cplxValue1, cplxValue1); // Square the values
-  cplxValue2 = _mm256_mul_ps(cplxValue2, cplxValue2); // Square the Values
-  complex1 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x20);
-  complex2 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x31);
-  return _mm256_hadd_ps(complex1, complex2); // Add the I2 and Q2 values
+_mm256_magnitudesquared_ps(__m256 cplxValue1, __m256 cplxValue2)
+{
+    __m256 complex1, complex2;
+    cplxValue1 = _mm256_mul_ps(cplxValue1, cplxValue1);  // Square the values
+    cplxValue2 = _mm256_mul_ps(cplxValue2, cplxValue2);  // Square the Values
+    complex1 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x20);
+    complex2 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x31);
+    return _mm256_hadd_ps(complex1, complex2);  // Add the I2 and Q2 values
 }
 
-static inline __m256 _mm256_complexnormalise_ps( __m256 z ){
+static inline __m256 _mm256_complexnormalise_ps(__m256 z)
+{
     __m256 tmp1 = _mm256_mul_ps(z, z);
     __m256 tmp2 = _mm256_hadd_ps(tmp1, tmp1);
     tmp1 = _mm256_shuffle_ps(tmp2, tmp2, 0xD8);
@@ -70,8 +74,9 @@ static inline __m256 _mm256_complexnormalise_ps( __m256 z ){
 }
 
 static inline __m256
-_mm256_magnitude_ps(__m256 cplxValue1, __m256 cplxValue2){
-  return _mm256_sqrt_ps(_mm256_magnitudesquared_ps(cplxValue1, cplxValue2));
+_mm256_magnitude_ps(__m256 cplxValue1, __m256 cplxValue2)
+{
+    return _mm256_sqrt_ps(_mm256_magnitudesquared_ps(cplxValue1, cplxValue2));
 }
 
 #endif /* INCLUDE_VOLK_VOLK_AVX_INTRINSICS_H_ */

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/include/volk_gnsssdr/volk_gnsssdr_common.h

@@ -28,14 +28,14 @@
 // Cross-platform attribute macros not included in VOLK
 ////////////////////////////////////////////////////////////////////////
 #if defined __GNUC__
-#  define __VOLK_GNSSSDR_PREFETCH(addr) __builtin_prefetch(addr)
-#  define __VOLK_GNSSSDR_PREFETCH_LOCALITY(addr, rw, locality) __builtin_prefetch(addr, rw, locality)
+#define __VOLK_GNSSSDR_PREFETCH(addr) __builtin_prefetch(addr)
+#define __VOLK_GNSSSDR_PREFETCH_LOCALITY(addr, rw, locality) __builtin_prefetch(addr, rw, locality)
 #elif _MSC_VER
-#  define __VOLK_GNSSSDR_PREFETCH(addr)
-#  define __VOLK_GNSSSDR_PREFETCH_LOCALITY(addr, rw, locality)
+#define __VOLK_GNSSSDR_PREFETCH(addr)
+#define __VOLK_GNSSSDR_PREFETCH_LOCALITY(addr, rw, locality)
 #else
-#  define __VOLK_GNSSSDR_PREFETCH(addr)
-#  define __VOLK_GNSSSDR_PREFETCH_LOCALITY(addr, rw, locality)
+#define __VOLK_GNSSSDR_PREFETCH(addr)
+#define __VOLK_GNSSSDR_PREFETCH_LOCALITY(addr, rw, locality)
 #endif
 
 #ifndef INCLUDED_LIBVOLK_COMMON_H
@@ -45,45 +45,45 @@
 // Cross-platform attribute macros
 ////////////////////////////////////////////////////////////////////////
 #if defined __GNUC__
-#  define __VOLK_ATTR_ALIGNED(x) __attribute__((aligned(x)))
-#  define __VOLK_ATTR_UNUSED     __attribute__((unused))
-#  define __VOLK_ATTR_INLINE     __attribute__((always_inline))
-#  define __VOLK_ATTR_DEPRECATED __attribute__((deprecated))
-#  define __VOLK_ASM             __asm__
-#  define __VOLK_VOLATILE        __volatile__
-#  if __GNUC__ >= 4
-#    define __VOLK_ATTR_EXPORT   __attribute__((visibility("default")))
-#    define __VOLK_ATTR_IMPORT   __attribute__((visibility("default")))
-#  else
-#    define __VOLK_ATTR_EXPORT
-#    define __VOLK_ATTR_IMPORT
-#  endif
-#elif _MSC_VER
-#  define __VOLK_ATTR_ALIGNED(x) __declspec(align(x))
-#  define __VOLK_ATTR_UNUSED
-#  define __VOLK_ATTR_INLINE     __forceinline
-#  define __VOLK_ATTR_DEPRECATED __declspec(deprecated)
-#  define __VOLK_ATTR_EXPORT     __declspec(dllexport)
-#  define __VOLK_ATTR_IMPORT     __declspec(dllimport)
-#  define __VOLK_ASM             __asm
-#  define __VOLK_VOLATILE
+#define __VOLK_ATTR_ALIGNED(x) __attribute__((aligned(x)))
+#define __VOLK_ATTR_UNUSED __attribute__((unused))
+#define __VOLK_ATTR_INLINE __attribute__((always_inline))
+#define __VOLK_ATTR_DEPRECATED __attribute__((deprecated))
+#define __VOLK_ASM __asm__
+#define __VOLK_VOLATILE __volatile__
+#if __GNUC__ >= 4
+#define __VOLK_ATTR_EXPORT __attribute__((visibility("default")))
+#define __VOLK_ATTR_IMPORT __attribute__((visibility("default")))
 #else
-#  define __VOLK_ATTR_ALIGNED(x)
-#  define __VOLK_ATTR_UNUSED
-#  define __VOLK_ATTR_INLINE
-#  define __VOLK_ATTR_DEPRECATED
-#  define __VOLK_ATTR_EXPORT
-#  define __VOLK_ATTR_IMPORT
-#  define __VOLK_ASM             __asm__
-#  define __VOLK_VOLATILE        __volatile__
+#define __VOLK_ATTR_EXPORT
+#define __VOLK_ATTR_IMPORT
+#endif
+#elif _MSC_VER
+#define __VOLK_ATTR_ALIGNED(x) __declspec(align(x))
+#define __VOLK_ATTR_UNUSED
+#define __VOLK_ATTR_INLINE __forceinline
+#define __VOLK_ATTR_DEPRECATED __declspec(deprecated)
+#define __VOLK_ATTR_EXPORT __declspec(dllexport)
+#define __VOLK_ATTR_IMPORT __declspec(dllimport)
+#define __VOLK_ASM __asm
+#define __VOLK_VOLATILE
+#else
+#define __VOLK_ATTR_ALIGNED(x)
+#define __VOLK_ATTR_UNUSED
+#define __VOLK_ATTR_INLINE
+#define __VOLK_ATTR_DEPRECATED
+#define __VOLK_ATTR_EXPORT
+#define __VOLK_ATTR_IMPORT
+#define __VOLK_ASM __asm__
+#define __VOLK_VOLATILE __volatile__
 #endif
 
 ////////////////////////////////////////////////////////////////////////
 // Ignore annoying warnings in MSVC
 ////////////////////////////////////////////////////////////////////////
 #if defined(_MSC_VER)
-#  pragma warning(disable: 4244) //'conversion' conversion from 'type1' to 'type2', possible loss of data
-#  pragma warning(disable: 4305) //'identifier' : truncation from 'type1' to 'type2'
+#pragma warning(disable : 4244)  //'conversion' conversion from 'type1' to 'type2', possible loss of data
+#pragma warning(disable : 4305)  //'identifier' : truncation from 'type1' to 'type2'
 #endif
 
 ////////////////////////////////////////////////////////////////////////
@@ -91,11 +91,13 @@
 // FIXME: due to the usage of complex.h, require gcc for c-linkage
 ////////////////////////////////////////////////////////////////////////
 #if defined(__cplusplus) && (__GNUC__)
-#  define __VOLK_DECL_BEGIN extern "C" {
-#  define __VOLK_DECL_END }
+#define __VOLK_DECL_BEGIN \
+    extern "C"            \
+    {
+#define __VOLK_DECL_END }
 #else
-#  define __VOLK_DECL_BEGIN
-#  define __VOLK_DECL_END
+#define __VOLK_DECL_BEGIN
+#define __VOLK_DECL_END
 #endif
 
 ////////////////////////////////////////////////////////////////////////
@@ -103,9 +105,9 @@
 // http://gcc.gnu.org/wiki/Visibility
 ////////////////////////////////////////////////////////////////////////
 #ifdef volk_gnsssdr_EXPORTS
-#  define VOLK_API __VOLK_ATTR_EXPORT
+#define VOLK_API __VOLK_ATTR_EXPORT
 #else
-#  define VOLK_API __VOLK_ATTR_IMPORT
+#define VOLK_API __VOLK_ATTR_IMPORT
 #endif
 
 ////////////////////////////////////////////////////////////////////////
@@ -121,35 +123,37 @@
 #endif
 #endif
 
-union bit128{
-  uint8_t i8[16];
-  uint16_t i16[8];
-  uint32_t i[4];
-  float f[4];
-  double d[2];
+union bit128
+{
+    uint8_t i8[16];
+    uint16_t i16[8];
+    uint32_t i[4];
+    float f[4];
+    double d[2];
 
-  #ifdef LV_HAVE_SSE
-  __m128 float_vec;
-  #endif
+#ifdef LV_HAVE_SSE
+    __m128 float_vec;
+#endif
 
-  #ifdef LV_HAVE_SSE2
-  __m128i int_vec;
-  __m128d double_vec;
-  #endif
+#ifdef LV_HAVE_SSE2
+    __m128i int_vec;
+    __m128d double_vec;
+#endif
 };
 
-union bit256{
-  uint8_t i8[32];
-  uint16_t i16[16];
-  uint32_t i[8];
-  float f[8];
-  double d[4];
+union bit256
+{
+    uint8_t i8[32];
+    uint16_t i16[16];
+    uint32_t i[8];
+    float f[8];
+    double d[4];
 
-  #ifdef LV_HAVE_AVX
-  __m256 float_vec;
-  __m256i int_vec;
-  __m256d double_vec;
-  #endif
+#ifdef LV_HAVE_AVX
+    __m256 float_vec;
+    __m256i int_vec;
+    __m256d double_vec;
+#endif
 };
 
 #define bit128_p(x) ((union bit128 *)(x))

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/include/volk_gnsssdr/volk_gnsssdr_complex.h

@@ -48,26 +48,34 @@
 #include <complex>
 #include <stdint.h>
 
-typedef std::complex<int8_t>  lv_8sc_t;
+typedef std::complex<int8_t> lv_8sc_t;
 typedef std::complex<int16_t> lv_16sc_t;
 typedef std::complex<int32_t> lv_32sc_t;
 typedef std::complex<int64_t> lv_64sc_t;
-typedef std::complex<float>   lv_32fc_t;
-typedef std::complex<double>  lv_64fc_t;
+typedef std::complex<float> lv_32fc_t;
+typedef std::complex<double> lv_64fc_t;
 
-template <typename T> inline std::complex<T> lv_cmake(const T &r, const T &i){
+template <typename T>
+inline std::complex<T> lv_cmake(const T &r, const T &i)
+{
     return std::complex<T>(r, i);
 }
 
-template <typename T> inline typename T::value_type lv_creal(const T &x){
+template <typename T>
+inline typename T::value_type lv_creal(const T &x)
+{
     return x.real();
 }
 
-template <typename T> inline typename T::value_type lv_cimag(const T &x){
+template <typename T>
+inline typename T::value_type lv_cimag(const T &x)
+{
     return x.imag();
 }
 
-template <typename T> inline T lv_conj(const T &x){
+template <typename T>
+inline T lv_conj(const T &x)
+{
     return std::conj(x);
 }
 
@@ -80,14 +88,14 @@ template <typename T> inline T lv_conj(const T &x){
 
 #include <complex.h>
 
-typedef char complex         lv_8sc_t;
-typedef short complex        lv_16sc_t;
-typedef long complex         lv_32sc_t;
-typedef long long complex    lv_64sc_t;
-typedef float complex        lv_32fc_t;
-typedef double complex       lv_64fc_t;
+typedef char complex lv_8sc_t;
+typedef short complex lv_16sc_t;
+typedef long complex lv_32sc_t;
+typedef long long complex lv_64sc_t;
+typedef float complex lv_32fc_t;
+typedef double complex lv_64fc_t;
 
-#define lv_cmake(r, i) ((r) + _Complex_I*(i))
+#define lv_cmake(r, i) ((r) + _Complex_I * (i))
 
 // When GNUC is available, use the complex extensions.
 // The extensions always return the correct value type.

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/include/volk_gnsssdr/volk_gnsssdr_neon_intrinsics.h

@@ -27,30 +27,30 @@
 
 #include <arm_neon.h>
 
-static inline float32x4_t vdivq_f32( float32x4_t num, float32x4_t den )
+static inline float32x4_t vdivq_f32(float32x4_t num, float32x4_t den)
 {
-    const float32x4_t q_inv0 = vrecpeq_f32( den );
-    const float32x4_t q_step0 = vrecpsq_f32( q_inv0, den );
+    const float32x4_t q_inv0 = vrecpeq_f32(den);
+    const float32x4_t q_step0 = vrecpsq_f32(q_inv0, den);
 
-    const float32x4_t q_inv1 = vmulq_f32( q_step0, q_inv0 );
-    return vmulq_f32( num, q_inv1 );
+    const float32x4_t q_inv1 = vmulq_f32(q_step0, q_inv0);
+    return vmulq_f32(num, q_inv1);
 }
 
 
-static inline float32x4_t vsqrtq_f32( float32x4_t q_x )
+static inline float32x4_t vsqrtq_f32(float32x4_t q_x)
 {
-    const float32x4_t q_step_0 = vrsqrteq_f32( q_x );
+    const float32x4_t q_step_0 = vrsqrteq_f32(q_x);
     // step
-    const float32x4_t q_step_parm0 = vmulq_f32( q_x, q_step_0 );
-    const float32x4_t q_step_result0 = vrsqrtsq_f32( q_step_parm0, q_step_0 );
+    const float32x4_t q_step_parm0 = vmulq_f32(q_x, q_step_0);
+    const float32x4_t q_step_result0 = vrsqrtsq_f32(q_step_parm0, q_step_0);
     // step
-    const float32x4_t q_step_1 = vmulq_f32( q_step_0, q_step_result0 );
-    const float32x4_t q_step_parm1 = vmulq_f32( q_x, q_step_1 );
-    const float32x4_t q_step_result1 = vrsqrtsq_f32( q_step_parm1, q_step_1 );
+    const float32x4_t q_step_1 = vmulq_f32(q_step_0, q_step_result0);
+    const float32x4_t q_step_parm1 = vmulq_f32(q_x, q_step_1);
+    const float32x4_t q_step_result1 = vrsqrtsq_f32(q_step_parm1, q_step_1);
     // take the res
-    const float32x4_t q_step_2 = vmulq_f32( q_step_1, q_step_result1 );
+    const float32x4_t q_step_2 = vmulq_f32(q_step_1, q_step_result1);
     // mul by x to get sqrt, not rsqrt
-    return vmulq_f32( q_x, q_step_2 );
+    return vmulq_f32(q_x, q_step_2);
 }
 
 #endif /* INCLUDED_VOLK_GNSSSDR_NEON_INTRINSICS_H_ */

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/include/volk_gnsssdr/volk_gnsssdr_prefs.h

@@ -32,9 +32,9 @@ __VOLK_DECL_BEGIN
 
 typedef struct volk_gnsssdr_arch_pref
 {
-    char name[128];   //name of the kernel
-    char impl_a[128]; //best aligned impl
-    char impl_u[128]; //best unaligned impl
+    char name[128];    //name of the kernel
+    char impl_a[128];  //best aligned impl
+    char impl_u[128];  //best unaligned impl
 } volk_gnsssdr_arch_pref_t;
 
 ////////////////////////////////////////////////////////////////////////

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/include/volk_gnsssdr/volk_gnsssdr_sse3_intrinsics.h

@@ -30,33 +30,35 @@
 static inline __m128
 _mm_complexmul_ps(__m128 x, __m128 y)
 {
-  __m128 yl, yh, tmp1, tmp2;
-  yl = _mm_moveldup_ps(y); // Load yl with cr,cr,dr,dr
-  yh = _mm_movehdup_ps(y); // Load yh with ci,ci,di,di
-  tmp1 = _mm_mul_ps(x, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-  x = _mm_shuffle_ps(x, x, 0xB1); // Re-arrange x to be ai,ar,bi,br
-  tmp2 = _mm_mul_ps(x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-  return _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+    __m128 yl, yh, tmp1, tmp2;
+    yl = _mm_moveldup_ps(y);           // Load yl with cr,cr,dr,dr
+    yh = _mm_movehdup_ps(y);           // Load yh with ci,ci,di,di
+    tmp1 = _mm_mul_ps(x, yl);          // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+    x = _mm_shuffle_ps(x, x, 0xB1);    // Re-arrange x to be ai,ar,bi,br
+    tmp2 = _mm_mul_ps(x, yh);          // tmp2 = ai*ci,ar*ci,bi*di,br*di
+    return _mm_addsub_ps(tmp1, tmp2);  // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
 }
 
 static inline __m128
 _mm_complexconjugatemul_ps(__m128 x, __m128 y)
 {
-  const __m128 conjugator = _mm_setr_ps(0, -0.f, 0, -0.f);
-  y = _mm_xor_ps(y, conjugator); // conjugate y
-  return _mm_complexmul_ps(x, y);
+    const __m128 conjugator = _mm_setr_ps(0, -0.f, 0, -0.f);
+    y = _mm_xor_ps(y, conjugator);  // conjugate y
+    return _mm_complexmul_ps(x, y);
 }
 
 static inline __m128
-_mm_magnitudesquared_ps_sse3(__m128 cplxValue1, __m128 cplxValue2){
-  cplxValue1 = _mm_mul_ps(cplxValue1, cplxValue1); // Square the values
-  cplxValue2 = _mm_mul_ps(cplxValue2, cplxValue2); // Square the Values
-  return _mm_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
+_mm_magnitudesquared_ps_sse3(__m128 cplxValue1, __m128 cplxValue2)
+{
+    cplxValue1 = _mm_mul_ps(cplxValue1, cplxValue1);  // Square the values
+    cplxValue2 = _mm_mul_ps(cplxValue2, cplxValue2);  // Square the Values
+    return _mm_hadd_ps(cplxValue1, cplxValue2);       // Add the I2 and Q2 values
 }
 
 static inline __m128
-_mm_magnitude_ps_sse3(__m128 cplxValue1, __m128 cplxValue2){
-  return _mm_sqrt_ps(_mm_magnitudesquared_ps_sse3(cplxValue1, cplxValue2));
+_mm_magnitude_ps_sse3(__m128 cplxValue1, __m128 cplxValue2)
+{
+    return _mm_sqrt_ps(_mm_magnitudesquared_ps_sse3(cplxValue1, cplxValue2));
 }
 
 #endif /* INCLUDE_VOLK_VOLK_SSE3_INTRINSICS_H_ */

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/include/volk_gnsssdr/volk_gnsssdr_sse_intrinsics.h

@@ -27,20 +27,22 @@
 #include <xmmintrin.h>
 
 static inline __m128
-_mm_magnitudesquared_ps(__m128 cplxValue1, __m128 cplxValue2){
-  __m128 iValue, qValue;
-  // Arrange in i1i2i3i4 format
-  iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2,0,2,0));
-  // Arrange in q1q2q3q4 format
-  qValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3,1,3,1));
-  iValue = _mm_mul_ps(iValue, iValue); // Square the I values
-  qValue = _mm_mul_ps(qValue, qValue); // Square the Q Values
-  return _mm_add_ps(iValue, qValue); // Add the I2 and Q2 values
+_mm_magnitudesquared_ps(__m128 cplxValue1, __m128 cplxValue2)
+{
+    __m128 iValue, qValue;
+    // Arrange in i1i2i3i4 format
+    iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2, 0, 2, 0));
+    // Arrange in q1q2q3q4 format
+    qValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3, 1, 3, 1));
+    iValue = _mm_mul_ps(iValue, iValue);  // Square the I values
+    qValue = _mm_mul_ps(qValue, qValue);  // Square the Q Values
+    return _mm_add_ps(iValue, qValue);    // Add the I2 and Q2 values
 }
 
 static inline __m128
-_mm_magnitude_ps(__m128 cplxValue1, __m128 cplxValue2){
-  return _mm_sqrt_ps(_mm_magnitudesquared_ps(cplxValue1, cplxValue2));
+_mm_magnitude_ps(__m128 cplxValue1, __m128 cplxValue2)
+{
+    return _mm_sqrt_ps(_mm_magnitudesquared_ps(cplxValue1, cplxValue2));
 }
 
 #endif /* INCLUDED_VOLK_VOLK_SSE_INTRINSICS_H_ */

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16i_resamplerxnpuppet_16i.h

@@ -45,26 +45,26 @@
 static inline void volk_gnsssdr_16i_resamplerxnpuppet_16i_generic(int16_t* result, const int16_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     unsigned int n;
     float rem_code_phase_chips = -0.234;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1  };
-    int16_t** result_aux =  (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
+    int16_t** result_aux = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_16i_xn_resampler_16i_xn_generic(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((int16_t*)result, (int16_t*)result_aux[0], sizeof(int16_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -74,26 +74,26 @@ static inline void volk_gnsssdr_16i_resamplerxnpuppet_16i_generic(int16_t* resul
 static inline void volk_gnsssdr_16i_resamplerxnpuppet_16i_a_sse3(int16_t* result, const int16_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
-    int16_t** result_aux =  (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
+    int16_t** result_aux = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_16i_xn_resampler_16i_xn_a_sse3(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((int16_t*)result, (int16_t*)result_aux[0], sizeof(int16_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -103,26 +103,26 @@ static inline void volk_gnsssdr_16i_resamplerxnpuppet_16i_a_sse3(int16_t* result
 static inline void volk_gnsssdr_16i_resamplerxnpuppet_16i_u_sse3(int16_t* result, const int16_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
-    int16_t** result_aux =  (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
+    int16_t** result_aux = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_16i_xn_resampler_16i_xn_u_sse3(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((int16_t*)result, (int16_t*)result_aux[0], sizeof(int16_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -133,26 +133,26 @@ static inline void volk_gnsssdr_16i_resamplerxnpuppet_16i_u_sse3(int16_t* result
 static inline void volk_gnsssdr_16i_resamplerxnpuppet_16i_u_sse4_1(int16_t* result, const int16_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
-    int16_t** result_aux =  (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
+    int16_t** result_aux = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_16i_xn_resampler_16i_xn_u_sse4_1(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((int16_t*)result, (int16_t*)result_aux[0], sizeof(int16_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -163,26 +163,26 @@ static inline void volk_gnsssdr_16i_resamplerxnpuppet_16i_u_sse4_1(int16_t* resu
 static inline void volk_gnsssdr_16i_resamplerxnpuppet_16i_a_sse4_1(int16_t* result, const int16_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
-    int16_t** result_aux =  (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
+    int16_t** result_aux = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_16i_xn_resampler_16i_xn_a_sse4_1(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((int16_t*)result, (int16_t*)result_aux[0], sizeof(int16_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -193,26 +193,26 @@ static inline void volk_gnsssdr_16i_resamplerxnpuppet_16i_a_sse4_1(int16_t* resu
 static inline void volk_gnsssdr_16i_resamplerxnpuppet_16i_u_avx(int16_t* result, const int16_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
-    int16_t** result_aux =  (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
+    int16_t** result_aux = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_16i_xn_resampler_16i_xn_u_avx(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((int16_t*)result, (int16_t*)result_aux[0], sizeof(int16_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -223,26 +223,26 @@ static inline void volk_gnsssdr_16i_resamplerxnpuppet_16i_u_avx(int16_t* result,
 static inline void volk_gnsssdr_16i_resamplerxnpuppet_16i_a_avx(int16_t* result, const int16_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
-    int16_t** result_aux =  (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
+    int16_t** result_aux = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_16i_xn_resampler_16i_xn_a_avx(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((int16_t*)result, (int16_t*)result_aux[0], sizeof(int16_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -253,30 +253,29 @@ static inline void volk_gnsssdr_16i_resamplerxnpuppet_16i_a_avx(int16_t* result,
 static inline void volk_gnsssdr_16i_resamplerxnpuppet_16i_neon(int16_t* result, const int16_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
-    int16_t** result_aux =  (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
+    int16_t** result_aux = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_16i_xn_resampler_16i_xn_neon(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((int16_t*)result, (int16_t*)result_aux[0], sizeof(int16_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
 #endif
 
-#endif // INCLUDED_volk_gnsssdr_16i_resamplerpuppet_16i_H
-
+#endif  // INCLUDED_volk_gnsssdr_16i_resamplerpuppet_16i_H

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16i_xn_resampler_16i_xn.h

@@ -107,7 +107,8 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_a_sse4_1(int16_t** resul
     const __m128 rem_code_phase_chips_reg = _mm_set_ps1(rem_code_phase_chips);
     const __m128 code_phase_step_chips_reg = _mm_set_ps1(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     int local_code_chip_index_;
 
     const __m128i zeros = _mm_setzero_si128();
@@ -121,7 +122,7 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_a_sse4_1(int16_t** resul
             shifts_chips_reg = _mm_set_ps1((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             __m128 indexn = _mm_set_ps(3.0f, 2.0f, 1.0f, 0.0f);
-            for(n = 0; n < quarterPoints; n++)
+            for (n = 0; n < quarterPoints; n++)
                 {
                     aux = _mm_mul_ps(code_phase_step_chips_reg, indexn);
                     aux = _mm_add_ps(aux, aux2);
@@ -139,13 +140,13 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_a_sse4_1(int16_t** resul
                     aux_i = _mm_and_si128(code_length_chips_reg_i, negatives);
                     local_code_chip_index_reg = _mm_add_epi32(local_code_chip_index_reg, aux_i);
                     _mm_store_si128((__m128i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 4; ++k)
+                    for (k = 0; k < 4; ++k)
                         {
                             _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
                         }
                     indexn = _mm_add_ps(indexn, fours);
                 }
-            for(n = quarterPoints * 4; n < num_points; n++)
+            for (n = quarterPoints * 4; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
@@ -173,7 +174,8 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_u_sse4_1(int16_t** resul
     const __m128 rem_code_phase_chips_reg = _mm_set_ps1(rem_code_phase_chips);
     const __m128 code_phase_step_chips_reg = _mm_set_ps1(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     int local_code_chip_index_;
 
     const __m128i zeros = _mm_setzero_si128();
@@ -187,7 +189,7 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_u_sse4_1(int16_t** resul
             shifts_chips_reg = _mm_set_ps1((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             __m128 indexn = _mm_set_ps(3.0f, 2.0f, 1.0f, 0.0f);
-            for(n = 0; n < quarterPoints; n++)
+            for (n = 0; n < quarterPoints; n++)
                 {
                     aux = _mm_mul_ps(code_phase_step_chips_reg, indexn);
                     aux = _mm_add_ps(aux, aux2);
@@ -205,13 +207,13 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_u_sse4_1(int16_t** resul
                     aux_i = _mm_and_si128(code_length_chips_reg_i, negatives);
                     local_code_chip_index_reg = _mm_add_epi32(local_code_chip_index_reg, aux_i);
                     _mm_store_si128((__m128i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 4; ++k)
+                    for (k = 0; k < 4; ++k)
                         {
                             _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
                         }
                     indexn = _mm_add_ps(indexn, fours);
                 }
-            for(n = quarterPoints * 4; n < num_points; n++)
+            for (n = quarterPoints * 4; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
@@ -240,7 +242,8 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_a_sse3(int16_t** result,
     const __m128 rem_code_phase_chips_reg = _mm_set_ps1(rem_code_phase_chips);
     const __m128 code_phase_step_chips_reg = _mm_set_ps1(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     int local_code_chip_index_;
 
     const __m128i zeros = _mm_setzero_si128();
@@ -254,7 +257,7 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_a_sse3(int16_t** result,
             shifts_chips_reg = _mm_set_ps1((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             __m128 indexn = _mm_set_ps(3.0f, 2.0f, 1.0f, 0.0f);
-            for(n = 0; n < quarterPoints; n++)
+            for (n = 0; n < quarterPoints; n++)
                 {
                     aux = _mm_mul_ps(code_phase_step_chips_reg, indexn);
                     aux = _mm_add_ps(aux, aux2);
@@ -275,13 +278,13 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_a_sse3(int16_t** result,
                     aux_i = _mm_and_si128(code_length_chips_reg_i, negatives);
                     local_code_chip_index_reg = _mm_add_epi32(local_code_chip_index_reg, aux_i);
                     _mm_store_si128((__m128i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 4; ++k)
+                    for (k = 0; k < 4; ++k)
                         {
                             _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
                         }
                     indexn = _mm_add_ps(indexn, fours);
                 }
-            for(n = quarterPoints * 4; n < num_points; n++)
+            for (n = quarterPoints * 4; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
@@ -310,7 +313,8 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_u_sse3(int16_t** result,
     const __m128 rem_code_phase_chips_reg = _mm_set_ps1(rem_code_phase_chips);
     const __m128 code_phase_step_chips_reg = _mm_set_ps1(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     int local_code_chip_index_;
 
     const __m128i zeros = _mm_setzero_si128();
@@ -324,7 +328,7 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_u_sse3(int16_t** result,
             shifts_chips_reg = _mm_set_ps1((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             __m128 indexn = _mm_set_ps(3.0f, 2.0f, 1.0f, 0.0f);
-            for(n = 0; n < quarterPoints; n++)
+            for (n = 0; n < quarterPoints; n++)
                 {
                     aux = _mm_mul_ps(code_phase_step_chips_reg, indexn);
                     aux = _mm_add_ps(aux, aux2);
@@ -345,13 +349,13 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_u_sse3(int16_t** result,
                     aux_i = _mm_and_si128(code_length_chips_reg_i, negatives);
                     local_code_chip_index_reg = _mm_add_epi32(local_code_chip_index_reg, aux_i);
                     _mm_store_si128((__m128i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 4; ++k)
+                    for (k = 0; k < 4; ++k)
                         {
                             _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
                         }
                     indexn = _mm_add_ps(indexn, fours);
                 }
-            for(n = quarterPoints * 4; n < num_points; n++)
+            for (n = quarterPoints * 4; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
@@ -379,7 +383,8 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_a_avx(int16_t** result,
     const __m256 rem_code_phase_chips_reg = _mm256_set1_ps(rem_code_phase_chips);
     const __m256 code_phase_step_chips_reg = _mm256_set1_ps(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(32) int local_code_chip_index[8];
+    __VOLK_ATTR_ALIGNED(32)
+    int local_code_chip_index[8];
     int local_code_chip_index_;
 
     const __m256 zeros = _mm256_setzero_ps();
@@ -394,7 +399,7 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_a_avx(int16_t** result,
             shifts_chips_reg = _mm256_set1_ps((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm256_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             indexn = n0;
-            for(n = 0; n < avx_iters; n++)
+            for (n = 0; n < avx_iters; n++)
                 {
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&_result[current_correlator_tap][8 * n + 7], 1, 0);
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&local_code_chip_index[8], 1, 3);
@@ -412,13 +417,13 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_a_avx(int16_t** result,
 
                     // no negatives
                     c = _mm256_cvtepi32_ps(local_code_chip_index_reg);
-                    negatives = _mm256_cmp_ps(c, zeros, 0x01 );
+                    negatives = _mm256_cmp_ps(c, zeros, 0x01);
                     aux3 = _mm256_and_ps(code_length_chips_reg_f, negatives);
                     aux = _mm256_add_ps(c, aux3);
                     local_code_chip_index_reg = _mm256_cvttps_epi32(aux);
 
                     _mm256_store_si256((__m256i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 8; ++k)
+                    for (k = 0; k < 8; ++k)
                         {
                             _result[current_correlator_tap][n * 8 + k] = local_code[local_code_chip_index[k]];
                         }
@@ -428,7 +433,7 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_a_avx(int16_t** result,
     _mm256_zeroupper();
     for (current_correlator_tap = 0; current_correlator_tap < num_out_vectors; current_correlator_tap++)
         {
-            for(n = avx_iters * 8; n < num_points; n++)
+            for (n = avx_iters * 8; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
@@ -456,7 +461,8 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_u_avx(int16_t** result,
     const __m256 rem_code_phase_chips_reg = _mm256_set1_ps(rem_code_phase_chips);
     const __m256 code_phase_step_chips_reg = _mm256_set1_ps(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(32) int local_code_chip_index[8];
+    __VOLK_ATTR_ALIGNED(32)
+    int local_code_chip_index[8];
     int local_code_chip_index_;
 
     const __m256 zeros = _mm256_setzero_ps();
@@ -471,7 +477,7 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_u_avx(int16_t** result,
             shifts_chips_reg = _mm256_set1_ps((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm256_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             indexn = n0;
-            for(n = 0; n < avx_iters; n++)
+            for (n = 0; n < avx_iters; n++)
                 {
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&_result[current_correlator_tap][8 * n + 7], 1, 0);
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&local_code_chip_index[8], 1, 3);
@@ -489,13 +495,13 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_u_avx(int16_t** result,
 
                     // no negatives
                     c = _mm256_cvtepi32_ps(local_code_chip_index_reg);
-                    negatives = _mm256_cmp_ps(c, zeros, 0x01 );
+                    negatives = _mm256_cmp_ps(c, zeros, 0x01);
                     aux3 = _mm256_and_ps(code_length_chips_reg_f, negatives);
                     aux = _mm256_add_ps(c, aux3);
                     local_code_chip_index_reg = _mm256_cvttps_epi32(aux);
 
                     _mm256_store_si256((__m256i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 8; ++k)
+                    for (k = 0; k < 8; ++k)
                         {
                             _result[current_correlator_tap][n * 8 + k] = local_code[local_code_chip_index[k]];
                         }
@@ -505,7 +511,7 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_u_avx(int16_t** result,
     _mm256_zeroupper();
     for (current_correlator_tap = 0; current_correlator_tap < num_out_vectors; current_correlator_tap++)
         {
-            for(n = avx_iters * 8; n < num_points; n++)
+            for (n = avx_iters * 8; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
@@ -531,7 +537,8 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_neon(int16_t** result, c
     const float32x4_t rem_code_phase_chips_reg = vdupq_n_f32(rem_code_phase_chips);
     const float32x4_t code_phase_step_chips_reg = vdupq_n_f32(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(16) int32_t local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int32_t local_code_chip_index[4];
     int32_t local_code_chip_index_;
 
     const int32x4_t zeros = vdupq_n_s32(0);
@@ -539,11 +546,12 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_neon(int16_t** result, c
     const int32x4_t code_length_chips_reg_i = vdupq_n_s32((int32_t)code_length_chips);
     int32x4_t local_code_chip_index_reg, aux_i, negatives, i;
     float32x4_t aux, aux2, shifts_chips_reg, fi, c, j, cTrunc, base, indexn, reciprocal;
-    __VOLK_ATTR_ALIGNED(16) const float vec[4] = { 0.0f, 1.0f, 2.0f, 3.0f };
+    __VOLK_ATTR_ALIGNED(16)
+    const float vec[4] = {0.0f, 1.0f, 2.0f, 3.0f};
     uint32x4_t igx;
     reciprocal = vrecpeq_f32(code_length_chips_reg_f);
     reciprocal = vmulq_f32(vrecpsq_f32(code_length_chips_reg_f, reciprocal), reciprocal);
-    reciprocal = vmulq_f32(vrecpsq_f32(code_length_chips_reg_f, reciprocal), reciprocal); // this refinement is required!
+    reciprocal = vmulq_f32(vrecpsq_f32(code_length_chips_reg_f, reciprocal), reciprocal);  // this refinement is required!
     float32x4_t n0 = vld1q_f32((float*)vec);
     int current_correlator_tap;
     unsigned int n;
@@ -553,7 +561,7 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_neon(int16_t** result, c
             shifts_chips_reg = vdupq_n_f32((float)shifts_chips[current_correlator_tap]);
             aux2 = vsubq_f32(shifts_chips_reg, rem_code_phase_chips_reg);
             indexn = n0;
-            for(n = 0; n < neon_iters; n++)
+            for (n = 0; n < neon_iters; n++)
                 {
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&_result[current_correlator_tap][4 * n + 3], 1, 0);
                     __VOLK_GNSSSDR_PREFETCH(&local_code_chip_index[4]);
@@ -569,7 +577,7 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_neon(int16_t** result, c
 
                     // fmod
                     c = vmulq_f32(aux, reciprocal);
-                    i =  vcvtq_s32_f32(c);
+                    i = vcvtq_s32_f32(c);
                     cTrunc = vcvtq_f32_s32(i);
                     base = vmulq_f32(cTrunc, code_length_chips_reg_f);
                     aux = vsubq_f32(aux, base);
@@ -581,13 +589,13 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_neon(int16_t** result, c
 
                     vst1q_s32((int32_t*)local_code_chip_index, local_code_chip_index_reg);
 
-                    for(k = 0; k < 4; ++k)
+                    for (k = 0; k < 4; ++k)
                         {
                             _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
                         }
                     indexn = vaddq_f32(indexn, fours);
                 }
-            for(n = neon_iters * 4; n < num_points; n++)
+            for (n = neon_iters * 4; n < num_points; n++)
                 {
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&_result[current_correlator_tap][n], 1, 0);
                     // resample code for current tap
@@ -605,4 +613,3 @@ static inline void volk_gnsssdr_16i_xn_resampler_16i_xn_neon(int16_t** result, c
 
 
 #endif /*INCLUDED_volk_gnsssdr_16i_xn_resampler_16i_xn_H*/
-

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic.h

@@ -41,7 +41,7 @@
 #include <string.h>
 
 #ifdef LV_HAVE_GENERIC
-static inline void volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic_generic(lv_16sc_t* result, const lv_16sc_t* local_code,  const lv_16sc_t* in, unsigned int num_points)
+static inline void volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic_generic(lv_16sc_t* result, const lv_16sc_t* local_code, const lv_16sc_t* in, unsigned int num_points)
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.345;
@@ -53,14 +53,14 @@ static inline void volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic_generic(lv
     unsigned int n;
     int num_a_vectors = 3;
     int16_t** in_a = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((int16_t*)in_a[n], (int16_t*)in, sizeof(int16_t) * num_points);
         }
-    volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_generic(result, local_code, phase_inc[0], phase,(const int16_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_generic(result, local_code, phase_inc[0], phase, (const int16_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
@@ -71,7 +71,7 @@ static inline void volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic_generic(lv
 
 
 #ifdef LV_HAVE_GENERIC
-static inline void volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic_generic_reload(lv_16sc_t* result, const lv_16sc_t* local_code,  const lv_16sc_t* in, unsigned int num_points)
+static inline void volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic_generic_reload(lv_16sc_t* result, const lv_16sc_t* local_code, const lv_16sc_t* in, unsigned int num_points)
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.345;
@@ -83,14 +83,14 @@ static inline void volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic_generic_re
     unsigned int n;
     int num_a_vectors = 3;
     int16_t** in_a = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((int16_t*)in_a[n], (int16_t*)in, sizeof(int16_t) * num_points);
         }
-    volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_generic_reload(result, local_code, phase_inc[0], phase,(const int16_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_generic_reload(result, local_code, phase_inc[0], phase, (const int16_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
@@ -113,50 +113,50 @@ static inline void volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic_a_sse3(lv_
     unsigned int n;
     int num_a_vectors = 3;
     int16_t** in_a = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((int16_t*)in_a[n], (int16_t*)in, sizeof(int16_t) * num_points);
         }
 
-    volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_a_sse3(result, local_code, phase_inc[0], phase, (const int16_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_a_sse3(result, local_code, phase_inc[0], phase, (const int16_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
     volk_gnsssdr_free(in_a);
 }
 
-#endif // SSE3
+#endif  // SSE3
 
 
 //#ifdef LV_HAVE_SSE3
 //static inline void volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic_a_sse3_reload(lv_16sc_t* result, const lv_16sc_t* local_code, const lv_16sc_t* in, unsigned int num_points)
 //{
-    //// phases must be normalized. Phase rotator expects a complex exponential input!
-    //float rem_carrier_phase_in_rad = 0.345;
-    //float phase_step_rad = 0.1;
-    //lv_32fc_t phase[1];
-    //phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), sin(rem_carrier_phase_in_rad));
-    //lv_32fc_t phase_inc[1];
-    //phase_inc[0] = lv_cmake(cos(phase_step_rad), sin(phase_step_rad));
-    //unsigned int n;
-    //int num_a_vectors = 3;
-    //int16_t** in_a = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    //for(n = 0; n < num_a_vectors; n++)
-        //{
-            //in_a[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
-            //memcpy((int16_t*)in_a[n], (int16_t*)in, sizeof(int16_t) * num_points);
-        //}
+//// phases must be normalized. Phase rotator expects a complex exponential input!
+//float rem_carrier_phase_in_rad = 0.345;
+//float phase_step_rad = 0.1;
+//lv_32fc_t phase[1];
+//phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), sin(rem_carrier_phase_in_rad));
+//lv_32fc_t phase_inc[1];
+//phase_inc[0] = lv_cmake(cos(phase_step_rad), sin(phase_step_rad));
+//unsigned int n;
+//int num_a_vectors = 3;
+//int16_t** in_a = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
+//for(n = 0; n < num_a_vectors; n++)
+//{
+//in_a[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
+//memcpy((int16_t*)in_a[n], (int16_t*)in, sizeof(int16_t) * num_points);
+//}
 
-    //volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_a_sse3_reload(result, local_code, phase_inc[0], phase, (const int16_t**) in_a, num_a_vectors, num_points);
+//volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_a_sse3_reload(result, local_code, phase_inc[0], phase, (const int16_t**) in_a, num_a_vectors, num_points);
 
-    //for(n = 0; n < num_a_vectors; n++)
-        //{
-            //volk_gnsssdr_free(in_a[n]);
-        //}
-    //volk_gnsssdr_free(in_a);
+//for(n = 0; n < num_a_vectors; n++)
+//{
+//volk_gnsssdr_free(in_a[n]);
+//}
+//volk_gnsssdr_free(in_a);
 //}
 
 //#endif // SSE3
@@ -175,22 +175,22 @@ static inline void volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic_u_sse3(lv_
     unsigned int n;
     int num_a_vectors = 3;
     int16_t** in_a = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((int16_t*)in_a[n], (int16_t*)in, sizeof(int16_t) * num_points);
         }
 
-    volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_u_sse3(result, local_code, phase_inc[0], phase, (const int16_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_u_sse3(result, local_code, phase_inc[0], phase, (const int16_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
     volk_gnsssdr_free(in_a);
 }
 
-#endif // SSE3
+#endif  // SSE3
 
 
 #ifdef LV_HAVE_AVX2
@@ -206,50 +206,50 @@ static inline void volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic_a_avx2(lv_
     unsigned int n;
     int num_a_vectors = 3;
     int16_t** in_a = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((int16_t*)in_a[n], (int16_t*)in, sizeof(int16_t) * num_points);
         }
 
-    volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_a_avx2(result, local_code, phase_inc[0], phase, (const int16_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_a_avx2(result, local_code, phase_inc[0], phase, (const int16_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
     volk_gnsssdr_free(in_a);
 }
 
-#endif // AVX2
+#endif  // AVX2
 
 
 //#ifdef LV_HAVE_AVX2
 //static inline void volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic_a_avx2_reload(lv_16sc_t* result, const lv_16sc_t* local_code, const lv_16sc_t* in, unsigned int num_points)
 //{
-    //// phases must be normalized. Phase rotator expects a complex exponential input!
-    //float rem_carrier_phase_in_rad = 0.345;
-    //float phase_step_rad = 0.1;
-    //lv_32fc_t phase[1];
-    //phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), sin(rem_carrier_phase_in_rad));
-    //lv_32fc_t phase_inc[1];
-    //phase_inc[0] = lv_cmake(cos(phase_step_rad), sin(phase_step_rad));
-    //unsigned int n;
-    //int num_a_vectors = 3;
-    //int16_t** in_a = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    //for(n = 0; n < num_a_vectors; n++)
-        //{
-            //in_a[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
-            //memcpy((int16_t*)in_a[n], (int16_t*)in, sizeof(int16_t) * num_points);
-        //}
+//// phases must be normalized. Phase rotator expects a complex exponential input!
+//float rem_carrier_phase_in_rad = 0.345;
+//float phase_step_rad = 0.1;
+//lv_32fc_t phase[1];
+//phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), sin(rem_carrier_phase_in_rad));
+//lv_32fc_t phase_inc[1];
+//phase_inc[0] = lv_cmake(cos(phase_step_rad), sin(phase_step_rad));
+//unsigned int n;
+//int num_a_vectors = 3;
+//int16_t** in_a = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
+//for(n = 0; n < num_a_vectors; n++)
+//{
+//in_a[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
+//memcpy((int16_t*)in_a[n], (int16_t*)in, sizeof(int16_t) * num_points);
+//}
 
-    //volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_a_avx2_reload(result, local_code, phase_inc[0], phase, (const int16_t**) in_a, num_a_vectors, num_points);
+//volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_a_avx2_reload(result, local_code, phase_inc[0], phase, (const int16_t**) in_a, num_a_vectors, num_points);
 
-    //for(n = 0; n < num_a_vectors; n++)
-        //{
-            //volk_gnsssdr_free(in_a[n]);
-        //}
-    //volk_gnsssdr_free(in_a);
+//for(n = 0; n < num_a_vectors; n++)
+//{
+//volk_gnsssdr_free(in_a[n]);
+//}
+//volk_gnsssdr_free(in_a);
 //}
 
 //#endif // AVX2
@@ -268,50 +268,50 @@ static inline void volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic_u_avx2(lv_
     unsigned int n;
     int num_a_vectors = 3;
     int16_t** in_a = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((int16_t*)in_a[n], (int16_t*)in, sizeof(int16_t) * num_points);
         }
 
-    volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_u_avx2(result, local_code, phase_inc[0], phase, (const int16_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_u_avx2(result, local_code, phase_inc[0], phase, (const int16_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
     volk_gnsssdr_free(in_a);
 }
 
-#endif // AVX2
+#endif  // AVX2
 
 
 //#ifdef LV_HAVE_AVX2
 //static inline void volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic_u_avx2_reload(lv_16sc_t* result, const lv_16sc_t* local_code, const lv_16sc_t* in, unsigned int num_points)
 //{
-    //// phases must be normalized. Phase rotator expects a complex exponential input!
-    //float rem_carrier_phase_in_rad = 0.345;
-    //float phase_step_rad = 0.1;
-    //lv_32fc_t phase[1];
-    //phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), sin(rem_carrier_phase_in_rad));
-    //lv_32fc_t phase_inc[1];
-    //phase_inc[0] = lv_cmake(cos(phase_step_rad), sin(phase_step_rad));
-    //unsigned int n;
-    //int num_a_vectors = 3;
-    //int16_t** in_a = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    //for(n = 0; n < num_a_vectors; n++)
-        //{
-            //in_a[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
-            //memcpy((int16_t*)in_a[n], (int16_t*)in, sizeof(int16_t) * num_points);
-        //}
+//// phases must be normalized. Phase rotator expects a complex exponential input!
+//float rem_carrier_phase_in_rad = 0.345;
+//float phase_step_rad = 0.1;
+//lv_32fc_t phase[1];
+//phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), sin(rem_carrier_phase_in_rad));
+//lv_32fc_t phase_inc[1];
+//phase_inc[0] = lv_cmake(cos(phase_step_rad), sin(phase_step_rad));
+//unsigned int n;
+//int num_a_vectors = 3;
+//int16_t** in_a = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
+//for(n = 0; n < num_a_vectors; n++)
+//{
+//in_a[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
+//memcpy((int16_t*)in_a[n], (int16_t*)in, sizeof(int16_t) * num_points);
+//}
 
-    //volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_a_avx2_reload(result, local_code, phase_inc[0], phase, (const int16_t**) in_a, num_a_vectors, num_points);
+//volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_a_avx2_reload(result, local_code, phase_inc[0], phase, (const int16_t**) in_a, num_a_vectors, num_points);
 
-    //for(n = 0; n < num_a_vectors; n++)
-        //{
-            //volk_gnsssdr_free(in_a[n]);
-        //}
-    //volk_gnsssdr_free(in_a);
+//for(n = 0; n < num_a_vectors; n++)
+//{
+//volk_gnsssdr_free(in_a[n]);
+//}
+//volk_gnsssdr_free(in_a);
 //}
 
 //#endif // AVX2
@@ -320,29 +320,29 @@ static inline void volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic_u_avx2(lv_
 //#ifdef LV_HAVE_NEON
 //static inline void volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic_neon(lv_16sc_t* result, const lv_16sc_t* local_code, const lv_16sc_t* in, unsigned int num_points)
 //{
-    //// phases must be normalized. Phase rotator expects a complex exponential input!
-    //float rem_carrier_phase_in_rad = 0.345;
-    //float phase_step_rad = 0.1;
-    //lv_32fc_t phase[1];
-    //phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), sin(rem_carrier_phase_in_rad));
-    //lv_32fc_t phase_inc[1];
-    //phase_inc[0] = lv_cmake(cos(phase_step_rad), sin(phase_step_rad));
-    //unsigned int n;
-    //int num_a_vectors = 3;
-    //int16_t** in_a = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    //for(n = 0; n < num_a_vectors; n++)
-        //{
-            //in_a[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
-            //memcpy((int16_t*)in_a[n], (int16_t*)in, sizeof(int16_t) * num_points);
-        //}
+//// phases must be normalized. Phase rotator expects a complex exponential input!
+//float rem_carrier_phase_in_rad = 0.345;
+//float phase_step_rad = 0.1;
+//lv_32fc_t phase[1];
+//phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), sin(rem_carrier_phase_in_rad));
+//lv_32fc_t phase_inc[1];
+//phase_inc[0] = lv_cmake(cos(phase_step_rad), sin(phase_step_rad));
+//unsigned int n;
+//int num_a_vectors = 3;
+//int16_t** in_a = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
+//for(n = 0; n < num_a_vectors; n++)
+//{
+//in_a[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
+//memcpy((int16_t*)in_a[n], (int16_t*)in, sizeof(int16_t) * num_points);
+//}
 
-    //volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_neon(result, local_code, phase_inc[0], phase, (const int16_t**) in_a, num_a_vectors, num_points);
+//volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_neon(result, local_code, phase_inc[0], phase, (const int16_t**) in_a, num_a_vectors, num_points);
 
-    //for(n = 0; n < num_a_vectors; n++)
-        //{
-            //volk_gnsssdr_free(in_a[n]);
-        //}
-    //volk_gnsssdr_free(in_a);
+//for(n = 0; n < num_a_vectors; n++)
+//{
+//volk_gnsssdr_free(in_a[n]);
+//}
+//volk_gnsssdr_free(in_a);
 //}
 
 //#endif // NEON
@@ -351,34 +351,31 @@ static inline void volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic_u_avx2(lv_
 //#ifdef LV_HAVE_NEON
 //static inline void volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic_neon_vma(lv_16sc_t* result, const lv_16sc_t* local_code, const lv_16sc_t* in, unsigned int num_points)
 //{
-    //// phases must be normalized. Phase rotator expects a complex exponential input!
-    //float rem_carrier_phase_in_rad = 0.345;
-    //float phase_step_rad = 0.1;
-    //lv_32fc_t phase[1];
-    //phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), sin(rem_carrier_phase_in_rad));
-    //lv_32fc_t phase_inc[1];
-    //phase_inc[0] = lv_cmake(cos(phase_step_rad), sin(phase_step_rad));
-    //unsigned int n;
-    //int num_a_vectors = 3;
-    //int16_t** in_a = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    //for(n = 0; n < num_a_vectors; n++)
-        //{
-            //in_a[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
-            //memcpy((int16_t*)in_a[n], (int16_t*)in, sizeof(int16_t) * num_points);
-        //}
+//// phases must be normalized. Phase rotator expects a complex exponential input!
+//float rem_carrier_phase_in_rad = 0.345;
+//float phase_step_rad = 0.1;
+//lv_32fc_t phase[1];
+//phase[0] = lv_cmake(cos(rem_carrier_phase_in_rad), sin(rem_carrier_phase_in_rad));
+//lv_32fc_t phase_inc[1];
+//phase_inc[0] = lv_cmake(cos(phase_step_rad), sin(phase_step_rad));
+//unsigned int n;
+//int num_a_vectors = 3;
+//int16_t** in_a = (int16_t**)volk_gnsssdr_malloc(sizeof(int16_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
+//for(n = 0; n < num_a_vectors; n++)
+//{
+//in_a[n] = (int16_t*)volk_gnsssdr_malloc(sizeof(int16_t) * num_points, volk_gnsssdr_get_alignment());
+//memcpy((int16_t*)in_a[n], (int16_t*)in, sizeof(int16_t) * num_points);
+//}
 
-    //volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_neon_vma(result, local_code, phase_inc[0], phase, (const int16_t**) in_a, num_a_vectors, num_points);
+//volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_neon_vma(result, local_code, phase_inc[0], phase, (const int16_t**) in_a, num_a_vectors, num_points);
 
-    //for(n = 0; n < num_a_vectors; n++)
-        //{
-            //volk_gnsssdr_free(in_a[n]);
-        //}
-    //volk_gnsssdr_free(in_a);
+//for(n = 0; n < num_a_vectors; n++)
+//{
+//volk_gnsssdr_free(in_a[n]);
+//}
+//volk_gnsssdr_free(in_a);
 //}
 
 //#endif // NEON
 
 #endif  // INCLUDED_volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic_H
-
-
-

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_conjugate_16ic.h

@@ -68,7 +68,7 @@ static inline void volk_gnsssdr_16ic_conjugate_16ic_generic(lv_16sc_t* cVector,
     const lv_16sc_t* aPtr = aVector;
     unsigned int number;
 
-    for(number = 0; number < num_points; number++)
+    for (number = 0; number < num_points; number++)
         {
             *cPtr++ = lv_conj(*aPtr++);
         }
@@ -231,4 +231,3 @@ static inline void volk_gnsssdr_16ic_conjugate_16ic_u_avx2(lv_16sc_t* cVector, c
 //#endif /* LV_HAVE_NEON */
 
 #endif /* INCLUDED_volk_gnsssdr_16ic_conjugate_16ic_H */
-

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_convert_32fc.h

@@ -63,7 +63,7 @@
 static inline void volk_gnsssdr_16ic_convert_32fc_generic(lv_32fc_t* outputVector, const lv_16sc_t* inputVector, unsigned int num_points)
 {
     unsigned int i;
-    for(i = 0; i < num_points; i++)
+    for (i = 0; i < num_points; i++)
         {
             outputVector[i] = lv_cmake((float)lv_creal(inputVector[i]), (float)lv_cimag(inputVector[i]));
         }
@@ -82,9 +82,9 @@ static inline void volk_gnsssdr_16ic_convert_32fc_a_sse2(lv_32fc_t* outputVector
     lv_32fc_t* _out = outputVector;
     __m128 a;
 
-    for(i = 0; i < sse_iters; i++)
+    for (i = 0; i < sse_iters; i++)
         {
-            a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0]))); // load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+            a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0])));  // load (2 byte imag, 2 byte real) x 2 into 128 bits reg
             _mm_store_ps((float*)_out, a);
             _in += 2;
             _out += 2;
@@ -109,9 +109,9 @@ static inline void volk_gnsssdr_16ic_convert_32fc_u_sse2(lv_32fc_t* outputVector
     lv_32fc_t* _out = outputVector;
     __m128 a;
 
-    for(i = 0; i < sse_iters; i++)
+    for (i = 0; i < sse_iters; i++)
         {
-            a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+            a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0])));  // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
             _mm_storeu_ps((float*)_out, a);
             _in += 2;
             _out += 2;
@@ -136,15 +136,15 @@ static inline void volk_gnsssdr_16ic_convert_32fc_u_axv(lv_32fc_t* outputVector,
     lv_32fc_t* _out = outputVector;
     __m256 a;
 
-    for(i = 0; i < sse_iters; i++)
+    for (i = 0; i < sse_iters; i++)
         {
-            a = _mm256_set_ps((float)(lv_cimag(_in[3])), (float)(lv_creal(_in[3])), (float)(lv_cimag(_in[2])), (float)(lv_creal(_in[2])), (float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+            a = _mm256_set_ps((float)(lv_cimag(_in[3])), (float)(lv_creal(_in[3])), (float)(lv_cimag(_in[2])), (float)(lv_creal(_in[2])), (float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0])));  // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
             _mm256_storeu_ps((float*)_out, a);
             _in += 4;
             _out += 4;
         }
     _mm256_zeroupper();
-    for(i = 0; i < (num_points % 4); ++i)
+    for (i = 0; i < (num_points % 4); ++i)
         {
             *_out++ = lv_cmake((float)lv_creal(*_in), (float)lv_cimag(*_in));
             _in++;
@@ -163,15 +163,15 @@ static inline void volk_gnsssdr_16ic_convert_32fc_a_axv(lv_32fc_t* outputVector,
     lv_32fc_t* _out = outputVector;
     __m256 a;
 
-    for(i = 0; i < sse_iters; i++)
+    for (i = 0; i < sse_iters; i++)
         {
-            a = _mm256_set_ps((float)(lv_cimag(_in[3])), (float)(lv_creal(_in[3])), (float)(lv_cimag(_in[2])), (float)(lv_creal(_in[2])), (float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+            a = _mm256_set_ps((float)(lv_cimag(_in[3])), (float)(lv_creal(_in[3])), (float)(lv_cimag(_in[2])), (float)(lv_creal(_in[2])), (float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0])));  // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
             _mm256_store_ps((float*)_out, a);
             _in += 4;
             _out += 4;
         }
     _mm256_zeroupper();
-    for(i = 0; i < (num_points % 4); ++i)
+    for (i = 0; i < (num_points % 4); ++i)
         {
             *_out++ = lv_cmake((float)lv_creal(*_in), (float)lv_cimag(*_in));
             _in++;
@@ -194,7 +194,7 @@ static inline void volk_gnsssdr_16ic_convert_32fc_neon(lv_32fc_t* outputVector,
     int32x4_t a32x4;
     float32x4_t f32x4;
 
-    for(i = 0; i < sse_iters; i++)
+    for (i = 0; i < sse_iters; i++)
         {
             a16x4 = vld1_s16((const int16_t*)_in);
             __VOLK_GNSSSDR_PREFETCH(_in + 4);

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_resampler_fast_16ic.h

@@ -78,7 +78,7 @@ static inline void volk_gnsssdr_16ic_resampler_fast_16ic_generic(lv_16sc_t* resu
             // resample code for current tap
             local_code_chip_index = round(code_phase_step_chips * (float)n + rem_code_phase_chips - 0.5f);
             if (local_code_chip_index < 0.0) local_code_chip_index += code_length_chips;
-            if (local_code_chip_index > (code_length_chips-1)) local_code_chip_index -= code_length_chips;
+            if (local_code_chip_index > (code_length_chips - 1)) local_code_chip_index -= code_length_chips;
             result[n] = local_code[local_code_chip_index];
         }
 }
@@ -89,61 +89,66 @@ static inline void volk_gnsssdr_16ic_resampler_fast_16ic_generic(lv_16sc_t* resu
 #ifdef LV_HAVE_SSE2
 #include <emmintrin.h>
 
-static inline void volk_gnsssdr_16ic_resampler_fast_16ic_a_sse2(lv_16sc_t* result, const lv_16sc_t* local_code, float rem_code_phase_chips, float code_phase_step_chips, int code_length_chips, unsigned int num_output_samples)//, int* scratch_buffer, float* scratch_buffer_float)
+static inline void volk_gnsssdr_16ic_resampler_fast_16ic_a_sse2(lv_16sc_t* result, const lv_16sc_t* local_code, float rem_code_phase_chips, float code_phase_step_chips, int code_length_chips, unsigned int num_output_samples)  //, int* scratch_buffer, float* scratch_buffer_float)
 {
-    _MM_SET_ROUNDING_MODE (_MM_ROUND_NEAREST);//_MM_ROUND_NEAREST, _MM_ROUND_DOWN, _MM_ROUND_UP, _MM_ROUND_TOWARD_ZERO
+    _MM_SET_ROUNDING_MODE(_MM_ROUND_NEAREST);  //_MM_ROUND_NEAREST, _MM_ROUND_DOWN, _MM_ROUND_UP, _MM_ROUND_TOWARD_ZERO
     unsigned int number;
     const unsigned int quarterPoints = num_output_samples / 4;
 
     lv_16sc_t* _result = result;
 
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     __m128 _rem_code_phase, _code_phase_step_chips;
     __m128i _code_length_chips, _code_length_chips_minus1;
     __m128 _code_phase_out, _code_phase_out_with_offset;
     rem_code_phase_chips = rem_code_phase_chips - 0.5f;
 
-    _rem_code_phase =  _mm_load1_ps(&rem_code_phase_chips); //load float to all four float values in m128 register
-    _code_phase_step_chips = _mm_load1_ps(&code_phase_step_chips); //load float to all four float values in m128 register
-    __VOLK_ATTR_ALIGNED(16) int four_times_code_length_chips_minus1[4];
-    four_times_code_length_chips_minus1[0] = code_length_chips-1;
-    four_times_code_length_chips_minus1[1] = code_length_chips-1;
-    four_times_code_length_chips_minus1[2] = code_length_chips-1;
-    four_times_code_length_chips_minus1[3] = code_length_chips-1;
+    _rem_code_phase = _mm_load1_ps(&rem_code_phase_chips);          //load float to all four float values in m128 register
+    _code_phase_step_chips = _mm_load1_ps(&code_phase_step_chips);  //load float to all four float values in m128 register
+    __VOLK_ATTR_ALIGNED(16)
+    int four_times_code_length_chips_minus1[4];
+    four_times_code_length_chips_minus1[0] = code_length_chips - 1;
+    four_times_code_length_chips_minus1[1] = code_length_chips - 1;
+    four_times_code_length_chips_minus1[2] = code_length_chips - 1;
+    four_times_code_length_chips_minus1[3] = code_length_chips - 1;
 
-    __VOLK_ATTR_ALIGNED(16) int four_times_code_length_chips[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int four_times_code_length_chips[4];
     four_times_code_length_chips[0] = code_length_chips;
     four_times_code_length_chips[1] = code_length_chips;
     four_times_code_length_chips[2] = code_length_chips;
     four_times_code_length_chips[3] = code_length_chips;
 
-    _code_length_chips = _mm_load_si128((__m128i*)&four_times_code_length_chips); //load float to all four float values in m128 register
-    _code_length_chips_minus1 = _mm_load_si128((__m128i*)&four_times_code_length_chips_minus1); //load float to all four float values in m128 register
+    _code_length_chips = _mm_load_si128((__m128i*)&four_times_code_length_chips);                //load float to all four float values in m128 register
+    _code_length_chips_minus1 = _mm_load_si128((__m128i*)&four_times_code_length_chips_minus1);  //load float to all four float values in m128 register
 
     __m128i negative_indexes, overflow_indexes, _code_phase_out_int, _code_phase_out_int_neg, _code_phase_out_int_over;
 
     __m128i zero = _mm_setzero_si128();
 
-    __VOLK_ATTR_ALIGNED(16) float init_idx_float[4] = { 0.0f, 1.0f, 2.0f, 3.0f };
+    __VOLK_ATTR_ALIGNED(16)
+    float init_idx_float[4] = {0.0f, 1.0f, 2.0f, 3.0f};
     __m128 _4output_index = _mm_load_ps(init_idx_float);
-    __VOLK_ATTR_ALIGNED(16) float init_4constant_float[4] = { 4.0f, 4.0f, 4.0f, 4.0f };
+    __VOLK_ATTR_ALIGNED(16)
+    float init_4constant_float[4] = {4.0f, 4.0f, 4.0f, 4.0f};
     __m128 _4constant_float = _mm_load_ps(init_4constant_float);
 
-    for(number = 0; number < quarterPoints; number++)
+    for (number = 0; number < quarterPoints; number++)
         {
-            _code_phase_out = _mm_mul_ps(_code_phase_step_chips, _4output_index); //compute the code phase point with the phase step
-            _code_phase_out_with_offset = _mm_add_ps(_code_phase_out, _rem_code_phase); //add the phase offset
-            _code_phase_out_int = _mm_cvtps_epi32(_code_phase_out_with_offset); //convert to integer
+            _code_phase_out = _mm_mul_ps(_code_phase_step_chips, _4output_index);        //compute the code phase point with the phase step
+            _code_phase_out_with_offset = _mm_add_ps(_code_phase_out, _rem_code_phase);  //add the phase offset
+            _code_phase_out_int = _mm_cvtps_epi32(_code_phase_out_with_offset);          //convert to integer
 
-            negative_indexes = _mm_cmplt_epi32(_code_phase_out_int, zero); //test for negative values
-            _code_phase_out_int_neg = _mm_add_epi32(_code_phase_out_int, _code_length_chips); //the negative values branch
-            _code_phase_out_int_neg = _mm_xor_si128(_code_phase_out_int, _mm_and_si128( negative_indexes, _mm_xor_si128( _code_phase_out_int_neg, _code_phase_out_int )));
+            negative_indexes = _mm_cmplt_epi32(_code_phase_out_int, zero);                     //test for negative values
+            _code_phase_out_int_neg = _mm_add_epi32(_code_phase_out_int, _code_length_chips);  //the negative values branch
+            _code_phase_out_int_neg = _mm_xor_si128(_code_phase_out_int, _mm_and_si128(negative_indexes, _mm_xor_si128(_code_phase_out_int_neg, _code_phase_out_int)));
 
-            overflow_indexes = _mm_cmpgt_epi32(_code_phase_out_int_neg, _code_length_chips_minus1); //test for overflow values
-            _code_phase_out_int_over = _mm_sub_epi32(_code_phase_out_int_neg, _code_length_chips); //the negative values branch
-            _code_phase_out_int_over = _mm_xor_si128(_code_phase_out_int_neg, _mm_and_si128( overflow_indexes, _mm_xor_si128( _code_phase_out_int_over, _code_phase_out_int_neg )));
+            overflow_indexes = _mm_cmpgt_epi32(_code_phase_out_int_neg, _code_length_chips_minus1);  //test for overflow values
+            _code_phase_out_int_over = _mm_sub_epi32(_code_phase_out_int_neg, _code_length_chips);   //the negative values branch
+            _code_phase_out_int_over = _mm_xor_si128(_code_phase_out_int_neg, _mm_and_si128(overflow_indexes, _mm_xor_si128(_code_phase_out_int_over, _code_phase_out_int_neg)));
 
-            _mm_store_si128((__m128i*)local_code_chip_index, _code_phase_out_int_over); // Store the results back
+            _mm_store_si128((__m128i*)local_code_chip_index, _code_phase_out_int_over);  // Store the results back
 
             //todo: optimize the local code lookup table with intrinsics, if possible
             *_result++ = local_code[local_code_chip_index[0]];
@@ -154,7 +159,7 @@ static inline void volk_gnsssdr_16ic_resampler_fast_16ic_a_sse2(lv_16sc_t* resul
             _4output_index = _mm_add_ps(_4output_index, _4constant_float);
         }
 
-    for(number = quarterPoints * 4; number < num_output_samples; number++)
+    for (number = quarterPoints * 4; number < num_output_samples; number++)
         {
             local_code_chip_index[0] = (int)(code_phase_step_chips * (float)number + rem_code_phase_chips + 0.5f);
             if (local_code_chip_index[0] < 0.0) local_code_chip_index[0] += code_length_chips - 1;
@@ -169,61 +174,66 @@ static inline void volk_gnsssdr_16ic_resampler_fast_16ic_a_sse2(lv_16sc_t* resul
 #ifdef LV_HAVE_SSE2
 #include <emmintrin.h>
 
-static inline void volk_gnsssdr_16ic_resampler_fast_16ic_u_sse2(lv_16sc_t* result, const lv_16sc_t* local_code, float rem_code_phase_chips, float code_phase_step_chips, int code_length_chips, unsigned int num_output_samples)//, int* scratch_buffer, float* scratch_buffer_float)
+static inline void volk_gnsssdr_16ic_resampler_fast_16ic_u_sse2(lv_16sc_t* result, const lv_16sc_t* local_code, float rem_code_phase_chips, float code_phase_step_chips, int code_length_chips, unsigned int num_output_samples)  //, int* scratch_buffer, float* scratch_buffer_float)
 {
-    _MM_SET_ROUNDING_MODE (_MM_ROUND_NEAREST);//_MM_ROUND_NEAREST, _MM_ROUND_DOWN, _MM_ROUND_UP, _MM_ROUND_TOWARD_ZERO
+    _MM_SET_ROUNDING_MODE(_MM_ROUND_NEAREST);  //_MM_ROUND_NEAREST, _MM_ROUND_DOWN, _MM_ROUND_UP, _MM_ROUND_TOWARD_ZERO
     unsigned int number;
     const unsigned int quarterPoints = num_output_samples / 4;
 
     lv_16sc_t* _result = result;
 
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     __m128 _rem_code_phase, _code_phase_step_chips;
     __m128i _code_length_chips, _code_length_chips_minus1;
     __m128 _code_phase_out, _code_phase_out_with_offset;
     rem_code_phase_chips = rem_code_phase_chips - 0.5f;
 
-    _rem_code_phase =  _mm_load1_ps(&rem_code_phase_chips); //load float to all four float values in m128 register
-    _code_phase_step_chips = _mm_load1_ps(&code_phase_step_chips); //load float to all four float values in m128 register
-    __VOLK_ATTR_ALIGNED(16) int four_times_code_length_chips_minus1[4];
-    four_times_code_length_chips_minus1[0] = code_length_chips-1;
-    four_times_code_length_chips_minus1[1] = code_length_chips-1;
-    four_times_code_length_chips_minus1[2] = code_length_chips-1;
-    four_times_code_length_chips_minus1[3] = code_length_chips-1;
+    _rem_code_phase = _mm_load1_ps(&rem_code_phase_chips);          //load float to all four float values in m128 register
+    _code_phase_step_chips = _mm_load1_ps(&code_phase_step_chips);  //load float to all four float values in m128 register
+    __VOLK_ATTR_ALIGNED(16)
+    int four_times_code_length_chips_minus1[4];
+    four_times_code_length_chips_minus1[0] = code_length_chips - 1;
+    four_times_code_length_chips_minus1[1] = code_length_chips - 1;
+    four_times_code_length_chips_minus1[2] = code_length_chips - 1;
+    four_times_code_length_chips_minus1[3] = code_length_chips - 1;
 
-    __VOLK_ATTR_ALIGNED(16) int four_times_code_length_chips[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int four_times_code_length_chips[4];
     four_times_code_length_chips[0] = code_length_chips;
     four_times_code_length_chips[1] = code_length_chips;
     four_times_code_length_chips[2] = code_length_chips;
     four_times_code_length_chips[3] = code_length_chips;
 
-    _code_length_chips = _mm_loadu_si128((__m128i*)&four_times_code_length_chips); //load float to all four float values in m128 register
-    _code_length_chips_minus1 = _mm_loadu_si128((__m128i*)&four_times_code_length_chips_minus1); //load float to all four float values in m128 register
+    _code_length_chips = _mm_loadu_si128((__m128i*)&four_times_code_length_chips);                //load float to all four float values in m128 register
+    _code_length_chips_minus1 = _mm_loadu_si128((__m128i*)&four_times_code_length_chips_minus1);  //load float to all four float values in m128 register
 
     __m128i negative_indexes, overflow_indexes, _code_phase_out_int, _code_phase_out_int_neg, _code_phase_out_int_over;
 
     __m128i zero = _mm_setzero_si128();
 
-    __VOLK_ATTR_ALIGNED(16) float init_idx_float[4] = { 0.0f, 1.0f, 2.0f, 3.0f };
+    __VOLK_ATTR_ALIGNED(16)
+    float init_idx_float[4] = {0.0f, 1.0f, 2.0f, 3.0f};
     __m128 _4output_index = _mm_loadu_ps(init_idx_float);
-    __VOLK_ATTR_ALIGNED(16) float init_4constant_float[4] = { 4.0f, 4.0f, 4.0f, 4.0f };
+    __VOLK_ATTR_ALIGNED(16)
+    float init_4constant_float[4] = {4.0f, 4.0f, 4.0f, 4.0f};
     __m128 _4constant_float = _mm_loadu_ps(init_4constant_float);
 
-    for(number = 0; number < quarterPoints; number++)
+    for (number = 0; number < quarterPoints; number++)
         {
-            _code_phase_out = _mm_mul_ps(_code_phase_step_chips, _4output_index); //compute the code phase point with the phase step
-            _code_phase_out_with_offset = _mm_add_ps(_code_phase_out, _rem_code_phase); //add the phase offset
-            _code_phase_out_int = _mm_cvtps_epi32(_code_phase_out_with_offset); //convert to integer
+            _code_phase_out = _mm_mul_ps(_code_phase_step_chips, _4output_index);        //compute the code phase point with the phase step
+            _code_phase_out_with_offset = _mm_add_ps(_code_phase_out, _rem_code_phase);  //add the phase offset
+            _code_phase_out_int = _mm_cvtps_epi32(_code_phase_out_with_offset);          //convert to integer
 
-            negative_indexes = _mm_cmplt_epi32(_code_phase_out_int, zero); //test for negative values
-            _code_phase_out_int_neg = _mm_add_epi32(_code_phase_out_int, _code_length_chips); //the negative values branch
-            _code_phase_out_int_neg = _mm_xor_si128(_code_phase_out_int, _mm_and_si128( negative_indexes, _mm_xor_si128( _code_phase_out_int_neg, _code_phase_out_int )));
+            negative_indexes = _mm_cmplt_epi32(_code_phase_out_int, zero);                     //test for negative values
+            _code_phase_out_int_neg = _mm_add_epi32(_code_phase_out_int, _code_length_chips);  //the negative values branch
+            _code_phase_out_int_neg = _mm_xor_si128(_code_phase_out_int, _mm_and_si128(negative_indexes, _mm_xor_si128(_code_phase_out_int_neg, _code_phase_out_int)));
 
-            overflow_indexes = _mm_cmpgt_epi32(_code_phase_out_int_neg, _code_length_chips_minus1); //test for overflow values
-            _code_phase_out_int_over = _mm_sub_epi32(_code_phase_out_int_neg, _code_length_chips); //the negative values branch
-            _code_phase_out_int_over = _mm_xor_si128(_code_phase_out_int_neg, _mm_and_si128( overflow_indexes, _mm_xor_si128( _code_phase_out_int_over, _code_phase_out_int_neg )));
+            overflow_indexes = _mm_cmpgt_epi32(_code_phase_out_int_neg, _code_length_chips_minus1);  //test for overflow values
+            _code_phase_out_int_over = _mm_sub_epi32(_code_phase_out_int_neg, _code_length_chips);   //the negative values branch
+            _code_phase_out_int_over = _mm_xor_si128(_code_phase_out_int_neg, _mm_and_si128(overflow_indexes, _mm_xor_si128(_code_phase_out_int_over, _code_phase_out_int_neg)));
 
-            _mm_storeu_si128((__m128i*)local_code_chip_index, _code_phase_out_int_over); // Store the results back
+            _mm_storeu_si128((__m128i*)local_code_chip_index, _code_phase_out_int_over);  // Store the results back
 
             //todo: optimize the local code lookup table with intrinsics, if possible
             *_result++ = local_code[local_code_chip_index[0]];
@@ -234,7 +244,7 @@ static inline void volk_gnsssdr_16ic_resampler_fast_16ic_u_sse2(lv_16sc_t* resul
             _4output_index = _mm_add_ps(_4output_index, _4constant_float);
         }
 
-    for(number = quarterPoints * 4; number < num_output_samples; number++)
+    for (number = quarterPoints * 4; number < num_output_samples; number++)
         {
             local_code_chip_index[0] = (int)(code_phase_step_chips * (float)number + rem_code_phase_chips + 0.5f);
             if (local_code_chip_index[0] < 0.0) local_code_chip_index[0] += code_length_chips - 1;
@@ -249,7 +259,7 @@ static inline void volk_gnsssdr_16ic_resampler_fast_16ic_u_sse2(lv_16sc_t* resul
 #ifdef LV_HAVE_NEON
 #include <arm_neon.h>
 
-static inline void volk_gnsssdr_16ic_resampler_fast_16ic_neon(lv_16sc_t* result, const lv_16sc_t* local_code, float rem_code_phase_chips, float code_phase_step_chips, int code_length_chips, unsigned int num_output_samples)//, int* scratch_buffer, float* scratch_buffer_float)
+static inline void volk_gnsssdr_16ic_resampler_fast_16ic_neon(lv_16sc_t* result, const lv_16sc_t* local_code, float rem_code_phase_chips, float code_phase_step_chips, int code_length_chips, unsigned int num_output_samples)  //, int* scratch_buffer, float* scratch_buffer_float)
 {
     unsigned int number;
     const unsigned int quarterPoints = num_output_samples / 4;
@@ -257,57 +267,62 @@ static inline void volk_gnsssdr_16ic_resampler_fast_16ic_neon(lv_16sc_t* result,
 
     lv_16sc_t* _result = result;
 
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     float32x4_t _rem_code_phase, _code_phase_step_chips;
     int32x4_t _code_length_chips, _code_length_chips_minus1;
     float32x4_t _code_phase_out, _code_phase_out_with_offset;
     rem_code_phase_chips = rem_code_phase_chips - 0.5f;
     float32x4_t sign, PlusHalf, Round;
 
-    _rem_code_phase =  vld1q_dup_f32(&rem_code_phase_chips); //load float to all four float values in m128 register
-    _code_phase_step_chips = vld1q_dup_f32(&code_phase_step_chips); //load float to all four float values in m128 register
-    __VOLK_ATTR_ALIGNED(16) int four_times_code_length_chips_minus1[4];
+    _rem_code_phase = vld1q_dup_f32(&rem_code_phase_chips);          //load float to all four float values in m128 register
+    _code_phase_step_chips = vld1q_dup_f32(&code_phase_step_chips);  //load float to all four float values in m128 register
+    __VOLK_ATTR_ALIGNED(16)
+    int four_times_code_length_chips_minus1[4];
     four_times_code_length_chips_minus1[0] = code_length_chips - 1;
     four_times_code_length_chips_minus1[1] = code_length_chips - 1;
     four_times_code_length_chips_minus1[2] = code_length_chips - 1;
     four_times_code_length_chips_minus1[3] = code_length_chips - 1;
 
-    __VOLK_ATTR_ALIGNED(16) int four_times_code_length_chips[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int four_times_code_length_chips[4];
     four_times_code_length_chips[0] = code_length_chips;
     four_times_code_length_chips[1] = code_length_chips;
     four_times_code_length_chips[2] = code_length_chips;
     four_times_code_length_chips[3] = code_length_chips;
 
-    _code_length_chips = vld1q_s32((int32_t*)&four_times_code_length_chips); //load float to all four float values in m128 register
-    _code_length_chips_minus1 = vld1q_s32((int32_t*)&four_times_code_length_chips_minus1); //load float to all four float values in m128 register
+    _code_length_chips = vld1q_s32((int32_t*)&four_times_code_length_chips);                //load float to all four float values in m128 register
+    _code_length_chips_minus1 = vld1q_s32((int32_t*)&four_times_code_length_chips_minus1);  //load float to all four float values in m128 register
 
-    int32x4_t  _code_phase_out_int, _code_phase_out_int_neg, _code_phase_out_int_over;
+    int32x4_t _code_phase_out_int, _code_phase_out_int_neg, _code_phase_out_int_over;
     uint32x4_t negative_indexes, overflow_indexes;
     int32x4_t zero = vmovq_n_s32(0);
 
-    __VOLK_ATTR_ALIGNED(16) float init_idx_float[4] = { 0.0f, 1.0f, 2.0f, 3.0f };
+    __VOLK_ATTR_ALIGNED(16)
+    float init_idx_float[4] = {0.0f, 1.0f, 2.0f, 3.0f};
     float32x4_t _4output_index = vld1q_f32(init_idx_float);
-    __VOLK_ATTR_ALIGNED(16) float init_4constant_float[4] = { 4.0f, 4.0f, 4.0f, 4.0f };
+    __VOLK_ATTR_ALIGNED(16)
+    float init_4constant_float[4] = {4.0f, 4.0f, 4.0f, 4.0f};
     float32x4_t _4constant_float = vld1q_f32(init_4constant_float);
 
-    for(number = 0; number < quarterPoints; number++)
+    for (number = 0; number < quarterPoints; number++)
         {
-            _code_phase_out = vmulq_f32(_code_phase_step_chips, _4output_index); //compute the code phase point with the phase step
-            _code_phase_out_with_offset = vaddq_f32(_code_phase_out, _rem_code_phase); //add the phase offset
+            _code_phase_out = vmulq_f32(_code_phase_step_chips, _4output_index);        //compute the code phase point with the phase step
+            _code_phase_out_with_offset = vaddq_f32(_code_phase_out, _rem_code_phase);  //add the phase offset
             sign = vcvtq_f32_u32((vshrq_n_u32(vreinterpretq_u32_f32(_code_phase_out_with_offset), 31)));
             PlusHalf = vaddq_f32(_code_phase_out_with_offset, half);
             Round = vsubq_f32(PlusHalf, sign);
             _code_phase_out_int = vcvtq_s32_f32(Round);
 
-            negative_indexes = vcltq_s32(_code_phase_out_int, zero); //test for negative values
-            _code_phase_out_int_neg = vaddq_s32(_code_phase_out_int, _code_length_chips); //the negative values branch
-            _code_phase_out_int_neg = veorq_s32(_code_phase_out_int, vandq_s32( (int32x4_t)negative_indexes, veorq_s32( _code_phase_out_int_neg, _code_phase_out_int )));
+            negative_indexes = vcltq_s32(_code_phase_out_int, zero);                       //test for negative values
+            _code_phase_out_int_neg = vaddq_s32(_code_phase_out_int, _code_length_chips);  //the negative values branch
+            _code_phase_out_int_neg = veorq_s32(_code_phase_out_int, vandq_s32((int32x4_t)negative_indexes, veorq_s32(_code_phase_out_int_neg, _code_phase_out_int)));
 
-            overflow_indexes = vcgtq_s32(_code_phase_out_int_neg, _code_length_chips_minus1); //test for overflow values
-            _code_phase_out_int_over = vsubq_s32(_code_phase_out_int_neg, _code_length_chips); //the negative values branch
-            _code_phase_out_int_over = veorq_s32(_code_phase_out_int_neg, vandq_s32( (int32x4_t)overflow_indexes, veorq_s32( _code_phase_out_int_over, _code_phase_out_int_neg )));
+            overflow_indexes = vcgtq_s32(_code_phase_out_int_neg, _code_length_chips_minus1);   //test for overflow values
+            _code_phase_out_int_over = vsubq_s32(_code_phase_out_int_neg, _code_length_chips);  //the negative values branch
+            _code_phase_out_int_over = veorq_s32(_code_phase_out_int_neg, vandq_s32((int32x4_t)overflow_indexes, veorq_s32(_code_phase_out_int_over, _code_phase_out_int_neg)));
 
-            vst1q_s32((int32_t*)local_code_chip_index, _code_phase_out_int_over); // Store the results back
+            vst1q_s32((int32_t*)local_code_chip_index, _code_phase_out_int_over);  // Store the results back
 
             //todo: optimize the local code lookup table with intrinsics, if possible
             *_result++ = local_code[local_code_chip_index[0]];
@@ -318,7 +333,7 @@ static inline void volk_gnsssdr_16ic_resampler_fast_16ic_neon(lv_16sc_t* result,
             _4output_index = vaddq_f32(_4output_index, _4constant_float);
         }
 
-    for(number = quarterPoints * 4; number < num_output_samples; number++)
+    for (number = quarterPoints * 4; number < num_output_samples; number++)
         {
             local_code_chip_index[0] = (int)(code_phase_step_chips * (float)number + rem_code_phase_chips + 0.5f);
             if (local_code_chip_index[0] < 0.0) local_code_chip_index[0] += code_length_chips - 1;

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_resamplerfastpuppet_16ic.h

@@ -44,7 +44,7 @@ static inline void volk_gnsssdr_16ic_resamplerfastpuppet_16ic_generic(lv_16sc_t*
     float rem_code_phase_chips = -0.123;
     float code_phase_step_chips = 0.1;
     int code_length_chips = 1023;
-    volk_gnsssdr_16ic_resampler_fast_16ic_generic(result, local_code, rem_code_phase_chips, code_phase_step_chips,  code_length_chips, num_points);
+    volk_gnsssdr_16ic_resampler_fast_16ic_generic(result, local_code, rem_code_phase_chips, code_phase_step_chips, code_length_chips, num_points);
 }
 
 #endif /* LV_HAVE_GENERIC */
@@ -55,7 +55,7 @@ static inline void volk_gnsssdr_16ic_resamplerfastpuppet_16ic_a_sse2(lv_16sc_t*
     float rem_code_phase_chips = -0.123;
     float code_phase_step_chips = 0.1;
     int code_length_chips = 1023;
-    volk_gnsssdr_16ic_resampler_fast_16ic_a_sse2(result, local_code, rem_code_phase_chips, code_phase_step_chips, code_length_chips, num_points );
+    volk_gnsssdr_16ic_resampler_fast_16ic_a_sse2(result, local_code, rem_code_phase_chips, code_phase_step_chips, code_length_chips, num_points);
 }
 
 #endif /* LV_HAVE_SSE2 */
@@ -67,7 +67,7 @@ static inline void volk_gnsssdr_16ic_resamplerfastpuppet_16ic_u_sse2(lv_16sc_t*
     float rem_code_phase_chips = -0.123;
     float code_phase_step_chips = 0.1;
     int code_length_chips = 1023;
-    volk_gnsssdr_16ic_resampler_fast_16ic_u_sse2(result, local_code, rem_code_phase_chips, code_phase_step_chips, code_length_chips, num_points );
+    volk_gnsssdr_16ic_resampler_fast_16ic_u_sse2(result, local_code, rem_code_phase_chips, code_phase_step_chips, code_length_chips, num_points);
 }
 
 #endif /* LV_HAVE_SSE2 */
@@ -79,9 +79,9 @@ static inline void volk_gnsssdr_16ic_resamplerfastpuppet_16ic_neon(lv_16sc_t* re
     float rem_code_phase_chips = -0.123;
     float code_phase_step_chips = 0.1;
     int code_length_chips = 1023;
-    volk_gnsssdr_16ic_resampler_fast_16ic_neon(result, local_code, rem_code_phase_chips, code_phase_step_chips, code_length_chips, num_points );
+    volk_gnsssdr_16ic_resampler_fast_16ic_neon(result, local_code, rem_code_phase_chips, code_phase_step_chips, code_length_chips, num_points);
 }
 
 #endif /* LV_HAVE_NEON */
 
-#endif // INCLUDED_volk_gnsssdr_16ic_resamplerfastpuppet_16ic_H
+#endif  // INCLUDED_volk_gnsssdr_16ic_resamplerfastpuppet_16ic_H

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_resamplerfastxnpuppet_16ic.h

@@ -49,21 +49,21 @@ static inline void volk_gnsssdr_16ic_resamplerfastxnpuppet_16ic_generic(lv_16sc_
     int num_out_vectors = 3;
     unsigned int n;
     float* rem_code_phase_chips = (float*)volk_gnsssdr_malloc(sizeof(float) * num_out_vectors, volk_gnsssdr_get_alignment());
-    lv_16sc_t** result_aux =  (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    lv_16sc_t** result_aux = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       rem_code_phase_chips[n] = -0.234; 
-       result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            rem_code_phase_chips[n] = -0.234;
+            result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
     volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn_generic(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((lv_16sc_t*)result, (lv_16sc_t*)result_aux[0], sizeof(lv_16sc_t) * num_points);
     volk_gnsssdr_free(rem_code_phase_chips);
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -77,22 +77,22 @@ static inline void volk_gnsssdr_16ic_resamplerfastxnpuppet_16ic_a_sse2(lv_16sc_t
     int code_length_chips = 2046;
     int num_out_vectors = 3;
     unsigned int n;
-    float * rem_code_phase_chips = (float*)volk_gnsssdr_malloc(sizeof(float) * num_out_vectors, volk_gnsssdr_get_alignment());
-    lv_16sc_t** result_aux =  (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    float* rem_code_phase_chips = (float*)volk_gnsssdr_malloc(sizeof(float) * num_out_vectors, volk_gnsssdr_get_alignment());
+    lv_16sc_t** result_aux = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        rem_code_phase_chips[n] = -0.234; 
-        result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            rem_code_phase_chips[n] = -0.234;
+            result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
     volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn_a_sse2(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy(result, result_aux[0], sizeof(lv_16sc_t) * num_points);
     volk_gnsssdr_free(rem_code_phase_chips);
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -106,22 +106,22 @@ static inline void volk_gnsssdr_16ic_resamplerfastxnpuppet_16ic_u_sse2(lv_16sc_t
     int code_length_chips = 2046;
     int num_out_vectors = 3;
     unsigned int n;
-    float * rem_code_phase_chips = (float*)volk_gnsssdr_malloc(sizeof(float) * num_out_vectors, volk_gnsssdr_get_alignment());
-    lv_16sc_t** result_aux =  (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    float* rem_code_phase_chips = (float*)volk_gnsssdr_malloc(sizeof(float) * num_out_vectors, volk_gnsssdr_get_alignment());
+    lv_16sc_t** result_aux = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        rem_code_phase_chips[n] = -0.234;
-        result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            rem_code_phase_chips[n] = -0.234;
+            result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
     volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn_u_sse2(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy(result, result_aux[0], sizeof(lv_16sc_t) * num_points);
     volk_gnsssdr_free(rem_code_phase_chips);
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -135,26 +135,26 @@ static inline void volk_gnsssdr_16ic_resamplerfastxnpuppet_16ic_neon(lv_16sc_t*
     int code_length_chips = 2046;
     int num_out_vectors = 3;
     unsigned int n;
-    float * rem_code_phase_chips = (float*)volk_gnsssdr_malloc(sizeof(float) * num_out_vectors, volk_gnsssdr_get_alignment());
-    lv_16sc_t** result_aux =  (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    float* rem_code_phase_chips = (float*)volk_gnsssdr_malloc(sizeof(float) * num_out_vectors, volk_gnsssdr_get_alignment());
+    lv_16sc_t** result_aux = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        rem_code_phase_chips[n] = -0.234;
-        result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            rem_code_phase_chips[n] = -0.234;
+            result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
     volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn_neon(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy(result, result_aux[0], sizeof(lv_16sc_t) * num_points);
     volk_gnsssdr_free(rem_code_phase_chips);
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
 #endif
 
 
-#endif // INCLUDED_volk_gnsssdr_16ic_resamplerpuppet_16ic_H
+#endif  // INCLUDED_volk_gnsssdr_16ic_resamplerpuppet_16ic_H

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_resamplerxnpuppet_16ic.h

@@ -45,26 +45,26 @@
 static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_generic(lv_16sc_t* result, const lv_16sc_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     unsigned int n;
     float rem_code_phase_chips = -0.234;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1  };
-    lv_16sc_t** result_aux =  (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
+    lv_16sc_t** result_aux = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_16ic_xn_resampler_16ic_xn_generic(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((lv_16sc_t*)result, (lv_16sc_t*)result_aux[0], sizeof(lv_16sc_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -75,26 +75,26 @@ static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_generic(lv_16sc_t* r
 static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_a_sse3(lv_16sc_t* result, const lv_16sc_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
-    lv_16sc_t** result_aux =  (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
+    lv_16sc_t** result_aux = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_16ic_xn_resampler_16ic_xn_a_sse3(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((lv_16sc_t*)result, (lv_16sc_t*)result_aux[0], sizeof(lv_16sc_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -104,26 +104,26 @@ static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_a_sse3(lv_16sc_t* re
 static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_u_sse3(lv_16sc_t* result, const lv_16sc_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
-    lv_16sc_t** result_aux =  (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
+    lv_16sc_t** result_aux = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_16ic_xn_resampler_16ic_xn_u_sse3(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((lv_16sc_t*)result, (lv_16sc_t*)result_aux[0], sizeof(lv_16sc_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -134,26 +134,26 @@ static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_u_sse3(lv_16sc_t* re
 static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_u_sse4_1(lv_16sc_t* result, const lv_16sc_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
-    lv_16sc_t** result_aux =  (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
+    lv_16sc_t** result_aux = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_16ic_xn_resampler_16ic_xn_u_sse4_1(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((lv_16sc_t*)result, (lv_16sc_t*)result_aux[0], sizeof(lv_16sc_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -164,26 +164,26 @@ static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_u_sse4_1(lv_16sc_t*
 static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_a_sse4_1(lv_16sc_t* result, const lv_16sc_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
-    lv_16sc_t** result_aux =  (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
+    lv_16sc_t** result_aux = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_16ic_xn_resampler_16ic_xn_a_sse4_1(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((lv_16sc_t*)result, (lv_16sc_t*)result_aux[0], sizeof(lv_16sc_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -194,26 +194,26 @@ static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_a_sse4_1(lv_16sc_t*
 static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_u_avx(lv_16sc_t* result, const lv_16sc_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
-    lv_16sc_t** result_aux =  (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
+    lv_16sc_t** result_aux = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_16ic_xn_resampler_16ic_xn_u_avx(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((lv_16sc_t*)result, (lv_16sc_t*)result_aux[0], sizeof(lv_16sc_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -224,26 +224,26 @@ static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_u_avx(lv_16sc_t* res
 static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_a_avx(lv_16sc_t* result, const lv_16sc_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
-    lv_16sc_t** result_aux =  (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
+    lv_16sc_t** result_aux = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_16ic_xn_resampler_16ic_xn_a_avx(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((lv_16sc_t*)result, (lv_16sc_t*)result_aux[0], sizeof(lv_16sc_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -254,29 +254,29 @@ static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_a_avx(lv_16sc_t* res
 static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_neon(lv_16sc_t* result, const lv_16sc_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
-    lv_16sc_t** result_aux =  (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
+    lv_16sc_t** result_aux = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_16ic_xn_resampler_16ic_xn_neon(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((lv_16sc_t*)result, (lv_16sc_t*)result_aux[0], sizeof(lv_16sc_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
 #endif
 
-#endif // INCLUDED_volk_gnsssdr_16ic_resamplerpuppet_16ic_H
+#endif  // INCLUDED_volk_gnsssdr_16ic_resamplerpuppet_16ic_H

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_s32fc_x2_rotator_16ic.h

@@ -70,7 +70,7 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_generic(lv_16sc_t* ou
     unsigned int i = 0;
     lv_16sc_t tmp16;
     lv_32fc_t tmp32;
-    for(i = 0; i < (unsigned int)(num_points); ++i)
+    for (i = 0; i < (unsigned int)(num_points); ++i)
         {
             tmp16 = *inVector++;
             tmp32 = lv_cmake((float)lv_creal(tmp16), (float)lv_cimag(tmp16)) * (*phase);
@@ -111,8 +111,8 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_generic_reload(lv_16s
                     *outVector++ = lv_cmake((int16_t)rintf(lv_creal(tmp32)), (int16_t)rintf(lv_cimag(tmp32)));
                     (*phase) *= phase_inc;
                 }
-            // Regenerate phase
-            //printf("Phase before regeneration %i: %f,%f  Modulus: %f\n", n,lv_creal(*phase),lv_cimag(*phase), cabsf(*phase));
+                // Regenerate phase
+                //printf("Phase before regeneration %i: %f,%f  Modulus: %f\n", n,lv_creal(*phase),lv_cimag(*phase), cabsf(*phase));
 #ifdef __cplusplus
             (*phase) /= std::abs((*phase));
 #else
@@ -141,11 +141,13 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_a_sse3(lv_16sc_t* out
     unsigned int number;
     __m128 a, b, two_phase_acc_reg, two_phase_inc_reg;
     __m128i c1, c2, result;
-    __VOLK_ATTR_ALIGNED(16) lv_32fc_t two_phase_inc[2];
+    __VOLK_ATTR_ALIGNED(16)
+    lv_32fc_t two_phase_inc[2];
     two_phase_inc[0] = phase_inc * phase_inc;
     two_phase_inc[1] = phase_inc * phase_inc;
-    two_phase_inc_reg = _mm_load_ps((float*) two_phase_inc);
-    __VOLK_ATTR_ALIGNED(16) lv_32fc_t two_phase_acc[2];
+    two_phase_inc_reg = _mm_load_ps((float*)two_phase_inc);
+    __VOLK_ATTR_ALIGNED(16)
+    lv_32fc_t two_phase_acc[2];
     two_phase_acc[0] = (*phase);
     two_phase_acc[1] = (*phase) * phase_inc;
     two_phase_acc_reg = _mm_load_ps((float*)two_phase_acc);
@@ -157,49 +159,49 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_a_sse3(lv_16sc_t* out
     lv_16sc_t tmp16;
     lv_32fc_t tmp32;
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
-            a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+            a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0])));  // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
             //complex 32fc multiplication b=a*two_phase_acc_reg
-            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-            yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-            tmp1 = _mm_mul_ps(a, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-            a = _mm_shuffle_ps(a, a, 0xB1); // Re-arrange x to be ai,ar,bi,br
-            tmp2 = _mm_mul_ps(a, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-            b = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
-            c1 = _mm_cvtps_epi32(b); // convert from 32fc to 32ic
+            yl = _mm_moveldup_ps(two_phase_acc_reg);  // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg);  // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(a, yl);                 // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            a = _mm_shuffle_ps(a, a, 0xB1);           // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(a, yh);                 // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            b = _mm_addsub_ps(tmp1, tmp2);            // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            c1 = _mm_cvtps_epi32(b);                  // convert from 32fc to 32ic
 
             //complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
-            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-            yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-            tmp1 = _mm_mul_ps(two_phase_inc_reg, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-            tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1); // Re-arrange x to be ai,ar,bi,br
-            tmp2 = _mm_mul_ps(tmp3, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-            two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            yl = _mm_moveldup_ps(two_phase_acc_reg);                            // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg);                            // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(two_phase_inc_reg, yl);                           // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1);  // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(tmp3, yh);                                        // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2);                      // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
 
             //next two samples
             _in += 2;
-            a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+            a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0])));  // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
             __VOLK_GNSSSDR_PREFETCH(_in + 8);
             //complex 32fc multiplication b=a*two_phase_acc_reg
-            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-            yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-            tmp1 = _mm_mul_ps(a, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-            a = _mm_shuffle_ps(a, a, 0xB1); // Re-arrange x to be ai,ar,bi,br
-            tmp2 = _mm_mul_ps(a, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-            b = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
-            c2 = _mm_cvtps_epi32(b); // convert from 32fc to 32ic
+            yl = _mm_moveldup_ps(two_phase_acc_reg);  // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg);  // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(a, yl);                 // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            a = _mm_shuffle_ps(a, a, 0xB1);           // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(a, yh);                 // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            b = _mm_addsub_ps(tmp1, tmp2);            // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            c2 = _mm_cvtps_epi32(b);                  // convert from 32fc to 32ic
 
             //complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
-            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-            yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-            tmp1 = _mm_mul_ps(two_phase_inc_reg, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-            tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1); // Re-arrange x to be ai,ar,bi,br
-            tmp2 = _mm_mul_ps(tmp3, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-            two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            yl = _mm_moveldup_ps(two_phase_acc_reg);                            // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg);                            // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(two_phase_inc_reg, yl);                           // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1);  // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(tmp3, yh);                                        // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2);                      // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
 
             // store four output samples
-            result = _mm_packs_epi32(c1, c2);// convert from 32ic to 16ic
+            result = _mm_packs_epi32(c1, c2);  // convert from 32ic to 16ic
             _mm_store_si128((__m128i*)_out, result);
 
             // Regenerate phase
@@ -232,7 +234,6 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_a_sse3(lv_16sc_t* out
 #endif /* LV_HAVE_SSE3 */
 
 
-
 #ifdef LV_HAVE_SSE3
 #include <pmmintrin.h>
 
@@ -244,11 +245,13 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_a_sse3_reload(lv_16sc
     unsigned int j;
     __m128 a, b, two_phase_acc_reg, two_phase_inc_reg;
     __m128i c1, c2, result;
-    __VOLK_ATTR_ALIGNED(16) lv_32fc_t two_phase_inc[2];
+    __VOLK_ATTR_ALIGNED(16)
+    lv_32fc_t two_phase_inc[2];
     two_phase_inc[0] = phase_inc * phase_inc;
     two_phase_inc[1] = phase_inc * phase_inc;
-    two_phase_inc_reg = _mm_load_ps((float*) two_phase_inc);
-    __VOLK_ATTR_ALIGNED(16) lv_32fc_t two_phase_acc[2];
+    two_phase_inc_reg = _mm_load_ps((float*)two_phase_inc);
+    __VOLK_ATTR_ALIGNED(16)
+    lv_32fc_t two_phase_acc[2];
     two_phase_acc[0] = (*phase);
     two_phase_acc[1] = (*phase) * phase_inc;
     two_phase_acc_reg = _mm_load_ps((float*)two_phase_acc);
@@ -265,47 +268,47 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_a_sse3_reload(lv_16sc
         {
             for (j = 0; j < ROTATOR_RELOAD; j++)
                 {
-                    a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+                    a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0])));  // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
                     //complex 32fc multiplication b=a*two_phase_acc_reg
-                    yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-                    yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-                    tmp1 = _mm_mul_ps(a, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-                    a = _mm_shuffle_ps(a, a, 0xB1); // Re-arrange x to be ai,ar,bi,br
-                    tmp2 = _mm_mul_ps(a, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-                    b = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
-                    c1 = _mm_cvtps_epi32(b); // convert from 32fc to 32ic
+                    yl = _mm_moveldup_ps(two_phase_acc_reg);  // Load yl with cr,cr,dr,dr
+                    yh = _mm_movehdup_ps(two_phase_acc_reg);  // Load yh with ci,ci,di,di
+                    tmp1 = _mm_mul_ps(a, yl);                 // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+                    a = _mm_shuffle_ps(a, a, 0xB1);           // Re-arrange x to be ai,ar,bi,br
+                    tmp2 = _mm_mul_ps(a, yh);                 // tmp2 = ai*ci,ar*ci,bi*di,br*di
+                    b = _mm_addsub_ps(tmp1, tmp2);            // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+                    c1 = _mm_cvtps_epi32(b);                  // convert from 32fc to 32ic
 
                     //complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
-                    yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-                    yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-                    tmp1 = _mm_mul_ps(two_phase_inc_reg, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-                    tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1); // Re-arrange x to be ai,ar,bi,br
-                    tmp2 = _mm_mul_ps(tmp3, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-                    two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+                    yl = _mm_moveldup_ps(two_phase_acc_reg);                            // Load yl with cr,cr,dr,dr
+                    yh = _mm_movehdup_ps(two_phase_acc_reg);                            // Load yh with ci,ci,di,di
+                    tmp1 = _mm_mul_ps(two_phase_inc_reg, yl);                           // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+                    tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1);  // Re-arrange x to be ai,ar,bi,br
+                    tmp2 = _mm_mul_ps(tmp3, yh);                                        // tmp2 = ai*ci,ar*ci,bi*di,br*di
+                    two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2);                      // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
 
                     //next two samples
                     _in += 2;
-                    a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+                    a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0])));  // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
                     __VOLK_GNSSSDR_PREFETCH(_in + 8);
                     //complex 32fc multiplication b=a*two_phase_acc_reg
-                    yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-                    yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-                    tmp1 = _mm_mul_ps(a, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-                    a = _mm_shuffle_ps(a, a, 0xB1); // Re-arrange x to be ai,ar,bi,br
-                    tmp2 = _mm_mul_ps(a, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-                    b = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
-                    c2 = _mm_cvtps_epi32(b); // convert from 32fc to 32ic
+                    yl = _mm_moveldup_ps(two_phase_acc_reg);  // Load yl with cr,cr,dr,dr
+                    yh = _mm_movehdup_ps(two_phase_acc_reg);  // Load yh with ci,ci,di,di
+                    tmp1 = _mm_mul_ps(a, yl);                 // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+                    a = _mm_shuffle_ps(a, a, 0xB1);           // Re-arrange x to be ai,ar,bi,br
+                    tmp2 = _mm_mul_ps(a, yh);                 // tmp2 = ai*ci,ar*ci,bi*di,br*di
+                    b = _mm_addsub_ps(tmp1, tmp2);            // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+                    c2 = _mm_cvtps_epi32(b);                  // convert from 32fc to 32ic
 
                     //complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
-                    yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-                    yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-                    tmp1 = _mm_mul_ps(two_phase_inc_reg, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-                    tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1); // Re-arrange x to be ai,ar,bi,br
-                    tmp2 = _mm_mul_ps(tmp3, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-                    two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+                    yl = _mm_moveldup_ps(two_phase_acc_reg);                            // Load yl with cr,cr,dr,dr
+                    yh = _mm_movehdup_ps(two_phase_acc_reg);                            // Load yh with ci,ci,di,di
+                    tmp1 = _mm_mul_ps(two_phase_inc_reg, yl);                           // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+                    tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1);  // Re-arrange x to be ai,ar,bi,br
+                    tmp2 = _mm_mul_ps(tmp3, yh);                                        // tmp2 = ai*ci,ar*ci,bi*di,br*di
+                    two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2);                      // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
 
                     // store four output samples
-                    result = _mm_packs_epi32(c1, c2);// convert from 32ic to 16ic
+                    result = _mm_packs_epi32(c1, c2);  // convert from 32ic to 16ic
                     _mm_store_si128((__m128i*)_out, result);
 
                     //next two samples
@@ -322,47 +325,47 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_a_sse3_reload(lv_16sc
 
     for (j = 0; j < sse_iters % ROTATOR_RELOAD; j++)
         {
-            a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+            a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0])));  // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
             //complex 32fc multiplication b=a*two_phase_acc_reg
-            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-            yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-            tmp1 = _mm_mul_ps(a, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-            a = _mm_shuffle_ps(a, a, 0xB1); // Re-arrange x to be ai,ar,bi,br
-            tmp2 = _mm_mul_ps(a, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-            b = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
-            c1 = _mm_cvtps_epi32(b); // convert from 32fc to 32ic
+            yl = _mm_moveldup_ps(two_phase_acc_reg);  // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg);  // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(a, yl);                 // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            a = _mm_shuffle_ps(a, a, 0xB1);           // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(a, yh);                 // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            b = _mm_addsub_ps(tmp1, tmp2);            // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            c1 = _mm_cvtps_epi32(b);                  // convert from 32fc to 32ic
 
             //complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
-            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-            yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-            tmp1 = _mm_mul_ps(two_phase_inc_reg, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-            tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1); // Re-arrange x to be ai,ar,bi,br
-            tmp2 = _mm_mul_ps(tmp3, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-            two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            yl = _mm_moveldup_ps(two_phase_acc_reg);                            // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg);                            // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(two_phase_inc_reg, yl);                           // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1);  // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(tmp3, yh);                                        // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2);                      // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
 
             //next two samples
             _in += 2;
-            a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+            a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0])));  // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
             __VOLK_GNSSSDR_PREFETCH(_in + 8);
             //complex 32fc multiplication b=a*two_phase_acc_reg
-            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-            yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-            tmp1 = _mm_mul_ps(a, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-            a = _mm_shuffle_ps(a, a, 0xB1); // Re-arrange x to be ai,ar,bi,br
-            tmp2 = _mm_mul_ps(a, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-            b = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
-            c2 = _mm_cvtps_epi32(b); // convert from 32fc to 32ic
+            yl = _mm_moveldup_ps(two_phase_acc_reg);  // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg);  // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(a, yl);                 // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            a = _mm_shuffle_ps(a, a, 0xB1);           // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(a, yh);                 // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            b = _mm_addsub_ps(tmp1, tmp2);            // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            c2 = _mm_cvtps_epi32(b);                  // convert from 32fc to 32ic
 
             //complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
-            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-            yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-            tmp1 = _mm_mul_ps(two_phase_inc_reg, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-            tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1); // Re-arrange x to be ai,ar,bi,br
-            tmp2 = _mm_mul_ps(tmp3, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-            two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            yl = _mm_moveldup_ps(two_phase_acc_reg);                            // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg);                            // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(two_phase_inc_reg, yl);                           // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1);  // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(tmp3, yh);                                        // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2);                      // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
 
             // store four output samples
-            result = _mm_packs_epi32(c1, c2);// convert from 32ic to 16ic
+            result = _mm_packs_epi32(c1, c2);  // convert from 32ic to 16ic
             _mm_store_si128((__m128i*)_out, result);
 
             //next two samples
@@ -385,7 +388,6 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_a_sse3_reload(lv_16sc
 #endif /* LV_HAVE_SSE3 */
 
 
-
 #ifdef LV_HAVE_SSE3
 #include <pmmintrin.h>
 
@@ -395,14 +397,16 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_u_sse3(lv_16sc_t* out
     unsigned int number;
     __m128 a, b, two_phase_acc_reg, two_phase_inc_reg;
     __m128i c1, c2, result;
-    __VOLK_ATTR_ALIGNED(16) lv_32fc_t two_phase_inc[2];
+    __VOLK_ATTR_ALIGNED(16)
+    lv_32fc_t two_phase_inc[2];
     two_phase_inc[0] = phase_inc * phase_inc;
     two_phase_inc[1] = phase_inc * phase_inc;
-    two_phase_inc_reg = _mm_load_ps((float*) two_phase_inc);
-    __VOLK_ATTR_ALIGNED(16) lv_32fc_t two_phase_acc[2];
+    two_phase_inc_reg = _mm_load_ps((float*)two_phase_inc);
+    __VOLK_ATTR_ALIGNED(16)
+    lv_32fc_t two_phase_acc[2];
     two_phase_acc[0] = (*phase);
     two_phase_acc[1] = (*phase) * phase_inc;
-    two_phase_acc_reg = _mm_load_ps((float*) two_phase_acc);
+    two_phase_acc_reg = _mm_load_ps((float*)two_phase_acc);
 
     const lv_16sc_t* _in = inVector;
 
@@ -412,49 +416,49 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_u_sse3(lv_16sc_t* out
     lv_16sc_t tmp16;
     lv_32fc_t tmp32;
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
-            a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+            a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0])));  // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
             //complex 32fc multiplication b=a*two_phase_acc_reg
-            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-            yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-            tmp1 = _mm_mul_ps(a, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-            a = _mm_shuffle_ps(a, a, 0xB1); // Re-arrange x to be ai,ar,bi,br
-            tmp2 = _mm_mul_ps(a, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-            b = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
-            c1 = _mm_cvtps_epi32(b); // convert from 32fc to 32ic
+            yl = _mm_moveldup_ps(two_phase_acc_reg);  // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg);  // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(a, yl);                 // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            a = _mm_shuffle_ps(a, a, 0xB1);           // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(a, yh);                 // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            b = _mm_addsub_ps(tmp1, tmp2);            // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            c1 = _mm_cvtps_epi32(b);                  // convert from 32fc to 32ic
 
             //complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
-            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-            yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-            tmp1 = _mm_mul_ps(two_phase_inc_reg, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-            tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1); // Re-arrange x to be ai,ar,bi,br
-            tmp2 = _mm_mul_ps(tmp3, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-            two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            yl = _mm_moveldup_ps(two_phase_acc_reg);                            // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg);                            // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(two_phase_inc_reg, yl);                           // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1);  // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(tmp3, yh);                                        // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2);                      // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
 
             //next two samples
             _in += 2;
-            a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+            a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0])));  // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
             __VOLK_GNSSSDR_PREFETCH(_in + 8);
             //complex 32fc multiplication b=a*two_phase_acc_reg
-            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-            yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-            tmp1 = _mm_mul_ps(a, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-            a = _mm_shuffle_ps(a, a, 0xB1); // Re-arrange x to be ai,ar,bi,br
-            tmp2 = _mm_mul_ps(a, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-            b = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
-            c2 = _mm_cvtps_epi32(b); // convert from 32fc to 32ic
+            yl = _mm_moveldup_ps(two_phase_acc_reg);  // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg);  // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(a, yl);                 // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            a = _mm_shuffle_ps(a, a, 0xB1);           // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(a, yh);                 // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            b = _mm_addsub_ps(tmp1, tmp2);            // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            c2 = _mm_cvtps_epi32(b);                  // convert from 32fc to 32ic
 
             //complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
-            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-            yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-            tmp1 = _mm_mul_ps(two_phase_inc_reg, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-            tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1); // Re-arrange x to be ai,ar,bi,br
-            tmp2 = _mm_mul_ps(tmp3, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-            two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            yl = _mm_moveldup_ps(two_phase_acc_reg);                            // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg);                            // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(two_phase_inc_reg, yl);                           // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1);  // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(tmp3, yh);                                        // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2);                      // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
 
             // store four output samples
-            result = _mm_packs_epi32(c1, c2);// convert from 32ic to 16ic
+            result = _mm_packs_epi32(c1, c2);  // convert from 32ic to 16ic
             _mm_storeu_si128((__m128i*)_out, result);
 
             // Regenerate phase
@@ -493,147 +497,149 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_u_sse3(lv_16sc_t* out
 static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_u_sse3_reload(lv_16sc_t* outVector, const lv_16sc_t* inVector, const lv_32fc_t phase_inc, lv_32fc_t* phase, unsigned int num_points)
 {
     const unsigned int sse_iters = num_points / 4;
-     unsigned int ROTATOR_RELOAD = 512;
-     unsigned int n;
-     unsigned int j;
-     __m128 a, b, two_phase_acc_reg, two_phase_inc_reg;
-     __m128i c1, c2, result;
-     __VOLK_ATTR_ALIGNED(16) lv_32fc_t two_phase_inc[2];
-     two_phase_inc[0] = phase_inc * phase_inc;
-     two_phase_inc[1] = phase_inc * phase_inc;
-     two_phase_inc_reg = _mm_load_ps((float*) two_phase_inc);
-     __VOLK_ATTR_ALIGNED(16) lv_32fc_t two_phase_acc[2];
-     two_phase_acc[0] = (*phase);
-     two_phase_acc[1] = (*phase) * phase_inc;
-     two_phase_acc_reg = _mm_load_ps((float*) two_phase_acc);
+    unsigned int ROTATOR_RELOAD = 512;
+    unsigned int n;
+    unsigned int j;
+    __m128 a, b, two_phase_acc_reg, two_phase_inc_reg;
+    __m128i c1, c2, result;
+    __VOLK_ATTR_ALIGNED(16)
+    lv_32fc_t two_phase_inc[2];
+    two_phase_inc[0] = phase_inc * phase_inc;
+    two_phase_inc[1] = phase_inc * phase_inc;
+    two_phase_inc_reg = _mm_load_ps((float*)two_phase_inc);
+    __VOLK_ATTR_ALIGNED(16)
+    lv_32fc_t two_phase_acc[2];
+    two_phase_acc[0] = (*phase);
+    two_phase_acc[1] = (*phase) * phase_inc;
+    two_phase_acc_reg = _mm_load_ps((float*)two_phase_acc);
 
-     const lv_16sc_t* _in = inVector;
+    const lv_16sc_t* _in = inVector;
 
-     lv_16sc_t* _out = outVector;
+    lv_16sc_t* _out = outVector;
 
-     __m128 yl, yh, tmp1, tmp2, tmp3;
-     lv_16sc_t tmp16;
-     lv_32fc_t tmp32;
+    __m128 yl, yh, tmp1, tmp2, tmp3;
+    lv_16sc_t tmp16;
+    lv_32fc_t tmp32;
 
-     for (n = 0; n < sse_iters / ROTATOR_RELOAD; n++)
-         {
-             for (j = 0; j < ROTATOR_RELOAD; j++)
-                 {
-                     a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
-                     //complex 32fc multiplication b=a*two_phase_acc_reg
-                     yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-                     yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-                     tmp1 = _mm_mul_ps(a, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-                     a = _mm_shuffle_ps(a, a, 0xB1); // Re-arrange x to be ai,ar,bi,br
-                     tmp2 = _mm_mul_ps(a, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-                     b = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
-                     c1 = _mm_cvtps_epi32(b); // convert from 32fc to 32ic
+    for (n = 0; n < sse_iters / ROTATOR_RELOAD; n++)
+        {
+            for (j = 0; j < ROTATOR_RELOAD; j++)
+                {
+                    a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0])));  // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+                    //complex 32fc multiplication b=a*two_phase_acc_reg
+                    yl = _mm_moveldup_ps(two_phase_acc_reg);  // Load yl with cr,cr,dr,dr
+                    yh = _mm_movehdup_ps(two_phase_acc_reg);  // Load yh with ci,ci,di,di
+                    tmp1 = _mm_mul_ps(a, yl);                 // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+                    a = _mm_shuffle_ps(a, a, 0xB1);           // Re-arrange x to be ai,ar,bi,br
+                    tmp2 = _mm_mul_ps(a, yh);                 // tmp2 = ai*ci,ar*ci,bi*di,br*di
+                    b = _mm_addsub_ps(tmp1, tmp2);            // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+                    c1 = _mm_cvtps_epi32(b);                  // convert from 32fc to 32ic
 
-                     //complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
-                     yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-                     yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-                     tmp1 = _mm_mul_ps(two_phase_inc_reg, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-                     tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1); // Re-arrange x to be ai,ar,bi,br
-                     tmp2 = _mm_mul_ps(tmp3, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-                     two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+                    //complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
+                    yl = _mm_moveldup_ps(two_phase_acc_reg);                            // Load yl with cr,cr,dr,dr
+                    yh = _mm_movehdup_ps(two_phase_acc_reg);                            // Load yh with ci,ci,di,di
+                    tmp1 = _mm_mul_ps(two_phase_inc_reg, yl);                           // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+                    tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1);  // Re-arrange x to be ai,ar,bi,br
+                    tmp2 = _mm_mul_ps(tmp3, yh);                                        // tmp2 = ai*ci,ar*ci,bi*di,br*di
+                    two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2);                      // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
 
-                     //next two samples
-                     _in += 2;
-                     a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
-                     __VOLK_GNSSSDR_PREFETCH(_in + 8);
-                     //complex 32fc multiplication b=a*two_phase_acc_reg
-                     yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-                     yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-                     tmp1 = _mm_mul_ps(a, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-                     a = _mm_shuffle_ps(a, a, 0xB1); // Re-arrange x to be ai,ar,bi,br
-                     tmp2 = _mm_mul_ps(a, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-                     b = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
-                     c2 = _mm_cvtps_epi32(b); // convert from 32fc to 32ic
+                    //next two samples
+                    _in += 2;
+                    a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0])));  // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+                    __VOLK_GNSSSDR_PREFETCH(_in + 8);
+                    //complex 32fc multiplication b=a*two_phase_acc_reg
+                    yl = _mm_moveldup_ps(two_phase_acc_reg);  // Load yl with cr,cr,dr,dr
+                    yh = _mm_movehdup_ps(two_phase_acc_reg);  // Load yh with ci,ci,di,di
+                    tmp1 = _mm_mul_ps(a, yl);                 // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+                    a = _mm_shuffle_ps(a, a, 0xB1);           // Re-arrange x to be ai,ar,bi,br
+                    tmp2 = _mm_mul_ps(a, yh);                 // tmp2 = ai*ci,ar*ci,bi*di,br*di
+                    b = _mm_addsub_ps(tmp1, tmp2);            // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+                    c2 = _mm_cvtps_epi32(b);                  // convert from 32fc to 32ic
 
-                     //complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
-                     yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-                     yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-                     tmp1 = _mm_mul_ps(two_phase_inc_reg, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-                     tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1); // Re-arrange x to be ai,ar,bi,br
-                     tmp2 = _mm_mul_ps(tmp3, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-                     two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+                    //complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
+                    yl = _mm_moveldup_ps(two_phase_acc_reg);                            // Load yl with cr,cr,dr,dr
+                    yh = _mm_movehdup_ps(two_phase_acc_reg);                            // Load yh with ci,ci,di,di
+                    tmp1 = _mm_mul_ps(two_phase_inc_reg, yl);                           // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+                    tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1);  // Re-arrange x to be ai,ar,bi,br
+                    tmp2 = _mm_mul_ps(tmp3, yh);                                        // tmp2 = ai*ci,ar*ci,bi*di,br*di
+                    two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2);                      // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
 
-                     // store four output samples
-                     result = _mm_packs_epi32(c1, c2);// convert from 32ic to 16ic
-                     _mm_storeu_si128((__m128i*)_out, result);
+                    // store four output samples
+                    result = _mm_packs_epi32(c1, c2);  // convert from 32ic to 16ic
+                    _mm_storeu_si128((__m128i*)_out, result);
 
-                     //next two samples
-                     _in += 2;
-                     _out += 4;
-                 }
-             // Regenerate phase
-             tmp1 = _mm_mul_ps(two_phase_acc_reg, two_phase_acc_reg);
-             tmp2 = _mm_hadd_ps(tmp1, tmp1);
-             tmp1 = _mm_shuffle_ps(tmp2, tmp2, 0xD8);
-             tmp2 = _mm_sqrt_ps(tmp1);
-             two_phase_acc_reg = _mm_div_ps(two_phase_acc_reg, tmp2);
-         }
+                    //next two samples
+                    _in += 2;
+                    _out += 4;
+                }
+            // Regenerate phase
+            tmp1 = _mm_mul_ps(two_phase_acc_reg, two_phase_acc_reg);
+            tmp2 = _mm_hadd_ps(tmp1, tmp1);
+            tmp1 = _mm_shuffle_ps(tmp2, tmp2, 0xD8);
+            tmp2 = _mm_sqrt_ps(tmp1);
+            two_phase_acc_reg = _mm_div_ps(two_phase_acc_reg, tmp2);
+        }
 
-     for (j = 0; j < sse_iters % ROTATOR_RELOAD; j++)
-         {
-             a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
-             //complex 32fc multiplication b=a*two_phase_acc_reg
-             yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-             yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-             tmp1 = _mm_mul_ps(a, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-             a = _mm_shuffle_ps(a, a, 0xB1); // Re-arrange x to be ai,ar,bi,br
-             tmp2 = _mm_mul_ps(a, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-             b = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
-             c1 = _mm_cvtps_epi32(b); // convert from 32fc to 32ic
+    for (j = 0; j < sse_iters % ROTATOR_RELOAD; j++)
+        {
+            a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0])));  // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+            //complex 32fc multiplication b=a*two_phase_acc_reg
+            yl = _mm_moveldup_ps(two_phase_acc_reg);  // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg);  // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(a, yl);                 // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            a = _mm_shuffle_ps(a, a, 0xB1);           // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(a, yh);                 // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            b = _mm_addsub_ps(tmp1, tmp2);            // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            c1 = _mm_cvtps_epi32(b);                  // convert from 32fc to 32ic
 
-             //complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
-             yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-             yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-             tmp1 = _mm_mul_ps(two_phase_inc_reg, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-             tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1); // Re-arrange x to be ai,ar,bi,br
-             tmp2 = _mm_mul_ps(tmp3, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-             two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            //complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
+            yl = _mm_moveldup_ps(two_phase_acc_reg);                            // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg);                            // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(two_phase_inc_reg, yl);                           // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1);  // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(tmp3, yh);                                        // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2);                      // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
 
-             //next two samples
-             _in += 2;
-             a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
-             __VOLK_GNSSSDR_PREFETCH(_in + 8);
-             //complex 32fc multiplication b=a*two_phase_acc_reg
-             yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-             yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-             tmp1 = _mm_mul_ps(a, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-             a = _mm_shuffle_ps(a, a, 0xB1); // Re-arrange x to be ai,ar,bi,br
-             tmp2 = _mm_mul_ps(a, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-             b = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
-             c2 = _mm_cvtps_epi32(b); // convert from 32fc to 32ic
+            //next two samples
+            _in += 2;
+            a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0])));  // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+            __VOLK_GNSSSDR_PREFETCH(_in + 8);
+            //complex 32fc multiplication b=a*two_phase_acc_reg
+            yl = _mm_moveldup_ps(two_phase_acc_reg);  // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg);  // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(a, yl);                 // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            a = _mm_shuffle_ps(a, a, 0xB1);           // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(a, yh);                 // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            b = _mm_addsub_ps(tmp1, tmp2);            // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            c2 = _mm_cvtps_epi32(b);                  // convert from 32fc to 32ic
 
-             //complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
-             yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
-             yh = _mm_movehdup_ps(two_phase_acc_reg); // Load yh with ci,ci,di,di
-             tmp1 = _mm_mul_ps(two_phase_inc_reg, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
-             tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1); // Re-arrange x to be ai,ar,bi,br
-             tmp2 = _mm_mul_ps(tmp3, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
-             two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+            //complex 32fc multiplication two_phase_acc_reg=two_phase_acc_reg*two_phase_inc_reg
+            yl = _mm_moveldup_ps(two_phase_acc_reg);                            // Load yl with cr,cr,dr,dr
+            yh = _mm_movehdup_ps(two_phase_acc_reg);                            // Load yh with ci,ci,di,di
+            tmp1 = _mm_mul_ps(two_phase_inc_reg, yl);                           // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+            tmp3 = _mm_shuffle_ps(two_phase_inc_reg, two_phase_inc_reg, 0xB1);  // Re-arrange x to be ai,ar,bi,br
+            tmp2 = _mm_mul_ps(tmp3, yh);                                        // tmp2 = ai*ci,ar*ci,bi*di,br*di
+            two_phase_acc_reg = _mm_addsub_ps(tmp1, tmp2);                      // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
 
-             // store four output samples
-             result = _mm_packs_epi32(c1, c2);// convert from 32ic to 16ic
-             _mm_storeu_si128((__m128i*)_out, result);
+            // store four output samples
+            result = _mm_packs_epi32(c1, c2);  // convert from 32ic to 16ic
+            _mm_storeu_si128((__m128i*)_out, result);
 
-             //next two samples
-             _in += 2;
-             _out += 4;
-         }
+            //next two samples
+            _in += 2;
+            _out += 4;
+        }
 
-     _mm_store_ps((float*)two_phase_acc, two_phase_acc_reg);
-     (*phase) = two_phase_acc[0];
+    _mm_store_ps((float*)two_phase_acc, two_phase_acc_reg);
+    (*phase) = two_phase_acc[0];
 
-     for (n = sse_iters * 4; n < num_points; ++n)
-         {
-             tmp16 = *_in++;
-             tmp32 = lv_cmake((float)lv_creal(tmp16), (float)lv_cimag(tmp16)) * (*phase);
-             *_out++ = lv_cmake((int16_t)rintf(lv_creal(tmp32)), (int16_t)rintf(lv_cimag(tmp32)));
-             (*phase) *= phase_inc;
-         }
+    for (n = sse_iters * 4; n < num_points; ++n)
+        {
+            tmp16 = *_in++;
+            tmp32 = lv_cmake((float)lv_creal(tmp16), (float)lv_cimag(tmp16)) * (*phase);
+            *_out++ = lv_cmake((int16_t)rintf(lv_creal(tmp32)), (int16_t)rintf(lv_cimag(tmp32)));
+            (*phase) *= phase_inc;
+        }
 }
 
 #endif /* LV_HAVE_SSE3 */
@@ -657,8 +663,10 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_neon(lv_16sc_t* outVe
     lv_16sc_t* _out = outVector;
 
     lv_32fc_t ___phase4 = phase_inc * phase_inc * phase_inc * phase_inc;
-    __VOLK_ATTR_ALIGNED(16) float32_t __phase4_real[4] = { lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4) };
-    __VOLK_ATTR_ALIGNED(16) float32_t __phase4_imag[4] = { lv_cimag(___phase4), lv_cimag(___phase4), lv_cimag(___phase4), lv_cimag(___phase4) };
+    __VOLK_ATTR_ALIGNED(16)
+    float32_t __phase4_real[4] = {lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4)};
+    __VOLK_ATTR_ALIGNED(16)
+    float32_t __phase4_imag[4] = {lv_cimag(___phase4), lv_cimag(___phase4), lv_cimag(___phase4), lv_cimag(___phase4)};
 
     float32x4_t _phase4_real = vld1q_f32(__phase4_real);
     float32x4_t _phase4_imag = vld1q_f32(__phase4_imag);
@@ -667,8 +675,10 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_neon(lv_16sc_t* outVe
     lv_32fc_t phase3 = phase2 * phase_inc;
     lv_32fc_t phase4 = phase3 * phase_inc;
 
-    __VOLK_ATTR_ALIGNED(16) float32_t __phase_real[4] = { lv_creal((*phase)), lv_creal(phase2), lv_creal(phase3), lv_creal(phase4) };
-    __VOLK_ATTR_ALIGNED(16) float32_t __phase_imag[4] = { lv_cimag((*phase)), lv_cimag(phase2), lv_cimag(phase3), lv_cimag(phase4) };
+    __VOLK_ATTR_ALIGNED(16)
+    float32_t __phase_real[4] = {lv_creal((*phase)), lv_creal(phase2), lv_creal(phase3), lv_creal(phase4)};
+    __VOLK_ATTR_ALIGNED(16)
+    float32_t __phase_imag[4] = {lv_cimag((*phase)), lv_cimag(phase2), lv_cimag(phase3), lv_cimag(phase4)};
 
     float32x4_t _phase_real = vld1q_f32(__phase_real);
     float32x4_t _phase_imag = vld1q_f32(__phase_imag);
@@ -681,7 +691,7 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_neon(lv_16sc_t* outVe
 
     if (neon_iters > 0)
         {
-            for(; i < neon_iters; ++i)
+            for (; i < neon_iters; ++i)
                 {
                     /* load 4 complex numbers (int 16 bits each component) */
                     tmp16 = vld2_s16((int16_t*)_in);
@@ -745,8 +755,10 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_neon(lv_16sc_t* outVe
                             phase3 = phase2 * phase_inc;
                             phase4 = phase3 * phase_inc;
 
-                            __VOLK_ATTR_ALIGNED(16) float32_t  ____phase_real[4] = { lv_creal((*phase)), lv_creal(phase2), lv_creal(phase3), lv_creal(phase4) };
-                            __VOLK_ATTR_ALIGNED(16) float32_t ____phase_imag[4] = { lv_cimag((*phase)), lv_cimag(phase2), lv_cimag(phase3), lv_cimag(phase4) };
+                            __VOLK_ATTR_ALIGNED(16)
+                            float32_t ____phase_real[4] = {lv_creal((*phase)), lv_creal(phase2), lv_creal(phase3), lv_creal(phase4)};
+                            __VOLK_ATTR_ALIGNED(16)
+                            float32_t ____phase_imag[4] = {lv_cimag((*phase)), lv_cimag(phase2), lv_cimag(phase3), lv_cimag(phase4)};
 
                             _phase_real = vld1q_f32(____phase_real);
                             _phase_imag = vld1q_f32(____phase_imag);
@@ -757,7 +769,7 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_neon(lv_16sc_t* outVe
 
             (*phase) = lv_cmake((float32_t)__phase_real[0], (float32_t)__phase_imag[0]);
         }
-    for(i = 0; i < neon_iters % 4; ++i)
+    for (i = 0; i < neon_iters % 4; ++i)
         {
             tmp16_ = *_in++;
             tmp32_ = lv_cmake((float32_t)lv_creal(tmp16_), (float32_t)lv_cimag(tmp16_)) * (*phase);
@@ -791,8 +803,10 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_neon_reload(lv_16sc_t
     lv_16sc_t* _out = outVector;
 
     lv_32fc_t ___phase4 = phase_inc * phase_inc * phase_inc * phase_inc;
-    __VOLK_ATTR_ALIGNED(16) float32_t __phase4_real[4] = { lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4) };
-    __VOLK_ATTR_ALIGNED(16) float32_t __phase4_imag[4] = { lv_cimag(___phase4), lv_cimag(___phase4), lv_cimag(___phase4), lv_cimag(___phase4) };
+    __VOLK_ATTR_ALIGNED(16)
+    float32_t __phase4_real[4] = {lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4)};
+    __VOLK_ATTR_ALIGNED(16)
+    float32_t __phase4_imag[4] = {lv_cimag(___phase4), lv_cimag(___phase4), lv_cimag(___phase4), lv_cimag(___phase4)};
 
     float32x4_t _phase4_real = vld1q_f32(__phase4_real);
     float32x4_t _phase4_imag = vld1q_f32(__phase4_imag);
@@ -801,8 +815,10 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_neon_reload(lv_16sc_t
     lv_32fc_t phase3 = phase2 * phase_inc;
     lv_32fc_t phase4 = phase3 * phase_inc;
 
-    __VOLK_ATTR_ALIGNED(16) float32_t __phase_real[4] = { lv_creal((*phase)), lv_creal(phase2), lv_creal(phase3), lv_creal(phase4) };
-    __VOLK_ATTR_ALIGNED(16) float32_t __phase_imag[4] = { lv_cimag((*phase)), lv_cimag(phase2), lv_cimag(phase3), lv_cimag(phase4) };
+    __VOLK_ATTR_ALIGNED(16)
+    float32_t __phase_real[4] = {lv_creal((*phase)), lv_creal(phase2), lv_creal(phase3), lv_creal(phase4)};
+    __VOLK_ATTR_ALIGNED(16)
+    float32_t __phase_imag[4] = {lv_cimag((*phase)), lv_cimag(phase2), lv_cimag(phase3), lv_cimag(phase4)};
 
     float32x4_t _phase_real = vld1q_f32(__phase_real);
     float32x4_t _phase_imag = vld1q_f32(__phase_imag);
@@ -879,8 +895,10 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_neon_reload(lv_16sc_t
                     phase3 = phase2 * phase_inc;
                     phase4 = phase3 * phase_inc;
 
-                    __VOLK_ATTR_ALIGNED(16) float32_t ____phase_real[4] = { lv_creal((*phase)), lv_creal(phase2), lv_creal(phase3), lv_creal(phase4) };
-                    __VOLK_ATTR_ALIGNED(16) float32_t ____phase_imag[4] = { lv_cimag((*phase)), lv_cimag(phase2), lv_cimag(phase3), lv_cimag(phase4) };
+                    __VOLK_ATTR_ALIGNED(16)
+                    float32_t ____phase_real[4] = {lv_creal((*phase)), lv_creal(phase2), lv_creal(phase3), lv_creal(phase4)};
+                    __VOLK_ATTR_ALIGNED(16)
+                    float32_t ____phase_imag[4] = {lv_cimag((*phase)), lv_cimag(phase2), lv_cimag(phase3), lv_cimag(phase4)};
 
                     _phase_real = vld1q_f32(____phase_real);
                     _phase_imag = vld1q_f32(____phase_imag);
@@ -945,7 +963,7 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_neon_reload(lv_16sc_t
 
             (*phase) = lv_cmake((float32_t)__phase_real[0], (float32_t)__phase_imag[0]);
         }
-    for(i = 0; i < neon_iters % 4; ++i)
+    for (i = 0; i < neon_iters % 4; ++i)
         {
             tmp16_ = *_in++;
             tmp32_ = lv_cmake((float32_t)lv_creal(tmp16_), (float32_t)lv_cimag(tmp16_)) * (*phase);

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_dot_prod_16ic.h

@@ -73,7 +73,7 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_generic(lv_16sc_t* result,
     for (n = 0; n < num_points; n++)
         {
             lv_16sc_t tmp = in_a[n] * in_b[n];
-            result[0] = lv_cmake(sat_adds16i(lv_creal(result[0]), lv_creal(tmp)), sat_adds16i(lv_cimag(result[0]), lv_cimag(tmp) ));
+            result[0] = lv_cmake(sat_adds16i(lv_creal(result[0]), lv_creal(tmp)), sat_adds16i(lv_cimag(result[0]), lv_cimag(tmp)));
         }
 }
 
@@ -96,7 +96,8 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_a_sse2(lv_16sc_t* out, con
     if (sse_iters > 0)
         {
             __m128i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1, imag2, b_sl, a_sl, realcacc, imagcacc;
-            __VOLK_ATTR_ALIGNED(16) lv_16sc_t dotProductVector[4];
+            __VOLK_ATTR_ALIGNED(16)
+            lv_16sc_t dotProductVector[4];
 
             realcacc = _mm_setzero_si128();
             imagcacc = _mm_setzero_si128();
@@ -104,25 +105,25 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_a_sse2(lv_16sc_t* out, con
             mask_imag = _mm_set_epi8(0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
             mask_real = _mm_set_epi8(0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
 
-            for(number = 0; number < sse_iters; number++)
+            for (number = 0; number < sse_iters; number++)
                 {
                     // a[127:0]=[a3.i,a3.r,a2.i,a2.r,a1.i,a1.r,a0.i,a0.r]
-                    a = _mm_load_si128((__m128i*)_in_a); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
+                    a = _mm_load_si128((__m128i*)_in_a);  //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
                     __VOLK_GNSSSDR_PREFETCH(_in_a + 8);
                     b = _mm_load_si128((__m128i*)_in_b);
                     __VOLK_GNSSSDR_PREFETCH(_in_b + 8);
-                    c = _mm_mullo_epi16(a, b); // a3.i*b3.i, a3.r*b3.r, ....
+                    c = _mm_mullo_epi16(a, b);  // a3.i*b3.i, a3.r*b3.r, ....
 
-                    c_sr = _mm_srli_si128(c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
+                    c_sr = _mm_srli_si128(c, 2);  // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
                     real = _mm_subs_epi16(c, c_sr);
 
-                    b_sl = _mm_slli_si128(b, 2); // b3.r, b2.i ....
-                    a_sl = _mm_slli_si128(a, 2); // a3.r, a2.i ....
+                    b_sl = _mm_slli_si128(b, 2);  // b3.r, b2.i ....
+                    a_sl = _mm_slli_si128(a, 2);  // a3.r, a2.i ....
 
-                    imag1 = _mm_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
-                    imag2 = _mm_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
+                    imag1 = _mm_mullo_epi16(a, b_sl);  // a3.i*b3.r, ....
+                    imag2 = _mm_mullo_epi16(b, a_sl);  // b3.i*a3.r, ....
 
-                    imag = _mm_adds_epi16(imag1, imag2); //with saturation arithmetic!
+                    imag = _mm_adds_epi16(imag1, imag2);  //with saturation arithmetic!
 
                     realcacc = _mm_adds_epi16(realcacc, real);
                     imagcacc = _mm_adds_epi16(imagcacc, imag);
@@ -136,7 +137,7 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_a_sse2(lv_16sc_t* out, con
 
             a = _mm_or_si128(realcacc, imagcacc);
 
-            _mm_store_si128((__m128i*)dotProductVector, a); // Store the results back into the dot product vector
+            _mm_store_si128((__m128i*)dotProductVector, a);  // Store the results back into the dot product vector
 
             for (number = 0; number < 4; ++number)
                 {
@@ -174,7 +175,8 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_u_sse2(lv_16sc_t* out, con
     if (sse_iters > 0)
         {
             __m128i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1, imag2, b_sl, a_sl, realcacc, imagcacc, result;
-            __VOLK_ATTR_ALIGNED(16) lv_16sc_t dotProductVector[4];
+            __VOLK_ATTR_ALIGNED(16)
+            lv_16sc_t dotProductVector[4];
 
             realcacc = _mm_setzero_si128();
             imagcacc = _mm_setzero_si128();
@@ -182,27 +184,27 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_u_sse2(lv_16sc_t* out, con
             mask_imag = _mm_set_epi8(0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
             mask_real = _mm_set_epi8(0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
 
-            for(number = 0; number < sse_iters; number++)
+            for (number = 0; number < sse_iters; number++)
                 {
                     //std::complex<T> memory structure: real part -> reinterpret_cast<cv T*>(a)[2*i]
                     //imaginery part -> reinterpret_cast<cv T*>(a)[2*i + 1]
                     // a[127:0]=[a3.i,a3.r,a2.i,a2.r,a1.i,a1.r,a0.i,a0.r]
-                    a = _mm_loadu_si128((__m128i*)_in_a); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
+                    a = _mm_loadu_si128((__m128i*)_in_a);  //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
                     __VOLK_GNSSSDR_PREFETCH(_in_a + 8);
                     b = _mm_loadu_si128((__m128i*)_in_b);
                     __VOLK_GNSSSDR_PREFETCH(_in_b + 8);
-                    c = _mm_mullo_epi16(a, b); // a3.i*b3.i, a3.r*b3.r, ....
+                    c = _mm_mullo_epi16(a, b);  // a3.i*b3.i, a3.r*b3.r, ....
 
-                    c_sr = _mm_srli_si128(c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
+                    c_sr = _mm_srli_si128(c, 2);  // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
                     real = _mm_subs_epi16(c, c_sr);
 
-                    b_sl = _mm_slli_si128(b, 2); // b3.r, b2.i ....
-                    a_sl = _mm_slli_si128(a, 2); // a3.r, a2.i ....
+                    b_sl = _mm_slli_si128(b, 2);  // b3.r, b2.i ....
+                    a_sl = _mm_slli_si128(a, 2);  // a3.r, a2.i ....
 
-                    imag1 = _mm_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
-                    imag2 = _mm_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
+                    imag1 = _mm_mullo_epi16(a, b_sl);  // a3.i*b3.r, ....
+                    imag2 = _mm_mullo_epi16(b, a_sl);  // b3.i*a3.r, ....
 
-                    imag = _mm_adds_epi16(imag1, imag2); //with saturation arithmetic!
+                    imag = _mm_adds_epi16(imag1, imag2);  //with saturation arithmetic!
 
                     realcacc = _mm_adds_epi16(realcacc, real);
                     imagcacc = _mm_adds_epi16(imagcacc, imag);
@@ -216,7 +218,7 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_u_sse2(lv_16sc_t* out, con
 
             result = _mm_or_si128(realcacc, imagcacc);
 
-            _mm_storeu_si128((__m128i*)dotProductVector, result); // Store the results back into the dot product vector
+            _mm_storeu_si128((__m128i*)dotProductVector, result);  // Store the results back into the dot product vector
 
             for (i = 0; i < 4; ++i)
                 {
@@ -253,7 +255,8 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_u_axv2(lv_16sc_t* out, con
     if (avx_iters > 0)
         {
             __m256i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1, imag2, b_sl, a_sl, realcacc, imagcacc, result;
-            __VOLK_ATTR_ALIGNED(32) lv_16sc_t dotProductVector[8];
+            __VOLK_ATTR_ALIGNED(32)
+            lv_16sc_t dotProductVector[8];
 
             realcacc = _mm256_setzero_si256();
             imagcacc = _mm256_setzero_si256();
@@ -261,7 +264,7 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_u_axv2(lv_16sc_t* out, con
             mask_imag = _mm256_set_epi8(0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
             mask_real = _mm256_set_epi8(0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
 
-            for(number = 0; number < avx_iters; number++)
+            for (number = 0; number < avx_iters; number++)
                 {
                     a = _mm256_loadu_si256((__m256i*)_in_a);
                     __VOLK_GNSSSDR_PREFETCH(_in_a + 16);
@@ -269,7 +272,7 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_u_axv2(lv_16sc_t* out, con
                     __VOLK_GNSSSDR_PREFETCH(_in_b + 16);
                     c = _mm256_mullo_epi16(a, b);
 
-                    c_sr = _mm256_srli_si256(c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
+                    c_sr = _mm256_srli_si256(c, 2);  // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
                     real = _mm256_subs_epi16(c, c_sr);
 
                     b_sl = _mm256_slli_si256(b, 2);
@@ -278,7 +281,7 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_u_axv2(lv_16sc_t* out, con
                     imag1 = _mm256_mullo_epi16(a, b_sl);
                     imag2 = _mm256_mullo_epi16(b, a_sl);
 
-                    imag = _mm256_adds_epi16(imag1, imag2); //with saturation arithmetic!
+                    imag = _mm256_adds_epi16(imag1, imag2);  //with saturation arithmetic!
 
                     realcacc = _mm256_adds_epi16(realcacc, real);
                     imagcacc = _mm256_adds_epi16(imagcacc, imag);
@@ -292,7 +295,7 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_u_axv2(lv_16sc_t* out, con
 
             result = _mm256_or_si256(realcacc, imagcacc);
 
-            _mm256_storeu_si256((__m256i*)dotProductVector, result); // Store the results back into the dot product vector
+            _mm256_storeu_si256((__m256i*)dotProductVector, result);  // Store the results back into the dot product vector
             _mm256_zeroupper();
 
             for (i = 0; i < 8; ++i)
@@ -330,7 +333,8 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_a_axv2(lv_16sc_t* out, con
     if (avx_iters > 0)
         {
             __m256i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1, imag2, b_sl, a_sl, realcacc, imagcacc, result;
-            __VOLK_ATTR_ALIGNED(32) lv_16sc_t dotProductVector[8];
+            __VOLK_ATTR_ALIGNED(32)
+            lv_16sc_t dotProductVector[8];
 
             realcacc = _mm256_setzero_si256();
             imagcacc = _mm256_setzero_si256();
@@ -338,7 +342,7 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_a_axv2(lv_16sc_t* out, con
             mask_imag = _mm256_set_epi8(0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
             mask_real = _mm256_set_epi8(0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
 
-            for(number = 0; number < avx_iters; number++)
+            for (number = 0; number < avx_iters; number++)
                 {
                     a = _mm256_load_si256((__m256i*)_in_a);
                     __VOLK_GNSSSDR_PREFETCH(_in_a + 16);
@@ -346,7 +350,7 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_a_axv2(lv_16sc_t* out, con
                     __VOLK_GNSSSDR_PREFETCH(_in_b + 16);
                     c = _mm256_mullo_epi16(a, b);
 
-                    c_sr = _mm256_srli_si256(c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
+                    c_sr = _mm256_srli_si256(c, 2);  // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
                     real = _mm256_subs_epi16(c, c_sr);
 
                     b_sl = _mm256_slli_si256(b, 2);
@@ -355,7 +359,7 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_a_axv2(lv_16sc_t* out, con
                     imag1 = _mm256_mullo_epi16(a, b_sl);
                     imag2 = _mm256_mullo_epi16(b, a_sl);
 
-                    imag = _mm256_adds_epi16(imag1, imag2); //with saturation arithmetic!
+                    imag = _mm256_adds_epi16(imag1, imag2);  //with saturation arithmetic!
 
                     realcacc = _mm256_adds_epi16(realcacc, real);
                     imagcacc = _mm256_adds_epi16(imagcacc, imag);
@@ -369,7 +373,7 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_a_axv2(lv_16sc_t* out, con
 
             result = _mm256_or_si256(realcacc, imagcacc);
 
-            _mm256_store_si256((__m256i*)dotProductVector, result); // Store the results back into the dot product vector
+            _mm256_store_si256((__m256i*)dotProductVector, result);  // Store the results back into the dot product vector
             _mm256_zeroupper();
 
             for (i = 0; i < 8; ++i)
@@ -397,8 +401,8 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_neon(lv_16sc_t* out, const
     unsigned int quarter_points = num_points / 4;
     unsigned int number;
 
-    lv_16sc_t* a_ptr = (lv_16sc_t*) in_a;
-    lv_16sc_t* b_ptr = (lv_16sc_t*) in_b;
+    lv_16sc_t* a_ptr = (lv_16sc_t*)in_a;
+    lv_16sc_t* b_ptr = (lv_16sc_t*)in_b;
     *out = lv_cmake((int16_t)0, (int16_t)0);
 
     if (quarter_points > 0)
@@ -407,15 +411,16 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_neon(lv_16sc_t* out, const
             // 2nd lane holds the imaginary part
             int16x4x2_t a_val, b_val, c_val, accumulator;
             int16x4x2_t tmp_real, tmp_imag;
-            __VOLK_ATTR_ALIGNED(16) lv_16sc_t accum_result[4];
+            __VOLK_ATTR_ALIGNED(16)
+            lv_16sc_t accum_result[4];
             accumulator.val[0] = vdup_n_s16(0);
             accumulator.val[1] = vdup_n_s16(0);
             lv_16sc_t dotProduct = lv_cmake((int16_t)0, (int16_t)0);
 
-            for(number = 0; number < quarter_points; ++number)
+            for (number = 0; number < quarter_points; ++number)
                 {
-                    a_val = vld2_s16((int16_t*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
-                    b_val = vld2_s16((int16_t*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
+                    a_val = vld2_s16((int16_t*)a_ptr);  // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
+                    b_val = vld2_s16((int16_t*)b_ptr);  // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
                     __VOLK_GNSSSDR_PREFETCH(a_ptr + 8);
                     __VOLK_GNSSSDR_PREFETCH(b_ptr + 8);
 
@@ -451,7 +456,7 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_neon(lv_16sc_t* out, const
         }
 
     // tail case
-    for(number = quarter_points * 4; number < num_points; ++number)
+    for (number = quarter_points * 4; number < num_points; ++number)
         {
             *out += (*a_ptr++) * (*b_ptr++);
         }
@@ -468,20 +473,21 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_neon_vma(lv_16sc_t* out, c
     unsigned int quarter_points = num_points / 4;
     unsigned int number;
 
-    lv_16sc_t* a_ptr = (lv_16sc_t*) in_a;
-    lv_16sc_t* b_ptr = (lv_16sc_t*) in_b;
+    lv_16sc_t* a_ptr = (lv_16sc_t*)in_a;
+    lv_16sc_t* b_ptr = (lv_16sc_t*)in_b;
     // for 2-lane vectors, 1st lane holds the real part,
     // 2nd lane holds the imaginary part
     int16x4x2_t a_val, b_val, accumulator;
     int16x4x2_t tmp;
-    __VOLK_ATTR_ALIGNED(16) lv_16sc_t accum_result[4];
+    __VOLK_ATTR_ALIGNED(16)
+    lv_16sc_t accum_result[4];
     accumulator.val[0] = vdup_n_s16(0);
     accumulator.val[1] = vdup_n_s16(0);
 
-    for(number = 0; number < quarter_points; ++number)
+    for (number = 0; number < quarter_points; ++number)
         {
-            a_val = vld2_s16((int16_t*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
-            b_val = vld2_s16((int16_t*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
+            a_val = vld2_s16((int16_t*)a_ptr);  // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
+            b_val = vld2_s16((int16_t*)b_ptr);  // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
             __VOLK_GNSSSDR_PREFETCH(a_ptr + 8);
             __VOLK_GNSSSDR_PREFETCH(b_ptr + 8);
 
@@ -503,7 +509,7 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_neon_vma(lv_16sc_t* out, c
     *out = accum_result[0] + accum_result[1] + accum_result[2] + accum_result[3];
 
     // tail case
-    for(number = quarter_points * 4; number < num_points; ++number)
+    for (number = quarter_points * 4; number < num_points; ++number)
         {
             *out += (*a_ptr++) * (*b_ptr++);
         }
@@ -520,22 +526,23 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_neon_optvma(lv_16sc_t* out
     unsigned int quarter_points = num_points / 4;
     unsigned int number;
 
-    lv_16sc_t* a_ptr = (lv_16sc_t*) in_a;
-    lv_16sc_t* b_ptr = (lv_16sc_t*) in_b;
+    lv_16sc_t* a_ptr = (lv_16sc_t*)in_a;
+    lv_16sc_t* b_ptr = (lv_16sc_t*)in_b;
     // for 2-lane vectors, 1st lane holds the real part,
     // 2nd lane holds the imaginary part
     int16x4x2_t a_val, b_val, accumulator1, accumulator2;
 
-    __VOLK_ATTR_ALIGNED(16) lv_16sc_t accum_result[4];
+    __VOLK_ATTR_ALIGNED(16)
+    lv_16sc_t accum_result[4];
     accumulator1.val[0] = vdup_n_s16(0);
     accumulator1.val[1] = vdup_n_s16(0);
     accumulator2.val[0] = vdup_n_s16(0);
     accumulator2.val[1] = vdup_n_s16(0);
 
-    for(number = 0; number < quarter_points; ++number)
+    for (number = 0; number < quarter_points; ++number)
         {
-            a_val = vld2_s16((int16_t*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
-            b_val = vld2_s16((int16_t*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
+            a_val = vld2_s16((int16_t*)a_ptr);  // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
+            b_val = vld2_s16((int16_t*)b_ptr);  // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
             __VOLK_GNSSSDR_PREFETCH(a_ptr + 8);
             __VOLK_GNSSSDR_PREFETCH(b_ptr + 8);
 
@@ -556,7 +563,7 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_neon_optvma(lv_16sc_t* out
     *out = accum_result[0] + accum_result[1] + accum_result[2] + accum_result[3];
 
     // tail case
-    for(number = quarter_points * 4; number < num_points; ++number)
+    for (number = quarter_points * 4; number < num_points; ++number)
         {
             *out += (*a_ptr++) * (*b_ptr++);
         }

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_dot_prod_16ic_xn.h

@@ -74,7 +74,7 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_generic(lv_16sc_t* resu
     unsigned int n;
     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
         {
-            result[n_vec] = lv_cmake(0,0);
+            result[n_vec] = lv_cmake(0, 0);
             for (n = 0; n < num_points; n++)
                 {
                     //r*a.r - i*a.i, i*a.r + r*a.i
@@ -96,11 +96,11 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_generic_sat(lv_16sc_t*
     unsigned int n;
     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
         {
-            result[n_vec] = lv_cmake(0,0);
+            result[n_vec] = lv_cmake(0, 0);
             for (n = 0; n < num_points; n++)
                 {
-                    lv_16sc_t tmp = lv_cmake(sat_adds16i(sat_muls16i(lv_creal(in_common[n]), lv_creal(in_a[n_vec][n])), - sat_muls16i(lv_cimag(in_common[n]), lv_cimag(in_a[n_vec][n]))),
-                                             sat_adds16i(sat_muls16i(lv_creal(in_common[n]), lv_cimag(in_a[n_vec][n])), sat_muls16i(lv_cimag(in_common[n]), lv_creal(in_a[n_vec][n]))));
+                    lv_16sc_t tmp = lv_cmake(sat_adds16i(sat_muls16i(lv_creal(in_common[n]), lv_creal(in_a[n_vec][n])), -sat_muls16i(lv_cimag(in_common[n]), lv_cimag(in_a[n_vec][n]))),
+                        sat_adds16i(sat_muls16i(lv_creal(in_common[n]), lv_cimag(in_a[n_vec][n])), sat_muls16i(lv_cimag(in_common[n]), lv_creal(in_a[n_vec][n]))));
                     result[n_vec] = lv_cmake(sat_adds16i(lv_creal(result[n_vec]), lv_creal(tmp)), sat_adds16i(lv_cimag(result[n_vec]), lv_cimag(tmp)));
                 }
         }
@@ -112,9 +112,9 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_generic_sat(lv_16sc_t*
 #ifdef LV_HAVE_SSE2
 #include <emmintrin.h>
 
-static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_a_sse2(lv_16sc_t* result, const lv_16sc_t* in_common, const lv_16sc_t** in_a,  int num_a_vectors, unsigned int num_points)
+static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_a_sse2(lv_16sc_t* result, const lv_16sc_t* in_common, const lv_16sc_t** in_a, int num_a_vectors, unsigned int num_points)
 {
-    lv_16sc_t dotProduct = lv_cmake(0,0);
+    lv_16sc_t dotProduct = lv_cmake(0, 0);
     int n_vec;
     unsigned int index;
     const unsigned int sse_iters = num_points / 4;
@@ -125,7 +125,8 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_a_sse2(lv_16sc_t* resul
 
     if (sse_iters > 0)
         {
-            __VOLK_ATTR_ALIGNED(16) lv_16sc_t dotProductVector[4];
+            __VOLK_ATTR_ALIGNED(16)
+            lv_16sc_t dotProductVector[4];
 
             __m128i* realcacc = (__m128i*)volk_gnsssdr_malloc(num_a_vectors * sizeof(__m128i), volk_gnsssdr_get_alignment());
             __m128i* imagcacc = (__m128i*)volk_gnsssdr_malloc(num_a_vectors * sizeof(__m128i), volk_gnsssdr_get_alignment());
@@ -141,25 +142,25 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_a_sse2(lv_16sc_t* resul
             mask_imag = _mm_set_epi8(0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
             mask_real = _mm_set_epi8(0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
 
-            for(index = 0; index < sse_iters; index++)
+            for (index = 0; index < sse_iters; index++)
                 {
                     // b[127:0]=[a3.i,a3.r,a2.i,a2.r,a1.i,a1.r,a0.i,a0.r]
-                    b = _mm_load_si128((__m128i*)_in_common); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
+                    b = _mm_load_si128((__m128i*)_in_common);  //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
                     __VOLK_GNSSSDR_PREFETCH(_in_common + 8);
                     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
                         {
-                            a = _mm_load_si128((__m128i*)&(_in_a[n_vec][index*4])); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
+                            a = _mm_load_si128((__m128i*)&(_in_a[n_vec][index * 4]));  //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
 
-                            c = _mm_mullo_epi16(a, b); // a3.i*b3.i, a3.r*b3.r, ....
+                            c = _mm_mullo_epi16(a, b);  // a3.i*b3.i, a3.r*b3.r, ....
 
-                            c_sr = _mm_srli_si128(c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
+                            c_sr = _mm_srli_si128(c, 2);  // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
                             real = _mm_subs_epi16(c, c_sr);
 
-                            c_sr = _mm_slli_si128(b, 2); // b3.r, b2.i ....
-                            c = _mm_mullo_epi16(a, c_sr); // a3.i*b3.r, ....
+                            c_sr = _mm_slli_si128(b, 2);   // b3.r, b2.i ....
+                            c = _mm_mullo_epi16(a, c_sr);  // a3.i*b3.r, ....
 
-                            c_sr = _mm_slli_si128(a, 2); // a3.r, a2.i ....
-                            imag = _mm_mullo_epi16(b, c_sr); // b3.i*a3.r, ....
+                            c_sr = _mm_slli_si128(a, 2);      // a3.r, a2.i ....
+                            imag = _mm_mullo_epi16(b, c_sr);  // b3.i*a3.r, ....
 
                             imag = _mm_adds_epi16(c, imag);
 
@@ -176,12 +177,12 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_a_sse2(lv_16sc_t* resul
 
                     a = _mm_or_si128(realcacc[n_vec], imagcacc[n_vec]);
 
-                    _mm_store_si128((__m128i*)dotProductVector, a); // Store the results back into the dot product vector
-                    dotProduct = lv_cmake(0,0);
+                    _mm_store_si128((__m128i*)dotProductVector, a);  // Store the results back into the dot product vector
+                    dotProduct = lv_cmake(0, 0);
                     for (index = 0; index < 4; ++index)
                         {
                             dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[index])),
-                                    sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[index])));
+                                sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[index])));
                         }
                     _out[n_vec] = dotProduct;
                 }
@@ -191,12 +192,12 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_a_sse2(lv_16sc_t* resul
 
     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
         {
-            for(index  = sse_iters * 4; index < num_points; index++)
+            for (index = sse_iters * 4; index < num_points; index++)
                 {
                     lv_16sc_t tmp = in_common[index] * in_a[n_vec][index];
 
                     _out[n_vec] = lv_cmake(sat_adds16i(lv_creal(_out[n_vec]), lv_creal(tmp)),
-                            sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
+                        sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
                 }
         }
 }
@@ -206,9 +207,9 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_a_sse2(lv_16sc_t* resul
 #ifdef LV_HAVE_SSE2
 #include <emmintrin.h>
 
-static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_u_sse2(lv_16sc_t* result, const lv_16sc_t* in_common, const lv_16sc_t** in_a,  int num_a_vectors, unsigned int num_points)
+static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_u_sse2(lv_16sc_t* result, const lv_16sc_t* in_common, const lv_16sc_t** in_a, int num_a_vectors, unsigned int num_points)
 {
-    lv_16sc_t dotProduct = lv_cmake(0,0);
+    lv_16sc_t dotProduct = lv_cmake(0, 0);
     int n_vec;
     unsigned int index;
     const unsigned int sse_iters = num_points / 4;
@@ -219,7 +220,8 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_u_sse2(lv_16sc_t* resul
 
     if (sse_iters > 0)
         {
-            __VOLK_ATTR_ALIGNED(16) lv_16sc_t dotProductVector[4];
+            __VOLK_ATTR_ALIGNED(16)
+            lv_16sc_t dotProductVector[4];
 
             __m128i* realcacc = (__m128i*)volk_gnsssdr_malloc(num_a_vectors * sizeof(__m128i), volk_gnsssdr_get_alignment());
             __m128i* imagcacc = (__m128i*)volk_gnsssdr_malloc(num_a_vectors * sizeof(__m128i), volk_gnsssdr_get_alignment());
@@ -235,25 +237,25 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_u_sse2(lv_16sc_t* resul
             mask_imag = _mm_set_epi8(0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
             mask_real = _mm_set_epi8(0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
 
-            for(index = 0; index < sse_iters; index++)
+            for (index = 0; index < sse_iters; index++)
                 {
                     // b[127:0]=[a3.i,a3.r,a2.i,a2.r,a1.i,a1.r,a0.i,a0.r]
-                    b = _mm_loadu_si128((__m128i*)_in_common); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
+                    b = _mm_loadu_si128((__m128i*)_in_common);  //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
                     __VOLK_GNSSSDR_PREFETCH(_in_common + 8);
                     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
                         {
-                            a = _mm_loadu_si128((__m128i*)&(_in_a[n_vec][index*4])); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
+                            a = _mm_loadu_si128((__m128i*)&(_in_a[n_vec][index * 4]));  //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
 
-                            c = _mm_mullo_epi16(a, b); // a3.i*b3.i, a3.r*b3.r, ....
+                            c = _mm_mullo_epi16(a, b);  // a3.i*b3.i, a3.r*b3.r, ....
 
-                            c_sr = _mm_srli_si128(c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
+                            c_sr = _mm_srli_si128(c, 2);  // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
                             real = _mm_subs_epi16(c, c_sr);
 
-                            c_sr = _mm_slli_si128(b, 2); // b3.r, b2.i ....
-                            c = _mm_mullo_epi16(a, c_sr); // a3.i*b3.r, ....
+                            c_sr = _mm_slli_si128(b, 2);   // b3.r, b2.i ....
+                            c = _mm_mullo_epi16(a, c_sr);  // a3.i*b3.r, ....
 
-                            c_sr = _mm_slli_si128(a, 2); // a3.r, a2.i ....
-                            imag = _mm_mullo_epi16(b, c_sr); // b3.i*a3.r, ....
+                            c_sr = _mm_slli_si128(a, 2);      // a3.r, a2.i ....
+                            imag = _mm_mullo_epi16(b, c_sr);  // b3.i*a3.r, ....
 
                             imag = _mm_adds_epi16(c, imag);
 
@@ -270,12 +272,12 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_u_sse2(lv_16sc_t* resul
 
                     a = _mm_or_si128(realcacc[n_vec], imagcacc[n_vec]);
 
-                    _mm_store_si128((__m128i*)dotProductVector, a); // Store the results back into the dot product vector
-                    dotProduct = lv_cmake(0,0);
+                    _mm_store_si128((__m128i*)dotProductVector, a);  // Store the results back into the dot product vector
+                    dotProduct = lv_cmake(0, 0);
                     for (index = 0; index < 4; ++index)
                         {
                             dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[index])),
-                                    sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[index])));
+                                sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[index])));
                         }
                     _out[n_vec] = dotProduct;
                 }
@@ -285,12 +287,12 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_u_sse2(lv_16sc_t* resul
 
     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
         {
-            for(index = sse_iters * 4; index < num_points; index++)
+            for (index = sse_iters * 4; index < num_points; index++)
                 {
                     lv_16sc_t tmp = in_common[index] * in_a[n_vec][index];
 
                     _out[n_vec] = lv_cmake(sat_adds16i(lv_creal(_out[n_vec]), lv_creal(tmp)),
-                            sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
+                        sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
                 }
         }
 }
@@ -300,9 +302,9 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_u_sse2(lv_16sc_t* resul
 #ifdef LV_HAVE_AVX2
 #include <immintrin.h>
 
-static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_a_avx2(lv_16sc_t* result, const lv_16sc_t* in_common, const lv_16sc_t** in_a,  int num_a_vectors, unsigned int num_points)
+static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_a_avx2(lv_16sc_t* result, const lv_16sc_t* in_common, const lv_16sc_t** in_a, int num_a_vectors, unsigned int num_points)
 {
-    lv_16sc_t dotProduct = lv_cmake(0,0);
+    lv_16sc_t dotProduct = lv_cmake(0, 0);
     int n_vec;
     unsigned int index;
     const unsigned int sse_iters = num_points / 8;
@@ -313,7 +315,8 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_a_avx2(lv_16sc_t* resul
 
     if (sse_iters > 0)
         {
-            __VOLK_ATTR_ALIGNED(32) lv_16sc_t dotProductVector[8];
+            __VOLK_ATTR_ALIGNED(32)
+            lv_16sc_t dotProductVector[8];
 
             __m256i* realcacc = (__m256i*)volk_gnsssdr_malloc(num_a_vectors * sizeof(__m256i), volk_gnsssdr_get_alignment());
             __m256i* imagcacc = (__m256i*)volk_gnsssdr_malloc(num_a_vectors * sizeof(__m256i), volk_gnsssdr_get_alignment());
@@ -329,24 +332,24 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_a_avx2(lv_16sc_t* resul
             mask_imag = _mm256_set_epi8(0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
             mask_real = _mm256_set_epi8(0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
 
-            for(index = 0; index < sse_iters; index++)
+            for (index = 0; index < sse_iters; index++)
                 {
                     b = _mm256_load_si256((__m256i*)_in_common);
                     __VOLK_GNSSSDR_PREFETCH(_in_common + 16);
                     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
                         {
-                            a = _mm256_load_si256((__m256i*)&(_in_a[n_vec][index*8]));
+                            a = _mm256_load_si256((__m256i*)&(_in_a[n_vec][index * 8]));
 
                             c = _mm256_mullo_epi16(a, b);
 
-                            c_sr = _mm256_srli_si256(c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
+                            c_sr = _mm256_srli_si256(c, 2);  // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
                             real = _mm256_subs_epi16(c, c_sr);
 
-                            c_sr = _mm256_slli_si256(b, 2); // b3.r, b2.i ....
-                            c = _mm256_mullo_epi16(a, c_sr); // a3.i*b3.r, ....
+                            c_sr = _mm256_slli_si256(b, 2);   // b3.r, b2.i ....
+                            c = _mm256_mullo_epi16(a, c_sr);  // a3.i*b3.r, ....
 
-                            c_sr = _mm256_slli_si256(a, 2); // a3.r, a2.i ....
-                            imag = _mm256_mullo_epi16(b, c_sr); // b3.i*a3.r, ....
+                            c_sr = _mm256_slli_si256(a, 2);      // a3.r, a2.i ....
+                            imag = _mm256_mullo_epi16(b, c_sr);  // b3.i*a3.r, ....
 
                             imag = _mm256_adds_epi16(c, imag);
 
@@ -363,12 +366,12 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_a_avx2(lv_16sc_t* resul
 
                     a = _mm256_or_si256(realcacc[n_vec], imagcacc[n_vec]);
 
-                    _mm256_store_si256((__m256i*)dotProductVector, a); // Store the results back into the dot product vector
-                    dotProduct = lv_cmake(0,0);
+                    _mm256_store_si256((__m256i*)dotProductVector, a);  // Store the results back into the dot product vector
+                    dotProduct = lv_cmake(0, 0);
                     for (index = 0; index < 8; ++index)
                         {
                             dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[index])),
-                                    sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[index])));
+                                sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[index])));
                         }
                     _out[n_vec] = dotProduct;
                 }
@@ -379,12 +382,12 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_a_avx2(lv_16sc_t* resul
 
     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
         {
-            for(index  = sse_iters * 8; index < num_points; index++)
+            for (index = sse_iters * 8; index < num_points; index++)
                 {
                     lv_16sc_t tmp = in_common[index] * in_a[n_vec][index];
 
                     _out[n_vec] = lv_cmake(sat_adds16i(lv_creal(_out[n_vec]), lv_creal(tmp)),
-                            sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
+                        sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
                 }
         }
 }
@@ -394,9 +397,9 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_a_avx2(lv_16sc_t* resul
 #ifdef LV_HAVE_AVX2
 #include <immintrin.h>
 
-static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_u_avx2(lv_16sc_t* result, const lv_16sc_t* in_common, const lv_16sc_t** in_a,  int num_a_vectors, unsigned int num_points)
+static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_u_avx2(lv_16sc_t* result, const lv_16sc_t* in_common, const lv_16sc_t** in_a, int num_a_vectors, unsigned int num_points)
 {
-    lv_16sc_t dotProduct = lv_cmake(0,0);
+    lv_16sc_t dotProduct = lv_cmake(0, 0);
 
     const unsigned int sse_iters = num_points / 8;
     int n_vec;
@@ -407,7 +410,8 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_u_avx2(lv_16sc_t* resul
 
     if (sse_iters > 0)
         {
-            __VOLK_ATTR_ALIGNED(32) lv_16sc_t dotProductVector[8];
+            __VOLK_ATTR_ALIGNED(32)
+            lv_16sc_t dotProductVector[8];
 
             __m256i* realcacc = (__m256i*)volk_gnsssdr_malloc(num_a_vectors * sizeof(__m256i), volk_gnsssdr_get_alignment());
             __m256i* imagcacc = (__m256i*)volk_gnsssdr_malloc(num_a_vectors * sizeof(__m256i), volk_gnsssdr_get_alignment());
@@ -423,24 +427,24 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_u_avx2(lv_16sc_t* resul
             mask_imag = _mm256_set_epi8(0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
             mask_real = _mm256_set_epi8(0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
 
-            for(index = 0; index < sse_iters; index++)
+            for (index = 0; index < sse_iters; index++)
                 {
                     b = _mm256_loadu_si256((__m256i*)_in_common);
                     __VOLK_GNSSSDR_PREFETCH(_in_common + 16);
                     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
                         {
-                            a = _mm256_loadu_si256((__m256i*)&(_in_a[n_vec][index*8]));
+                            a = _mm256_loadu_si256((__m256i*)&(_in_a[n_vec][index * 8]));
 
                             c = _mm256_mullo_epi16(a, b);
 
-                            c_sr = _mm256_srli_si256(c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
+                            c_sr = _mm256_srli_si256(c, 2);  // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
                             real = _mm256_subs_epi16(c, c_sr);
 
-                            c_sr = _mm256_slli_si256(b, 2); // b3.r, b2.i ....
-                            c = _mm256_mullo_epi16(a, c_sr); // a3.i*b3.r, ....
+                            c_sr = _mm256_slli_si256(b, 2);   // b3.r, b2.i ....
+                            c = _mm256_mullo_epi16(a, c_sr);  // a3.i*b3.r, ....
 
-                            c_sr = _mm256_slli_si256(a, 2); // a3.r, a2.i ....
-                            imag = _mm256_mullo_epi16(b, c_sr); // b3.i*a3.r, ....
+                            c_sr = _mm256_slli_si256(a, 2);      // a3.r, a2.i ....
+                            imag = _mm256_mullo_epi16(b, c_sr);  // b3.i*a3.r, ....
 
                             imag = _mm256_adds_epi16(c, imag);
 
@@ -457,12 +461,12 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_u_avx2(lv_16sc_t* resul
 
                     a = _mm256_or_si256(realcacc[n_vec], imagcacc[n_vec]);
 
-                    _mm256_store_si256((__m256i*)dotProductVector, a); // Store the results back into the dot product vector
-                    dotProduct = lv_cmake(0,0);
+                    _mm256_store_si256((__m256i*)dotProductVector, a);  // Store the results back into the dot product vector
+                    dotProduct = lv_cmake(0, 0);
                     for (index = 0; index < 8; ++index)
                         {
                             dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[index])),
-                                    sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[index])));
+                                sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[index])));
                         }
                     _out[n_vec] = dotProduct;
                 }
@@ -473,12 +477,12 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_u_avx2(lv_16sc_t* resul
 
     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
         {
-            for(index = sse_iters * 8; index < num_points; index++)
+            for (index = sse_iters * 8; index < num_points; index++)
                 {
                     lv_16sc_t tmp = in_common[index] * in_a[n_vec][index];
 
                     _out[n_vec] = lv_cmake(sat_adds16i(lv_creal(_out[n_vec]), lv_creal(tmp)),
-                            sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
+                        sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
                 }
         }
 }
@@ -488,9 +492,9 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_u_avx2(lv_16sc_t* resul
 #ifdef LV_HAVE_NEON
 #include <arm_neon.h>
 
-static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon(lv_16sc_t* result, const lv_16sc_t* in_common, const lv_16sc_t** in_a,  int num_a_vectors, unsigned int num_points)
+static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon(lv_16sc_t* result, const lv_16sc_t* in_common, const lv_16sc_t** in_a, int num_a_vectors, unsigned int num_points)
 {
-    lv_16sc_t dotProduct = lv_cmake(0,0);
+    lv_16sc_t dotProduct = lv_cmake(0, 0);
     int n_vec;
     unsigned int index;
     const unsigned int neon_iters = num_points / 4;
@@ -501,7 +505,8 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon(lv_16sc_t* result,
 
     if (neon_iters > 0)
         {
-            __VOLK_ATTR_ALIGNED(16) lv_16sc_t dotProductVector[4];
+            __VOLK_ATTR_ALIGNED(16)
+            lv_16sc_t dotProductVector[4];
 
             int16x4x2_t a_val, b_val, c_val;
 
@@ -509,19 +514,19 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon(lv_16sc_t* result,
 
             int16x4x2_t tmp_real, tmp_imag;
 
-            for(n_vec = 0; n_vec < num_a_vectors; n_vec++)
+            for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
                 {
                     accumulator[n_vec].val[0] = vdup_n_s16(0);
                     accumulator[n_vec].val[1] = vdup_n_s16(0);
                 }
 
-            for(index = 0; index < neon_iters; index++)
+            for (index = 0; index < neon_iters; index++)
                 {
-                    b_val = vld2_s16((int16_t*)_in_common); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
+                    b_val = vld2_s16((int16_t*)_in_common);  //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
                     __VOLK_GNSSSDR_PREFETCH(_in_common + 8);
                     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
                         {
-                            a_val = vld2_s16((int16_t*)&(_in_a[n_vec][index*4])); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
+                            a_val = vld2_s16((int16_t*)&(_in_a[n_vec][index * 4]));  //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
                             //__VOLK_GNSSSDR_PREFETCH(&_in_a[n_vec][index*4] + 8);
 
                             // multiply the real*real and imag*imag to get real result
@@ -547,12 +552,12 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon(lv_16sc_t* result,
 
             for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
                 {
-                    vst2_s16((int16_t*)dotProductVector, accumulator[n_vec]); // Store the results back into the dot product vector
-                    dotProduct = lv_cmake(0,0);
+                    vst2_s16((int16_t*)dotProductVector, accumulator[n_vec]);  // Store the results back into the dot product vector
+                    dotProduct = lv_cmake(0, 0);
                     for (index = 0; index < 4; ++index)
                         {
                             dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[index])),
-                                    sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[index])));
+                                sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[index])));
                         }
                     _out[n_vec] = dotProduct;
                 }
@@ -561,12 +566,12 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon(lv_16sc_t* result,
 
     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
         {
-            for(index = neon_iters * 4; index < num_points; index++)
+            for (index = neon_iters * 4; index < num_points; index++)
                 {
                     lv_16sc_t tmp = in_common[index] * in_a[n_vec][index];
 
                     _out[n_vec] = lv_cmake(sat_adds16i(lv_creal(_out[n_vec]), lv_creal(tmp)),
-                            sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
+                        sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
                 }
         }
 }
@@ -576,9 +581,9 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon(lv_16sc_t* result,
 #ifdef LV_HAVE_NEON
 #include <arm_neon.h>
 
-static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon_vma(lv_16sc_t* result, const lv_16sc_t* in_common, const lv_16sc_t** in_a,  int num_a_vectors, unsigned int num_points)
+static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon_vma(lv_16sc_t* result, const lv_16sc_t* in_common, const lv_16sc_t** in_a, int num_a_vectors, unsigned int num_points)
 {
-    lv_16sc_t dotProduct = lv_cmake(0,0);
+    lv_16sc_t dotProduct = lv_cmake(0, 0);
 
     const unsigned int neon_iters = num_points / 4;
     int n_vec;
@@ -589,25 +594,26 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon_vma(lv_16sc_t* res
 
     if (neon_iters > 0)
         {
-            __VOLK_ATTR_ALIGNED(16) lv_16sc_t dotProductVector[4];
+            __VOLK_ATTR_ALIGNED(16)
+            lv_16sc_t dotProductVector[4];
 
             int16x4x2_t a_val, b_val, tmp;
 
             int16x4x2_t* accumulator = (int16x4x2_t*)volk_gnsssdr_malloc(num_a_vectors * sizeof(int16x4x2_t), volk_gnsssdr_get_alignment());
 
-            for(n_vec = 0; n_vec < num_a_vectors; n_vec++)
+            for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
                 {
                     accumulator[n_vec].val[0] = vdup_n_s16(0);
                     accumulator[n_vec].val[1] = vdup_n_s16(0);
                 }
 
-            for(index = 0; index < neon_iters; index++)
+            for (index = 0; index < neon_iters; index++)
                 {
-                    b_val = vld2_s16((int16_t*)_in_common); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
+                    b_val = vld2_s16((int16_t*)_in_common);  //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
                     __VOLK_GNSSSDR_PREFETCH(_in_common + 8);
                     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
                         {
-                            a_val = vld2_s16((int16_t*)&(_in_a[n_vec][index*4]));
+                            a_val = vld2_s16((int16_t*)&(_in_a[n_vec][index * 4]));
 
                             tmp.val[0] = vmul_s16(a_val.val[0], b_val.val[0]);
                             tmp.val[1] = vmul_s16(a_val.val[1], b_val.val[0]);
@@ -624,12 +630,12 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon_vma(lv_16sc_t* res
 
             for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
                 {
-                    vst2_s16((int16_t*)dotProductVector, accumulator[n_vec]); // Store the results back into the dot product vector
-                    dotProduct = lv_cmake(0,0);
+                    vst2_s16((int16_t*)dotProductVector, accumulator[n_vec]);  // Store the results back into the dot product vector
+                    dotProduct = lv_cmake(0, 0);
                     for (index = 0; index < 4; ++index)
                         {
                             dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[index])),
-                                    sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[index])));
+                                sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[index])));
                         }
                     _out[n_vec] = dotProduct;
                 }
@@ -638,12 +644,12 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon_vma(lv_16sc_t* res
 
     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
         {
-            for(index = neon_iters * 4; index < num_points; index++)
+            for (index = neon_iters * 4; index < num_points; index++)
                 {
                     lv_16sc_t tmp = in_common[index] * in_a[n_vec][index];
 
                     _out[n_vec] = lv_cmake(sat_adds16i(lv_creal(_out[n_vec]), lv_creal(tmp)),
-                            sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
+                        sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
                 }
         }
 }
@@ -653,9 +659,9 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon_vma(lv_16sc_t* res
 #ifdef LV_HAVE_NEON
 #include <arm_neon.h>
 
-static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon_optvma(lv_16sc_t* result, const lv_16sc_t* in_common, const lv_16sc_t** in_a,  int num_a_vectors, unsigned int num_points)
+static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon_optvma(lv_16sc_t* result, const lv_16sc_t* in_common, const lv_16sc_t** in_a, int num_a_vectors, unsigned int num_points)
 {
-    lv_16sc_t dotProduct = lv_cmake(0,0);
+    lv_16sc_t dotProduct = lv_cmake(0, 0);
 
     const unsigned int neon_iters = num_points / 4;
     int n_vec;
@@ -666,14 +672,15 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon_optvma(lv_16sc_t*
 
     if (neon_iters > 0)
         {
-            __VOLK_ATTR_ALIGNED(16) lv_16sc_t dotProductVector[4];
+            __VOLK_ATTR_ALIGNED(16)
+            lv_16sc_t dotProductVector[4];
 
             int16x4x2_t a_val, b_val;
 
             int16x4x2_t* accumulator1 = (int16x4x2_t*)volk_gnsssdr_malloc(num_a_vectors * sizeof(int16x4x2_t), volk_gnsssdr_get_alignment());
             int16x4x2_t* accumulator2 = (int16x4x2_t*)volk_gnsssdr_malloc(num_a_vectors * sizeof(int16x4x2_t), volk_gnsssdr_get_alignment());
 
-            for(n_vec = 0; n_vec < num_a_vectors; n_vec++)
+            for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
                 {
                     accumulator1[n_vec].val[0] = vdup_n_s16(0);
                     accumulator1[n_vec].val[1] = vdup_n_s16(0);
@@ -681,13 +688,13 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon_optvma(lv_16sc_t*
                     accumulator2[n_vec].val[1] = vdup_n_s16(0);
                 }
 
-            for(index = 0; index < neon_iters; index++)
+            for (index = 0; index < neon_iters; index++)
                 {
-                    b_val = vld2_s16((int16_t*)_in_common); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
+                    b_val = vld2_s16((int16_t*)_in_common);  //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
                     __VOLK_GNSSSDR_PREFETCH(_in_common + 8);
                     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
                         {
-                            a_val = vld2_s16((int16_t*)&(_in_a[n_vec][index*4]));
+                            a_val = vld2_s16((int16_t*)&(_in_a[n_vec][index * 4]));
 
                             accumulator1[n_vec].val[0] = vmla_s16(accumulator1[n_vec].val[0], a_val.val[0], b_val.val[0]);
                             accumulator1[n_vec].val[1] = vmla_s16(accumulator1[n_vec].val[1], a_val.val[0], b_val.val[1]);
@@ -705,12 +712,12 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon_optvma(lv_16sc_t*
 
             for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
                 {
-                    vst2_s16((int16_t*)dotProductVector, accumulator1[n_vec]); // Store the results back into the dot product vector
-                    dotProduct = lv_cmake(0,0);
+                    vst2_s16((int16_t*)dotProductVector, accumulator1[n_vec]);  // Store the results back into the dot product vector
+                    dotProduct = lv_cmake(0, 0);
                     for (index = 0; index < 4; ++index)
                         {
                             dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[index])),
-                                    sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[index])));
+                                sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[index])));
                         }
                     _out[n_vec] = dotProduct;
                 }
@@ -720,12 +727,12 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon_optvma(lv_16sc_t*
 
     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
         {
-            for(index = neon_iters * 4; index < num_points; index++)
+            for (index = neon_iters * 4; index < num_points; index++)
                 {
                     lv_16sc_t tmp = in_common[index] * in_a[n_vec][index];
 
                     _out[n_vec] = lv_cmake(sat_adds16i(lv_creal(_out[n_vec]), lv_creal(tmp)),
-                            sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
+                        sat_adds16i(lv_cimag(_out[n_vec]), lv_cimag(tmp)));
                 }
         }
 }

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic.h

@@ -47,22 +47,22 @@ static inline void volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic_generic(lv_16sc_t*
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
     unsigned int n;
-    for(n = 0; n < num_a_vectors; n++)
-    {
-       in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
-       memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
-    }
+    for (n = 0; n < num_a_vectors; n++)
+        {
+            in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+            memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
+        }
 
-    volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_generic(result, local_code, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_generic(result, local_code, (const lv_16sc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
-    {
-        volk_gnsssdr_free(in_a[n]);
-    }
+    for (n = 0; n < num_a_vectors; n++)
+        {
+            volk_gnsssdr_free(in_a[n]);
+        }
     volk_gnsssdr_free(in_a);
 }
 
-#endif  /* Generic */
+#endif /* Generic */
 
 
 #ifdef LV_HAVE_GENERIC
@@ -71,22 +71,22 @@ static inline void volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic_generic_sat(lv_16sc
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
     unsigned int n;
-    for(n = 0; n < num_a_vectors; n++)
-    {
-       in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
-       memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
-    }
+    for (n = 0; n < num_a_vectors; n++)
+        {
+            in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+            memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
+        }
 
-    volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_generic_sat(result, local_code, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_generic_sat(result, local_code, (const lv_16sc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
-    {
-        volk_gnsssdr_free(in_a[n]);
-    }
+    for (n = 0; n < num_a_vectors; n++)
+        {
+            volk_gnsssdr_free(in_a[n]);
+        }
     volk_gnsssdr_free(in_a);
 }
 
-#endif  /* Generic */
+#endif /* Generic */
 
 
 #ifdef LV_HAVE_SSE2
@@ -95,18 +95,18 @@ static inline void volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic_a_sse2(lv_16sc_t* r
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
     unsigned int n;
-    for(n = 0; n < num_a_vectors; n++)
-    {
-       in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
-       memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
-    }
+    for (n = 0; n < num_a_vectors; n++)
+        {
+            in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+            memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
+        }
 
-    volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_a_sse2(result, local_code, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_a_sse2(result, local_code, (const lv_16sc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
-    {
-        volk_gnsssdr_free(in_a[n]);
-    }
+    for (n = 0; n < num_a_vectors; n++)
+        {
+            volk_gnsssdr_free(in_a[n]);
+        }
     volk_gnsssdr_free(in_a);
 }
 
@@ -120,18 +120,18 @@ static inline void volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic_u_sse2(lv_16sc_t* r
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
     unsigned int n;
-    for(n = 0; n < num_a_vectors; n++)
-    {
-       in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t)*num_points, volk_gnsssdr_get_alignment());
-       memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t)*num_points);
-    }
+    for (n = 0; n < num_a_vectors; n++)
+        {
+            in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+            memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
+        }
 
-    volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_u_sse2(result, local_code, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_u_sse2(result, local_code, (const lv_16sc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
-    {
-        volk_gnsssdr_free(in_a[n]);
-    }
+    for (n = 0; n < num_a_vectors; n++)
+        {
+            volk_gnsssdr_free(in_a[n]);
+        }
     volk_gnsssdr_free(in_a);
 }
 
@@ -145,18 +145,18 @@ static inline void volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic_a_avx2(lv_16sc_t* r
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
     unsigned int n;
-    for(n = 0; n < num_a_vectors; n++)
-    {
-       in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t)*num_points, volk_gnsssdr_get_alignment());
-       memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t)*num_points);
-    }
+    for (n = 0; n < num_a_vectors; n++)
+        {
+            in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+            memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
+        }
 
-    volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_a_avx2(result, local_code, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_a_avx2(result, local_code, (const lv_16sc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
-    {
-        volk_gnsssdr_free(in_a[n]);
-    }
+    for (n = 0; n < num_a_vectors; n++)
+        {
+            volk_gnsssdr_free(in_a[n]);
+        }
     volk_gnsssdr_free(in_a);
 }
 
@@ -170,18 +170,18 @@ static inline void volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic_u_avx2(lv_16sc_t* r
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
     unsigned int n;
-    for(n = 0; n < num_a_vectors; n++)
-    {
-       in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t)*num_points, volk_gnsssdr_get_alignment());
-       memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t)*num_points);
-    }
+    for (n = 0; n < num_a_vectors; n++)
+        {
+            in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+            memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
+        }
 
-    volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_u_avx2(result, local_code, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_u_avx2(result, local_code, (const lv_16sc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
-    {
-        volk_gnsssdr_free(in_a[n]);
-    }
+    for (n = 0; n < num_a_vectors; n++)
+        {
+            volk_gnsssdr_free(in_a[n]);
+        }
     volk_gnsssdr_free(in_a);
 }
 
@@ -195,22 +195,22 @@ static inline void volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic_neon(lv_16sc_t* res
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
     unsigned int n;
-    for(n = 0; n < num_a_vectors; n++)
-    {
-       in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t)*num_points, volk_gnsssdr_get_alignment());
-       memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t)*num_points);
-    }
+    for (n = 0; n < num_a_vectors; n++)
+        {
+            in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+            memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
+        }
 
-    volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon(result, local_code, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon(result, local_code, (const lv_16sc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
-    {
-        volk_gnsssdr_free(in_a[n]);
-    }
+    for (n = 0; n < num_a_vectors; n++)
+        {
+            volk_gnsssdr_free(in_a[n]);
+        }
     volk_gnsssdr_free(in_a);
 }
 
-#endif // NEON
+#endif  // NEON
 
 
 #ifdef LV_HAVE_NEON
@@ -220,22 +220,22 @@ static inline void volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic_neon_vma(lv_16sc_t*
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
     unsigned int n;
-    for(n = 0; n < num_a_vectors; n++)
-    {
-       in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t)*num_points, volk_gnsssdr_get_alignment());
-       memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t)*num_points);
-    }
+    for (n = 0; n < num_a_vectors; n++)
+        {
+            in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+            memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
+        }
 
-    volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon_vma(result, local_code, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon_vma(result, local_code, (const lv_16sc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
-    {
-        volk_gnsssdr_free(in_a[n]);
-    }
+    for (n = 0; n < num_a_vectors; n++)
+        {
+            volk_gnsssdr_free(in_a[n]);
+        }
     volk_gnsssdr_free(in_a);
 }
 
-#endif // NEON
+#endif  // NEON
 
 #ifdef LV_HAVE_NEON
 
@@ -244,23 +244,21 @@ static inline void volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic_neon_optvma(lv_16sc
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
     unsigned int n;
-    for(n = 0; n < num_a_vectors; n++)
-    {
-       in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t)*num_points, volk_gnsssdr_get_alignment());
-       memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t)*num_points);
-    }
+    for (n = 0; n < num_a_vectors; n++)
+        {
+            in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
+            memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
+        }
 
-    volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon_optvma(result, local_code, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon_optvma(result, local_code, (const lv_16sc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
-    {
-        volk_gnsssdr_free(in_a[n]);
-    }
+    for (n = 0; n < num_a_vectors; n++)
+        {
+            volk_gnsssdr_free(in_a[n]);
+        }
     volk_gnsssdr_free(in_a);
 }
 
-#endif // NEON
+#endif  // NEON
 
 #endif  // INCLUDED_volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic_H
-
-

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_multiply_16ic.h

@@ -91,29 +91,29 @@ static inline void volk_gnsssdr_16ic_x2_multiply_16ic_a_sse2(lv_16sc_t* out, con
     const lv_16sc_t* _in_a = in_a;
     const lv_16sc_t* _in_b = in_b;
     lv_16sc_t* _out = out;
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             //std::complex<T> memory structure: real part -> reinterpret_cast<cv T*>(a)[2*i]
             //imaginery part -> reinterpret_cast<cv T*>(a)[2*i + 1]
             // a[127:0]=[a3.i,a3.r,a2.i,a2.r,a1.i,a1.r,a0.i,a0.r]
-            a = _mm_load_si128((__m128i*)_in_a); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
+            a = _mm_load_si128((__m128i*)_in_a);  //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
             b = _mm_load_si128((__m128i*)_in_b);
-            c = _mm_mullo_epi16 (a, b); // a3.i*b3.i, a3.r*b3.r, ....
+            c = _mm_mullo_epi16(a, b);  // a3.i*b3.i, a3.r*b3.r, ....
 
-            c_sr = _mm_srli_si128 (c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
-            real = _mm_subs_epi16 (c, c_sr);
-            real = _mm_and_si128 (real, mask_real); // a3.r*b3.r-a3.i*b3.i , 0,  a3.r*b3.r- a3.i*b3.i
+            c_sr = _mm_srli_si128(c, 2);  // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
+            real = _mm_subs_epi16(c, c_sr);
+            real = _mm_and_si128(real, mask_real);  // a3.r*b3.r-a3.i*b3.i , 0,  a3.r*b3.r- a3.i*b3.i
 
-            b_sl = _mm_slli_si128(b, 2); // b3.r, b2.i ....
-            a_sl = _mm_slli_si128(a, 2); // a3.r, a2.i ....
+            b_sl = _mm_slli_si128(b, 2);  // b3.r, b2.i ....
+            a_sl = _mm_slli_si128(a, 2);  // a3.r, a2.i ....
 
-            imag1 = _mm_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
-            imag2 = _mm_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
+            imag1 = _mm_mullo_epi16(a, b_sl);  // a3.i*b3.r, ....
+            imag2 = _mm_mullo_epi16(b, a_sl);  // b3.i*a3.r, ....
 
             imag = _mm_adds_epi16(imag1, imag2);
-            imag = _mm_and_si128 (imag, mask_imag); // a3.i*b3.r+b3.i*a3.r, 0, ...
+            imag = _mm_and_si128(imag, mask_imag);  // a3.i*b3.r+b3.i*a3.r, 0, ...
 
-            result = _mm_or_si128 (real, imag);
+            result = _mm_or_si128(real, imag);
 
             _mm_store_si128((__m128i*)_out, result);
 
@@ -137,7 +137,7 @@ static inline void volk_gnsssdr_16ic_x2_multiply_16ic_u_sse2(lv_16sc_t* out, con
 {
     const unsigned int sse_iters = num_points / 4;
     unsigned int number;
-    __m128i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1,imag2, b_sl, a_sl, result;
+    __m128i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1, imag2, b_sl, a_sl, result;
 
     mask_imag = _mm_set_epi8(0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
     mask_real = _mm_set_epi8(0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
@@ -145,29 +145,29 @@ static inline void volk_gnsssdr_16ic_x2_multiply_16ic_u_sse2(lv_16sc_t* out, con
     const lv_16sc_t* _in_a = in_a;
     const lv_16sc_t* _in_b = in_b;
     lv_16sc_t* _out = out;
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             //std::complex<T> memory structure: real part -> reinterpret_cast<cv T*>(a)[2*i]
             //imaginery part -> reinterpret_cast<cv T*>(a)[2*i + 1]
             // a[127:0]=[a3.i,a3.r,a2.i,a2.r,a1.i,a1.r,a0.i,a0.r]
-            a = _mm_loadu_si128((__m128i*)_in_a); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
+            a = _mm_loadu_si128((__m128i*)_in_a);  //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
             b = _mm_loadu_si128((__m128i*)_in_b);
-            c = _mm_mullo_epi16 (a, b); // a3.i*b3.i, a3.r*b3.r, ....
+            c = _mm_mullo_epi16(a, b);  // a3.i*b3.i, a3.r*b3.r, ....
 
-            c_sr = _mm_srli_si128 (c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
-            real = _mm_subs_epi16 (c, c_sr);
-            real = _mm_and_si128 (real, mask_real); // a3.r*b3.r-a3.i*b3.i , 0,  a3.r*b3.r- a3.i*b3.i
+            c_sr = _mm_srli_si128(c, 2);  // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
+            real = _mm_subs_epi16(c, c_sr);
+            real = _mm_and_si128(real, mask_real);  // a3.r*b3.r-a3.i*b3.i , 0,  a3.r*b3.r- a3.i*b3.i
 
-            b_sl = _mm_slli_si128(b, 2); // b3.r, b2.i ....
-            a_sl = _mm_slli_si128(a, 2); // a3.r, a2.i ....
+            b_sl = _mm_slli_si128(b, 2);  // b3.r, b2.i ....
+            a_sl = _mm_slli_si128(a, 2);  // a3.r, a2.i ....
 
-            imag1 = _mm_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
-            imag2 = _mm_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
+            imag1 = _mm_mullo_epi16(a, b_sl);  // a3.i*b3.r, ....
+            imag2 = _mm_mullo_epi16(b, a_sl);  // b3.i*a3.r, ....
 
             imag = _mm_adds_epi16(imag1, imag2);
-            imag = _mm_and_si128 (imag, mask_imag); // a3.i*b3.r+b3.i*a3.r, 0, ...
+            imag = _mm_and_si128(imag, mask_imag);  // a3.i*b3.r+b3.i*a3.r, 0, ...
 
-            result = _mm_or_si128 (real, imag);
+            result = _mm_or_si128(real, imag);
 
             _mm_storeu_si128((__m128i*)_out, result);
 
@@ -196,29 +196,29 @@ static inline void volk_gnsssdr_16ic_x2_multiply_16ic_u_avx2(lv_16sc_t* out, con
     const lv_16sc_t* _in_b = in_b;
     lv_16sc_t* _out = out;
 
-    __m256i a, b, c, c_sr,  real, imag, imag1, imag2, b_sl, a_sl, result;
+    __m256i a, b, c, c_sr, real, imag, imag1, imag2, b_sl, a_sl, result;
 
     const __m256i mask_imag = _mm256_set_epi8(0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
     const __m256i mask_real = _mm256_set_epi8(0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
 
-    for(;number < avx2_points; number++)
+    for (; number < avx2_points; number++)
         {
-            a = _mm256_loadu_si256((__m256i*)_in_a); // Load the ar + ai, br + bi as ar,ai,br,bi
-            b = _mm256_loadu_si256((__m256i*)_in_b); // Load the cr + ci, dr + di as cr,ci,dr,di
+            a = _mm256_loadu_si256((__m256i*)_in_a);  // Load the ar + ai, br + bi as ar,ai,br,bi
+            b = _mm256_loadu_si256((__m256i*)_in_b);  // Load the cr + ci, dr + di as cr,ci,dr,di
             c = _mm256_mullo_epi16(a, b);
 
-            c_sr = _mm256_srli_si256(c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
+            c_sr = _mm256_srli_si256(c, 2);  // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
             real = _mm256_subs_epi16(c, c_sr);
-            real = _mm256_and_si256(real, mask_real); // a3.r*b3.r-a3.i*b3.i , 0,  a3.r*b3.r- a3.i*b3.i
+            real = _mm256_and_si256(real, mask_real);  // a3.r*b3.r-a3.i*b3.i , 0,  a3.r*b3.r- a3.i*b3.i
 
-            b_sl = _mm256_slli_si256(b, 2); // b3.r, b2.i ....
-            a_sl = _mm256_slli_si256(a, 2); // a3.r, a2.i ....
+            b_sl = _mm256_slli_si256(b, 2);  // b3.r, b2.i ....
+            a_sl = _mm256_slli_si256(a, 2);  // a3.r, a2.i ....
 
-            imag1 = _mm256_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
-            imag2 = _mm256_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
+            imag1 = _mm256_mullo_epi16(a, b_sl);  // a3.i*b3.r, ....
+            imag2 = _mm256_mullo_epi16(b, a_sl);  // b3.i*a3.r, ....
 
             imag = _mm256_adds_epi16(imag1, imag2);
-            imag = _mm256_and_si256(imag, mask_imag); // a3.i*b3.r+b3.i*a3.r, 0, ...
+            imag = _mm256_and_si256(imag, mask_imag);  // a3.i*b3.r+b3.i*a3.r, 0, ...
 
             result = _mm256_or_si256(real, imag);
 
@@ -230,7 +230,7 @@ static inline void volk_gnsssdr_16ic_x2_multiply_16ic_u_avx2(lv_16sc_t* out, con
         }
     _mm256_zeroupper();
     number = avx2_points * 8;
-    for(;number < num_points; number++)
+    for (; number < num_points; number++)
         {
             *_out++ = (*_in_a++) * (*_in_b++);
         }
@@ -250,29 +250,29 @@ static inline void volk_gnsssdr_16ic_x2_multiply_16ic_a_avx2(lv_16sc_t* out, con
     const lv_16sc_t* _in_b = in_b;
     lv_16sc_t* _out = out;
 
-    __m256i a, b, c, c_sr,  real, imag, imag1, imag2, b_sl, a_sl, result;
+    __m256i a, b, c, c_sr, real, imag, imag1, imag2, b_sl, a_sl, result;
 
     const __m256i mask_imag = _mm256_set_epi8(0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
     const __m256i mask_real = _mm256_set_epi8(0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
 
-    for(;number < avx2_points; number++)
+    for (; number < avx2_points; number++)
         {
-            a = _mm256_load_si256((__m256i*)_in_a); // Load the ar + ai, br + bi as ar,ai,br,bi
-            b = _mm256_load_si256((__m256i*)_in_b); // Load the cr + ci, dr + di as cr,ci,dr,di
+            a = _mm256_load_si256((__m256i*)_in_a);  // Load the ar + ai, br + bi as ar,ai,br,bi
+            b = _mm256_load_si256((__m256i*)_in_b);  // Load the cr + ci, dr + di as cr,ci,dr,di
             c = _mm256_mullo_epi16(a, b);
 
-            c_sr = _mm256_srli_si256(c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
+            c_sr = _mm256_srli_si256(c, 2);  // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
             real = _mm256_subs_epi16(c, c_sr);
-            real = _mm256_and_si256(real, mask_real); // a3.r*b3.r-a3.i*b3.i , 0,  a3.r*b3.r- a3.i*b3.i
+            real = _mm256_and_si256(real, mask_real);  // a3.r*b3.r-a3.i*b3.i , 0,  a3.r*b3.r- a3.i*b3.i
 
-            b_sl = _mm256_slli_si256(b, 2); // b3.r, b2.i ....
-            a_sl = _mm256_slli_si256(a, 2); // a3.r, a2.i ....
+            b_sl = _mm256_slli_si256(b, 2);  // b3.r, b2.i ....
+            a_sl = _mm256_slli_si256(a, 2);  // a3.r, a2.i ....
 
-            imag1 = _mm256_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
-            imag2 = _mm256_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
+            imag1 = _mm256_mullo_epi16(a, b_sl);  // a3.i*b3.r, ....
+            imag2 = _mm256_mullo_epi16(b, a_sl);  // b3.i*a3.r, ....
 
             imag = _mm256_adds_epi16(imag1, imag2);
-            imag = _mm256_and_si256(imag, mask_imag); // a3.i*b3.r+b3.i*a3.r, 0, ...
+            imag = _mm256_and_si256(imag, mask_imag);  // a3.i*b3.r+b3.i*a3.r, 0, ...
 
             result = _mm256_or_si256(real, imag);
 
@@ -284,7 +284,7 @@ static inline void volk_gnsssdr_16ic_x2_multiply_16ic_a_avx2(lv_16sc_t* out, con
         }
     _mm256_zeroupper();
     number = avx2_points * 8;
-    for(;number < num_points; number++)
+    for (; number < num_points; number++)
         {
             *_out++ = (*_in_a++) * (*_in_b++);
         }
@@ -292,23 +292,22 @@ static inline void volk_gnsssdr_16ic_x2_multiply_16ic_a_avx2(lv_16sc_t* out, con
 #endif /* LV_HAVE_AVX2  */
 
 
-
 #ifdef LV_HAVE_NEON
 #include <arm_neon.h>
 
 static inline void volk_gnsssdr_16ic_x2_multiply_16ic_neon(lv_16sc_t* out, const lv_16sc_t* in_a, const lv_16sc_t* in_b, unsigned int num_points)
 {
-    lv_16sc_t *a_ptr = (lv_16sc_t*) in_a;
-    lv_16sc_t *b_ptr = (lv_16sc_t*) in_b;
+    lv_16sc_t* a_ptr = (lv_16sc_t*)in_a;
+    lv_16sc_t* b_ptr = (lv_16sc_t*)in_b;
     unsigned int quarter_points = num_points / 4;
     int16x4x2_t a_val, b_val, c_val;
     int16x4x2_t tmp_real, tmp_imag;
     unsigned int number = 0;
 
-    for(number = 0; number < quarter_points; ++number)
+    for (number = 0; number < quarter_points; ++number)
         {
-            a_val = vld2_s16((int16_t*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
-            b_val = vld2_s16((int16_t*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
+            a_val = vld2_s16((int16_t*)a_ptr);  // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
+            b_val = vld2_s16((int16_t*)b_ptr);  // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
             __VOLK_GNSSSDR_PREFETCH(a_ptr + 4);
             __VOLK_GNSSSDR_PREFETCH(b_ptr + 4);
 
@@ -334,7 +333,7 @@ static inline void volk_gnsssdr_16ic_x2_multiply_16ic_neon(lv_16sc_t* out, const
             out += 4;
         }
 
-    for(number = quarter_points * 4; number < num_points; number++)
+    for (number = quarter_points * 4; number < num_points; number++)
         {
             *out++ = (*a_ptr++) * (*b_ptr++);
         }

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic.h

@@ -41,7 +41,7 @@
 #include <string.h>
 
 #ifdef LV_HAVE_GENERIC
-static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_generic(lv_16sc_t* result, const lv_16sc_t* local_code,  const lv_16sc_t* in, unsigned int num_points)
+static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_generic(lv_16sc_t* result, const lv_16sc_t* local_code, const lv_16sc_t* in, unsigned int num_points)
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.345;
@@ -53,14 +53,14 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_generic(lv_
     unsigned int n;
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
         }
-    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_generic(result, local_code, phase_inc[0], phase,(const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_generic(result, local_code, phase_inc[0], phase, (const lv_16sc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
@@ -71,7 +71,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_generic(lv_
 
 
 #ifdef LV_HAVE_GENERIC
-static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_generic_reload(lv_16sc_t* result, const lv_16sc_t* local_code,  const lv_16sc_t* in, unsigned int num_points)
+static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_generic_reload(lv_16sc_t* result, const lv_16sc_t* local_code, const lv_16sc_t* in, unsigned int num_points)
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.345;
@@ -83,14 +83,14 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_generic_rel
     unsigned int n;
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
         }
-    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_generic_reload(result, local_code, phase_inc[0], phase,(const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_generic_reload(result, local_code, phase_inc[0], phase, (const lv_16sc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
@@ -113,22 +113,22 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_a_sse3(lv_1
     unsigned int n;
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
         }
 
-    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_sse3(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_sse3(result, local_code, phase_inc[0], phase, (const lv_16sc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
     volk_gnsssdr_free(in_a);
 }
 
-#endif // SSE3
+#endif  // SSE3
 
 
 #ifdef LV_HAVE_SSE3
@@ -144,22 +144,22 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_a_sse3_relo
     unsigned int n;
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
         }
 
-    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_sse3_reload(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_sse3_reload(result, local_code, phase_inc[0], phase, (const lv_16sc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
     volk_gnsssdr_free(in_a);
 }
 
-#endif // SSE3
+#endif  // SSE3
 
 
 #ifdef LV_HAVE_SSE3
@@ -175,22 +175,22 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_u_sse3(lv_1
     unsigned int n;
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
         }
 
-    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_u_sse3(result, local_code, phase_inc[0], phase, (const lv_16sc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
     volk_gnsssdr_free(in_a);
 }
 
-#endif // SSE3
+#endif  // SSE3
 
 
 #ifdef LV_HAVE_AVX2
@@ -206,22 +206,22 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_a_avx2(lv_1
     unsigned int n;
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
         }
 
-    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_avx2(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_avx2(result, local_code, phase_inc[0], phase, (const lv_16sc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
     volk_gnsssdr_free(in_a);
 }
 
-#endif // AVX2
+#endif  // AVX2
 
 
 #ifdef LV_HAVE_AVX2
@@ -237,22 +237,22 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_a_avx2_relo
     unsigned int n;
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
         }
 
-    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_avx2_reload(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_avx2_reload(result, local_code, phase_inc[0], phase, (const lv_16sc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
     volk_gnsssdr_free(in_a);
 }
 
-#endif // AVX2
+#endif  // AVX2
 
 
 #ifdef LV_HAVE_AVX2
@@ -268,22 +268,22 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_u_avx2(lv_1
     unsigned int n;
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
         }
 
-    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_avx2(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_avx2(result, local_code, phase_inc[0], phase, (const lv_16sc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
     volk_gnsssdr_free(in_a);
 }
 
-#endif // AVX2
+#endif  // AVX2
 
 
 #ifdef LV_HAVE_AVX2
@@ -299,22 +299,22 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_u_avx2_relo
     unsigned int n;
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
         }
 
-    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_avx2_reload(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_a_avx2_reload(result, local_code, phase_inc[0], phase, (const lv_16sc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
     volk_gnsssdr_free(in_a);
 }
 
-#endif // AVX2
+#endif  // AVX2
 
 
 #ifdef LV_HAVE_NEON
@@ -330,22 +330,22 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_neon(lv_16s
     unsigned int n;
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
         }
 
-    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon(result, local_code, phase_inc[0], phase, (const lv_16sc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
     volk_gnsssdr_free(in_a);
 }
 
-#endif // NEON
+#endif  // NEON
 
 
 #ifdef LV_HAVE_NEON
@@ -361,23 +361,21 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_neon_vma(lv
     unsigned int n;
     int num_a_vectors = 3;
     lv_16sc_t** in_a = (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (lv_16sc_t*)volk_gnsssdr_malloc(sizeof(lv_16sc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_16sc_t*)in_a[n], (lv_16sc_t*)in, sizeof(lv_16sc_t) * num_points);
         }
 
-    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon_vma(result, local_code, phase_inc[0], phase, (const lv_16sc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_neon_vma(result, local_code, phase_inc[0], phase, (const lv_16sc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
     volk_gnsssdr_free(in_a);
 }
 
-#endif // NEON
+#endif  // NEON
 
 #endif  // INCLUDED_volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic_H
-
-

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_xn_resampler_16ic_xn.h

@@ -106,7 +106,8 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_a_sse4_1(lv_16sc_t** r
     const __m128 rem_code_phase_chips_reg = _mm_set_ps1(rem_code_phase_chips);
     const __m128 code_phase_step_chips_reg = _mm_set_ps1(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     int local_code_chip_index_;
 
     const __m128i zeros = _mm_setzero_si128();
@@ -120,7 +121,7 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_a_sse4_1(lv_16sc_t** r
             shifts_chips_reg = _mm_set_ps1((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             __m128 indexn = _mm_set_ps(3.0f, 2.0f, 1.0f, 0.0f);
-            for(n = 0; n < quarterPoints; n++)
+            for (n = 0; n < quarterPoints; n++)
                 {
                     aux = _mm_mul_ps(code_phase_step_chips_reg, indexn);
                     aux = _mm_add_ps(aux, aux2);
@@ -138,13 +139,13 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_a_sse4_1(lv_16sc_t** r
                     aux_i = _mm_and_si128(code_length_chips_reg_i, negatives);
                     local_code_chip_index_reg = _mm_add_epi32(local_code_chip_index_reg, aux_i);
                     _mm_store_si128((__m128i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 4; ++k)
+                    for (k = 0; k < 4; ++k)
                         {
                             _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
                         }
                     indexn = _mm_add_ps(indexn, fours);
                 }
-            for(n = quarterPoints * 4; n < num_points; n++)
+            for (n = quarterPoints * 4; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
@@ -172,7 +173,8 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_u_sse4_1(lv_16sc_t** r
     const __m128 rem_code_phase_chips_reg = _mm_set_ps1(rem_code_phase_chips);
     const __m128 code_phase_step_chips_reg = _mm_set_ps1(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     int local_code_chip_index_;
 
     const __m128i zeros = _mm_setzero_si128();
@@ -186,7 +188,7 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_u_sse4_1(lv_16sc_t** r
             shifts_chips_reg = _mm_set_ps1((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             __m128 indexn = _mm_set_ps(3.0f, 2.0f, 1.0f, 0.0f);
-            for(n = 0; n < quarterPoints; n++)
+            for (n = 0; n < quarterPoints; n++)
                 {
                     aux = _mm_mul_ps(code_phase_step_chips_reg, indexn);
                     aux = _mm_add_ps(aux, aux2);
@@ -204,13 +206,13 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_u_sse4_1(lv_16sc_t** r
                     aux_i = _mm_and_si128(code_length_chips_reg_i, negatives);
                     local_code_chip_index_reg = _mm_add_epi32(local_code_chip_index_reg, aux_i);
                     _mm_store_si128((__m128i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 4; ++k)
+                    for (k = 0; k < 4; ++k)
                         {
                             _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
                         }
                     indexn = _mm_add_ps(indexn, fours);
                 }
-            for(n = quarterPoints * 4; n < num_points; n++)
+            for (n = quarterPoints * 4; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
@@ -239,7 +241,8 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_a_sse3(lv_16sc_t** res
     const __m128 rem_code_phase_chips_reg = _mm_set_ps1(rem_code_phase_chips);
     const __m128 code_phase_step_chips_reg = _mm_set_ps1(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     int local_code_chip_index_;
 
     const __m128i zeros = _mm_setzero_si128();
@@ -253,7 +256,7 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_a_sse3(lv_16sc_t** res
             shifts_chips_reg = _mm_set_ps1((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             __m128 indexn = _mm_set_ps(3.0f, 2.0f, 1.0f, 0.0f);
-            for(n = 0; n < quarterPoints; n++)
+            for (n = 0; n < quarterPoints; n++)
                 {
                     aux = _mm_mul_ps(code_phase_step_chips_reg, indexn);
                     aux = _mm_add_ps(aux, aux2);
@@ -274,13 +277,13 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_a_sse3(lv_16sc_t** res
                     aux_i = _mm_and_si128(code_length_chips_reg_i, negatives);
                     local_code_chip_index_reg = _mm_add_epi32(local_code_chip_index_reg, aux_i);
                     _mm_store_si128((__m128i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 4; ++k)
+                    for (k = 0; k < 4; ++k)
                         {
                             _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
                         }
                     indexn = _mm_add_ps(indexn, fours);
                 }
-            for(n = quarterPoints * 4; n < num_points; n++)
+            for (n = quarterPoints * 4; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
@@ -309,7 +312,8 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_u_sse3(lv_16sc_t** res
     const __m128 rem_code_phase_chips_reg = _mm_set_ps1(rem_code_phase_chips);
     const __m128 code_phase_step_chips_reg = _mm_set_ps1(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     int local_code_chip_index_;
 
     const __m128i zeros = _mm_setzero_si128();
@@ -323,7 +327,7 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_u_sse3(lv_16sc_t** res
             shifts_chips_reg = _mm_set_ps1((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             __m128 indexn = _mm_set_ps(3.0f, 2.0f, 1.0f, 0.0f);
-            for(n = 0; n < quarterPoints; n++)
+            for (n = 0; n < quarterPoints; n++)
                 {
                     aux = _mm_mul_ps(code_phase_step_chips_reg, indexn);
                     aux = _mm_add_ps(aux, aux2);
@@ -344,13 +348,13 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_u_sse3(lv_16sc_t** res
                     aux_i = _mm_and_si128(code_length_chips_reg_i, negatives);
                     local_code_chip_index_reg = _mm_add_epi32(local_code_chip_index_reg, aux_i);
                     _mm_store_si128((__m128i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 4; ++k)
+                    for (k = 0; k < 4; ++k)
                         {
                             _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
                         }
                     indexn = _mm_add_ps(indexn, fours);
                 }
-            for(n = quarterPoints * 4; n < num_points; n++)
+            for (n = quarterPoints * 4; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
@@ -378,7 +382,8 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_a_avx(lv_16sc_t** resu
     const __m256 rem_code_phase_chips_reg = _mm256_set1_ps(rem_code_phase_chips);
     const __m256 code_phase_step_chips_reg = _mm256_set1_ps(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(32) int local_code_chip_index[8];
+    __VOLK_ATTR_ALIGNED(32)
+    int local_code_chip_index[8];
     int local_code_chip_index_;
 
     const __m256 zeros = _mm256_setzero_ps();
@@ -393,7 +398,7 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_a_avx(lv_16sc_t** resu
             shifts_chips_reg = _mm256_set1_ps((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm256_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             indexn = n0;
-            for(n = 0; n < avx_iters; n++)
+            for (n = 0; n < avx_iters; n++)
                 {
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&_result[current_correlator_tap][8 * n + 7], 1, 0);
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&local_code_chip_index[8], 1, 3);
@@ -411,13 +416,13 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_a_avx(lv_16sc_t** resu
 
                     // no negatives
                     c = _mm256_cvtepi32_ps(local_code_chip_index_reg);
-                    negatives = _mm256_cmp_ps(c, zeros, 0x01 );
+                    negatives = _mm256_cmp_ps(c, zeros, 0x01);
                     aux3 = _mm256_and_ps(code_length_chips_reg_f, negatives);
                     aux = _mm256_add_ps(c, aux3);
                     local_code_chip_index_reg = _mm256_cvttps_epi32(aux);
 
                     _mm256_store_si256((__m256i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 8; ++k)
+                    for (k = 0; k < 8; ++k)
                         {
                             _result[current_correlator_tap][n * 8 + k] = local_code[local_code_chip_index[k]];
                         }
@@ -427,7 +432,7 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_a_avx(lv_16sc_t** resu
     _mm256_zeroupper();
     for (current_correlator_tap = 0; current_correlator_tap < num_out_vectors; current_correlator_tap++)
         {
-            for(n = avx_iters * 8; n < num_points; n++)
+            for (n = avx_iters * 8; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
@@ -455,7 +460,8 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_u_avx(lv_16sc_t** resu
     const __m256 rem_code_phase_chips_reg = _mm256_set1_ps(rem_code_phase_chips);
     const __m256 code_phase_step_chips_reg = _mm256_set1_ps(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(32) int local_code_chip_index[8];
+    __VOLK_ATTR_ALIGNED(32)
+    int local_code_chip_index[8];
     int local_code_chip_index_;
 
     const __m256 zeros = _mm256_setzero_ps();
@@ -470,7 +476,7 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_u_avx(lv_16sc_t** resu
             shifts_chips_reg = _mm256_set1_ps((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm256_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             indexn = n0;
-            for(n = 0; n < avx_iters; n++)
+            for (n = 0; n < avx_iters; n++)
                 {
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&_result[current_correlator_tap][8 * n + 7], 1, 0);
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&local_code_chip_index[8], 1, 3);
@@ -488,13 +494,13 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_u_avx(lv_16sc_t** resu
 
                     // no negatives
                     c = _mm256_cvtepi32_ps(local_code_chip_index_reg);
-                    negatives = _mm256_cmp_ps(c, zeros, 0x01 );
+                    negatives = _mm256_cmp_ps(c, zeros, 0x01);
                     aux3 = _mm256_and_ps(code_length_chips_reg_f, negatives);
                     aux = _mm256_add_ps(c, aux3);
                     local_code_chip_index_reg = _mm256_cvttps_epi32(aux);
 
                     _mm256_store_si256((__m256i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 8; ++k)
+                    for (k = 0; k < 8; ++k)
                         {
                             _result[current_correlator_tap][n * 8 + k] = local_code[local_code_chip_index[k]];
                         }
@@ -504,7 +510,7 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_u_avx(lv_16sc_t** resu
     _mm256_zeroupper();
     for (current_correlator_tap = 0; current_correlator_tap < num_out_vectors; current_correlator_tap++)
         {
-            for(n = avx_iters * 8; n < num_points; n++)
+            for (n = avx_iters * 8; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
@@ -530,7 +536,8 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_neon(lv_16sc_t** resul
     const float32x4_t rem_code_phase_chips_reg = vdupq_n_f32(rem_code_phase_chips);
     const float32x4_t code_phase_step_chips_reg = vdupq_n_f32(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(16) int32_t local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int32_t local_code_chip_index[4];
     int32_t local_code_chip_index_;
 
     const int32x4_t zeros = vdupq_n_s32(0);
@@ -538,11 +545,12 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_neon(lv_16sc_t** resul
     const int32x4_t code_length_chips_reg_i = vdupq_n_s32((int32_t)code_length_chips);
     int32x4_t local_code_chip_index_reg, aux_i, negatives, i;
     float32x4_t aux, aux2, shifts_chips_reg, fi, c, j, cTrunc, base, indexn, reciprocal;
-    __VOLK_ATTR_ALIGNED(16) const float vec[4] = { 0.0f, 1.0f, 2.0f, 3.0f };
+    __VOLK_ATTR_ALIGNED(16)
+    const float vec[4] = {0.0f, 1.0f, 2.0f, 3.0f};
     uint32x4_t igx;
     reciprocal = vrecpeq_f32(code_length_chips_reg_f);
     reciprocal = vmulq_f32(vrecpsq_f32(code_length_chips_reg_f, reciprocal), reciprocal);
-    reciprocal = vmulq_f32(vrecpsq_f32(code_length_chips_reg_f, reciprocal), reciprocal); // this refinement is required!
+    reciprocal = vmulq_f32(vrecpsq_f32(code_length_chips_reg_f, reciprocal), reciprocal);  // this refinement is required!
     float32x4_t n0 = vld1q_f32((float*)vec);
     int current_correlator_tap;
     unsigned int n;
@@ -552,7 +560,7 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_neon(lv_16sc_t** resul
             shifts_chips_reg = vdupq_n_f32((float)shifts_chips[current_correlator_tap]);
             aux2 = vsubq_f32(shifts_chips_reg, rem_code_phase_chips_reg);
             indexn = n0;
-            for(n = 0; n < neon_iters; n++)
+            for (n = 0; n < neon_iters; n++)
                 {
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&_result[current_correlator_tap][4 * n + 3], 1, 0);
                     __VOLK_GNSSSDR_PREFETCH(&local_code_chip_index[4]);
@@ -568,7 +576,7 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_neon(lv_16sc_t** resul
 
                     // fmod
                     c = vmulq_f32(aux, reciprocal);
-                    i =  vcvtq_s32_f32(c);
+                    i = vcvtq_s32_f32(c);
                     cTrunc = vcvtq_f32_s32(i);
                     base = vmulq_f32(cTrunc, code_length_chips_reg_f);
                     aux = vsubq_f32(aux, base);
@@ -580,13 +588,13 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_neon(lv_16sc_t** resul
 
                     vst1q_s32((int32_t*)local_code_chip_index, local_code_chip_index_reg);
 
-                    for(k = 0; k < 4; ++k)
+                    for (k = 0; k < 4; ++k)
                         {
                             _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
                         }
                     indexn = vaddq_f32(indexn, fours);
                 }
-            for(n = neon_iters * 4; n < num_points; n++)
+            for (n = neon_iters * 4; n < num_points; n++)
                 {
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&_result[current_correlator_tap][n], 1, 0);
                     // resample code for current tap
@@ -604,4 +612,3 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_neon(lv_16sc_t** resul
 
 
 #endif /*INCLUDED_volk_gnsssdr_16ic_xn_resampler_16ic_xn_H*/
-

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn.h

@@ -95,69 +95,74 @@ static inline void volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn_generic(lv_16sc_t
 #ifdef LV_HAVE_SSE2
 #include <emmintrin.h>
 
-static inline void volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn_a_sse2(lv_16sc_t** result, const lv_16sc_t* local_code, float* rem_code_phase_chips ,float code_phase_step_chips, unsigned int code_length_chips, int num_out_vectors, unsigned int num_output_samples)
+static inline void volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn_a_sse2(lv_16sc_t** result, const lv_16sc_t* local_code, float* rem_code_phase_chips, float code_phase_step_chips, unsigned int code_length_chips, int num_out_vectors, unsigned int num_output_samples)
 {
-    _MM_SET_ROUNDING_MODE(_MM_ROUND_NEAREST);//_MM_ROUND_NEAREST, _MM_ROUND_DOWN, _MM_ROUND_UP, _MM_ROUND_TOWARD_ZERO
+    _MM_SET_ROUNDING_MODE(_MM_ROUND_NEAREST);  //_MM_ROUND_NEAREST, _MM_ROUND_DOWN, _MM_ROUND_UP, _MM_ROUND_TOWARD_ZERO
     unsigned int number;
     const unsigned int quarterPoints = num_output_samples / 4;
 
     lv_16sc_t** _result = result;
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     float tmp_rem_code_phase_chips;
-    __m128 _rem_code_phase,_code_phase_step_chips;
-    __m128i _code_length_chips,_code_length_chips_minus1;
-    __m128 _code_phase_out,_code_phase_out_with_offset;
+    __m128 _rem_code_phase, _code_phase_step_chips;
+    __m128i _code_length_chips, _code_length_chips_minus1;
+    __m128 _code_phase_out, _code_phase_out_with_offset;
 
-    _code_phase_step_chips = _mm_load1_ps(&code_phase_step_chips); //load float to all four float values in m128 register
-    __VOLK_ATTR_ALIGNED(16) int four_times_code_length_chips_minus1[4];
+    _code_phase_step_chips = _mm_load1_ps(&code_phase_step_chips);  //load float to all four float values in m128 register
+    __VOLK_ATTR_ALIGNED(16)
+    int four_times_code_length_chips_minus1[4];
     four_times_code_length_chips_minus1[0] = code_length_chips - 1;
     four_times_code_length_chips_minus1[1] = code_length_chips - 1;
     four_times_code_length_chips_minus1[2] = code_length_chips - 1;
     four_times_code_length_chips_minus1[3] = code_length_chips - 1;
 
-    __VOLK_ATTR_ALIGNED(16) int four_times_code_length_chips[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int four_times_code_length_chips[4];
     four_times_code_length_chips[0] = code_length_chips;
     four_times_code_length_chips[1] = code_length_chips;
     four_times_code_length_chips[2] = code_length_chips;
     four_times_code_length_chips[3] = code_length_chips;
 
-    _code_length_chips = _mm_load_si128((__m128i*)&four_times_code_length_chips); //load float to all four float values in m128 register
-    _code_length_chips_minus1 = _mm_load_si128((__m128i*)&four_times_code_length_chips_minus1); //load float to all four float values in m128 register
+    _code_length_chips = _mm_load_si128((__m128i*)&four_times_code_length_chips);                //load float to all four float values in m128 register
+    _code_length_chips_minus1 = _mm_load_si128((__m128i*)&four_times_code_length_chips_minus1);  //load float to all four float values in m128 register
 
-    __m128i negative_indexes, overflow_indexes,_code_phase_out_int, _code_phase_out_int_neg,_code_phase_out_int_over;
+    __m128i negative_indexes, overflow_indexes, _code_phase_out_int, _code_phase_out_int_neg, _code_phase_out_int_over;
 
     __m128i zero = _mm_setzero_si128();
 
-    __VOLK_ATTR_ALIGNED(16) float init_idx_float[4] = { 0.0f, 1.0f, 2.0f, 3.0f };
+    __VOLK_ATTR_ALIGNED(16)
+    float init_idx_float[4] = {0.0f, 1.0f, 2.0f, 3.0f};
     __m128 _4output_index = _mm_load_ps(init_idx_float);
-    __VOLK_ATTR_ALIGNED(16) float init_4constant_float[4] = { 4.0f, 4.0f, 4.0f, 4.0f };
+    __VOLK_ATTR_ALIGNED(16)
+    float init_4constant_float[4] = {4.0f, 4.0f, 4.0f, 4.0f};
     __m128 _4constant_float = _mm_load_ps(init_4constant_float);
 
     int current_vector = 0;
     int sample_idx = 0;
-    for(number = 0; number < quarterPoints; number++)
+    for (number = 0; number < quarterPoints; number++)
         {
             //common to all outputs
-            _code_phase_out = _mm_mul_ps(_code_phase_step_chips, _4output_index); //compute the code phase point with the phase step
+            _code_phase_out = _mm_mul_ps(_code_phase_step_chips, _4output_index);  //compute the code phase point with the phase step
 
             //output vector dependant (different code phase offset)
-            for(current_vector = 0; current_vector < num_out_vectors; current_vector++)
+            for (current_vector = 0; current_vector < num_out_vectors; current_vector++)
                 {
-                    tmp_rem_code_phase_chips = rem_code_phase_chips[current_vector] - 0.5f; // adjust offset to perform correct rounding (chip transition at 0)
-                    _rem_code_phase = _mm_load1_ps(&tmp_rem_code_phase_chips); //load float to all four float values in m128 register
+                    tmp_rem_code_phase_chips = rem_code_phase_chips[current_vector] - 0.5f;  // adjust offset to perform correct rounding (chip transition at 0)
+                    _rem_code_phase = _mm_load1_ps(&tmp_rem_code_phase_chips);               //load float to all four float values in m128 register
 
-                    _code_phase_out_with_offset = _mm_add_ps(_code_phase_out, _rem_code_phase); //add the phase offset
-                    _code_phase_out_int = _mm_cvtps_epi32(_code_phase_out_with_offset); //convert to integer
+                    _code_phase_out_with_offset = _mm_add_ps(_code_phase_out, _rem_code_phase);  //add the phase offset
+                    _code_phase_out_int = _mm_cvtps_epi32(_code_phase_out_with_offset);          //convert to integer
 
-                    negative_indexes = _mm_cmplt_epi32(_code_phase_out_int, zero); //test for negative values
-                    _code_phase_out_int_neg = _mm_add_epi32(_code_phase_out_int, _code_length_chips); //the negative values branch
-                    _code_phase_out_int_neg = _mm_xor_si128(_code_phase_out_int, _mm_and_si128( negative_indexes, _mm_xor_si128( _code_phase_out_int_neg, _code_phase_out_int )));
+                    negative_indexes = _mm_cmplt_epi32(_code_phase_out_int, zero);                     //test for negative values
+                    _code_phase_out_int_neg = _mm_add_epi32(_code_phase_out_int, _code_length_chips);  //the negative values branch
+                    _code_phase_out_int_neg = _mm_xor_si128(_code_phase_out_int, _mm_and_si128(negative_indexes, _mm_xor_si128(_code_phase_out_int_neg, _code_phase_out_int)));
 
-                    overflow_indexes = _mm_cmpgt_epi32(_code_phase_out_int_neg, _code_length_chips_minus1); //test for overflow values
-                    _code_phase_out_int_over = _mm_sub_epi32(_code_phase_out_int_neg, _code_length_chips); //the negative values branch
-                    _code_phase_out_int_over = _mm_xor_si128(_code_phase_out_int_neg, _mm_and_si128( overflow_indexes, _mm_xor_si128( _code_phase_out_int_over, _code_phase_out_int_neg )));
+                    overflow_indexes = _mm_cmpgt_epi32(_code_phase_out_int_neg, _code_length_chips_minus1);  //test for overflow values
+                    _code_phase_out_int_over = _mm_sub_epi32(_code_phase_out_int_neg, _code_length_chips);   //the negative values branch
+                    _code_phase_out_int_over = _mm_xor_si128(_code_phase_out_int_neg, _mm_and_si128(overflow_indexes, _mm_xor_si128(_code_phase_out_int_over, _code_phase_out_int_neg)));
 
-                    _mm_store_si128((__m128i*)local_code_chip_index, _code_phase_out_int_over); // Store the results back
+                    _mm_store_si128((__m128i*)local_code_chip_index, _code_phase_out_int_over);  // Store the results back
 
                     //todo: optimize the local code lookup table with intrinsics, if possible
                     _result[current_vector][sample_idx] = local_code[local_code_chip_index[0]];
@@ -169,9 +174,9 @@ static inline void volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn_a_sse2(lv_16sc_t*
             sample_idx += 4;
         }
 
-    for(number = quarterPoints * 4; number < num_output_samples; number++)
+    for (number = quarterPoints * 4; number < num_output_samples; number++)
         {
-            for(current_vector = 0; current_vector < num_out_vectors; current_vector++)
+            for (current_vector = 0; current_vector < num_out_vectors; current_vector++)
                 {
                     local_code_chip_index[0] = (int)(code_phase_step_chips * (float)(number) + rem_code_phase_chips[current_vector]);
                     if (local_code_chip_index[0] < 0.0) local_code_chip_index[0] += code_length_chips - 1;
@@ -186,69 +191,74 @@ static inline void volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn_a_sse2(lv_16sc_t*
 #ifdef LV_HAVE_SSE2
 #include <emmintrin.h>
 
-static inline void volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn_u_sse2(lv_16sc_t** result, const lv_16sc_t* local_code, float* rem_code_phase_chips ,float code_phase_step_chips, unsigned int code_length_chips, int num_out_vectors, unsigned int num_output_samples)
+static inline void volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn_u_sse2(lv_16sc_t** result, const lv_16sc_t* local_code, float* rem_code_phase_chips, float code_phase_step_chips, unsigned int code_length_chips, int num_out_vectors, unsigned int num_output_samples)
 {
-    _MM_SET_ROUNDING_MODE(_MM_ROUND_NEAREST);//_MM_ROUND_NEAREST, _MM_ROUND_DOWN, _MM_ROUND_UP, _MM_ROUND_TOWARD_ZERO
+    _MM_SET_ROUNDING_MODE(_MM_ROUND_NEAREST);  //_MM_ROUND_NEAREST, _MM_ROUND_DOWN, _MM_ROUND_UP, _MM_ROUND_TOWARD_ZERO
     unsigned int number;
     const unsigned int quarterPoints = num_output_samples / 4;
 
     lv_16sc_t** _result = result;
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     float tmp_rem_code_phase_chips;
-    __m128 _rem_code_phase,_code_phase_step_chips;
-    __m128i _code_length_chips,_code_length_chips_minus1;
-    __m128 _code_phase_out,_code_phase_out_with_offset;
+    __m128 _rem_code_phase, _code_phase_step_chips;
+    __m128i _code_length_chips, _code_length_chips_minus1;
+    __m128 _code_phase_out, _code_phase_out_with_offset;
 
-    _code_phase_step_chips = _mm_load1_ps(&code_phase_step_chips); //load float to all four float values in m128 register
-    __VOLK_ATTR_ALIGNED(16) int four_times_code_length_chips_minus1[4];
+    _code_phase_step_chips = _mm_load1_ps(&code_phase_step_chips);  //load float to all four float values in m128 register
+    __VOLK_ATTR_ALIGNED(16)
+    int four_times_code_length_chips_minus1[4];
     four_times_code_length_chips_minus1[0] = code_length_chips - 1;
     four_times_code_length_chips_minus1[1] = code_length_chips - 1;
     four_times_code_length_chips_minus1[2] = code_length_chips - 1;
     four_times_code_length_chips_minus1[3] = code_length_chips - 1;
 
-    __VOLK_ATTR_ALIGNED(16) int four_times_code_length_chips[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int four_times_code_length_chips[4];
     four_times_code_length_chips[0] = code_length_chips;
     four_times_code_length_chips[1] = code_length_chips;
     four_times_code_length_chips[2] = code_length_chips;
     four_times_code_length_chips[3] = code_length_chips;
 
-    _code_length_chips = _mm_loadu_si128((__m128i*)&four_times_code_length_chips); //load float to all four float values in m128 register
-    _code_length_chips_minus1 = _mm_loadu_si128((__m128i*)&four_times_code_length_chips_minus1); //load float to all four float values in m128 register
+    _code_length_chips = _mm_loadu_si128((__m128i*)&four_times_code_length_chips);                //load float to all four float values in m128 register
+    _code_length_chips_minus1 = _mm_loadu_si128((__m128i*)&four_times_code_length_chips_minus1);  //load float to all four float values in m128 register
 
-    __m128i negative_indexes, overflow_indexes,_code_phase_out_int, _code_phase_out_int_neg,_code_phase_out_int_over;
+    __m128i negative_indexes, overflow_indexes, _code_phase_out_int, _code_phase_out_int_neg, _code_phase_out_int_over;
 
     __m128i zero = _mm_setzero_si128();
 
-    __VOLK_ATTR_ALIGNED(16) float init_idx_float[4] = { 0.0f, 1.0f, 2.0f, 3.0f };
+    __VOLK_ATTR_ALIGNED(16)
+    float init_idx_float[4] = {0.0f, 1.0f, 2.0f, 3.0f};
     __m128 _4output_index = _mm_loadu_ps(init_idx_float);
-    __VOLK_ATTR_ALIGNED(16) float init_4constant_float[4] = { 4.0f, 4.0f, 4.0f, 4.0f };
+    __VOLK_ATTR_ALIGNED(16)
+    float init_4constant_float[4] = {4.0f, 4.0f, 4.0f, 4.0f};
     __m128 _4constant_float = _mm_loadu_ps(init_4constant_float);
 
     int current_vector = 0;
     int sample_idx = 0;
-    for(number = 0; number < quarterPoints; number++)
+    for (number = 0; number < quarterPoints; number++)
         {
             //common to all outputs
-            _code_phase_out = _mm_mul_ps(_code_phase_step_chips, _4output_index); //compute the code phase point with the phase step
+            _code_phase_out = _mm_mul_ps(_code_phase_step_chips, _4output_index);  //compute the code phase point with the phase step
 
             //output vector dependant (different code phase offset)
-            for(current_vector = 0; current_vector < num_out_vectors; current_vector++)
+            for (current_vector = 0; current_vector < num_out_vectors; current_vector++)
                 {
-                    tmp_rem_code_phase_chips = rem_code_phase_chips[current_vector] - 0.5f; // adjust offset to perform correct rounding (chip transition at 0)
-                    _rem_code_phase = _mm_load1_ps(&tmp_rem_code_phase_chips); //load float to all four float values in m128 register
+                    tmp_rem_code_phase_chips = rem_code_phase_chips[current_vector] - 0.5f;  // adjust offset to perform correct rounding (chip transition at 0)
+                    _rem_code_phase = _mm_load1_ps(&tmp_rem_code_phase_chips);               //load float to all four float values in m128 register
 
-                    _code_phase_out_with_offset = _mm_add_ps(_code_phase_out, _rem_code_phase); //add the phase offset
-                    _code_phase_out_int = _mm_cvtps_epi32(_code_phase_out_with_offset); //convert to integer
+                    _code_phase_out_with_offset = _mm_add_ps(_code_phase_out, _rem_code_phase);  //add the phase offset
+                    _code_phase_out_int = _mm_cvtps_epi32(_code_phase_out_with_offset);          //convert to integer
 
-                    negative_indexes = _mm_cmplt_epi32(_code_phase_out_int, zero); //test for negative values
-                    _code_phase_out_int_neg = _mm_add_epi32(_code_phase_out_int, _code_length_chips); //the negative values branch
-                    _code_phase_out_int_neg = _mm_xor_si128(_code_phase_out_int, _mm_and_si128( negative_indexes, _mm_xor_si128( _code_phase_out_int_neg, _code_phase_out_int )));
+                    negative_indexes = _mm_cmplt_epi32(_code_phase_out_int, zero);                     //test for negative values
+                    _code_phase_out_int_neg = _mm_add_epi32(_code_phase_out_int, _code_length_chips);  //the negative values branch
+                    _code_phase_out_int_neg = _mm_xor_si128(_code_phase_out_int, _mm_and_si128(negative_indexes, _mm_xor_si128(_code_phase_out_int_neg, _code_phase_out_int)));
 
-                    overflow_indexes = _mm_cmpgt_epi32(_code_phase_out_int_neg, _code_length_chips_minus1); //test for overflow values
-                    _code_phase_out_int_over = _mm_sub_epi32(_code_phase_out_int_neg, _code_length_chips); //the negative values branch
-                    _code_phase_out_int_over = _mm_xor_si128(_code_phase_out_int_neg, _mm_and_si128( overflow_indexes, _mm_xor_si128( _code_phase_out_int_over, _code_phase_out_int_neg )));
+                    overflow_indexes = _mm_cmpgt_epi32(_code_phase_out_int_neg, _code_length_chips_minus1);  //test for overflow values
+                    _code_phase_out_int_over = _mm_sub_epi32(_code_phase_out_int_neg, _code_length_chips);   //the negative values branch
+                    _code_phase_out_int_over = _mm_xor_si128(_code_phase_out_int_neg, _mm_and_si128(overflow_indexes, _mm_xor_si128(_code_phase_out_int_over, _code_phase_out_int_neg)));
 
-                    _mm_storeu_si128((__m128i*)local_code_chip_index, _code_phase_out_int_over); // Store the results back
+                    _mm_storeu_si128((__m128i*)local_code_chip_index, _code_phase_out_int_over);  // Store the results back
 
                     //todo: optimize the local code lookup table with intrinsics, if possible
                     _result[current_vector][sample_idx] = local_code[local_code_chip_index[0]];
@@ -260,9 +270,9 @@ static inline void volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn_u_sse2(lv_16sc_t*
             sample_idx += 4;
         }
 
-    for(number = quarterPoints * 4; number < num_output_samples; number++)
+    for (number = quarterPoints * 4; number < num_output_samples; number++)
         {
-            for(current_vector = 0; current_vector < num_out_vectors; current_vector++)
+            for (current_vector = 0; current_vector < num_out_vectors; current_vector++)
                 {
                     local_code_chip_index[0] = (int)(code_phase_step_chips * (float)(number) + rem_code_phase_chips[current_vector]);
                     if (local_code_chip_index[0] < 0.0) local_code_chip_index[0] += code_length_chips - 1;
@@ -278,74 +288,79 @@ static inline void volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn_u_sse2(lv_16sc_t*
 #ifdef LV_HAVE_NEON
 #include <arm_neon.h>
 
-static inline void volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn_neon(lv_16sc_t** result, const lv_16sc_t* local_code, float* rem_code_phase_chips ,float code_phase_step_chips, unsigned int code_length_chips, int num_out_vectors, unsigned int num_output_samples)
+static inline void volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn_neon(lv_16sc_t** result, const lv_16sc_t* local_code, float* rem_code_phase_chips, float code_phase_step_chips, unsigned int code_length_chips, int num_out_vectors, unsigned int num_output_samples)
 {
     unsigned int number;
     const unsigned int quarterPoints = num_output_samples / 4;
     float32x4_t half = vdupq_n_f32(0.5f);
 
     lv_16sc_t** _result = result;
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     float tmp_rem_code_phase_chips;
     float32x4_t _rem_code_phase, _code_phase_step_chips;
     int32x4_t _code_length_chips, _code_length_chips_minus1;
     float32x4_t _code_phase_out, _code_phase_out_with_offset;
     float32x4_t sign, PlusHalf, Round;
 
-    _code_phase_step_chips = vld1q_dup_f32(&code_phase_step_chips); //load float to all four float values in float32x4_t register
-    __VOLK_ATTR_ALIGNED(16) int four_times_code_length_chips_minus1[4];
+    _code_phase_step_chips = vld1q_dup_f32(&code_phase_step_chips);  //load float to all four float values in float32x4_t register
+    __VOLK_ATTR_ALIGNED(16)
+    int four_times_code_length_chips_minus1[4];
     four_times_code_length_chips_minus1[0] = code_length_chips - 1;
     four_times_code_length_chips_minus1[1] = code_length_chips - 1;
     four_times_code_length_chips_minus1[2] = code_length_chips - 1;
     four_times_code_length_chips_minus1[3] = code_length_chips - 1;
 
-    __VOLK_ATTR_ALIGNED(16) int four_times_code_length_chips[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int four_times_code_length_chips[4];
     four_times_code_length_chips[0] = code_length_chips;
     four_times_code_length_chips[1] = code_length_chips;
     four_times_code_length_chips[2] = code_length_chips;
     four_times_code_length_chips[3] = code_length_chips;
 
-    _code_length_chips = vld1q_s32((int32_t*)&four_times_code_length_chips); //load float to all four float values in float32x4_t register
-    _code_length_chips_minus1 = vld1q_s32((int32_t*)&four_times_code_length_chips_minus1); //load float to all four float values in float32x4_t register
+    _code_length_chips = vld1q_s32((int32_t*)&four_times_code_length_chips);                //load float to all four float values in float32x4_t register
+    _code_length_chips_minus1 = vld1q_s32((int32_t*)&four_times_code_length_chips_minus1);  //load float to all four float values in float32x4_t register
 
-    int32x4_t  _code_phase_out_int, _code_phase_out_int_neg, _code_phase_out_int_over;
+    int32x4_t _code_phase_out_int, _code_phase_out_int_neg, _code_phase_out_int_over;
     uint32x4_t negative_indexes, overflow_indexes;
     int32x4_t zero = vmovq_n_s32(0);
 
-    __VOLK_ATTR_ALIGNED(16) float init_idx_float[4] = { 0.0f, 1.0f, 2.0f, 3.0f };
+    __VOLK_ATTR_ALIGNED(16)
+    float init_idx_float[4] = {0.0f, 1.0f, 2.0f, 3.0f};
     float32x4_t _4output_index = vld1q_f32(init_idx_float);
-    __VOLK_ATTR_ALIGNED(16) float init_4constant_float[4] = { 4.0f, 4.0f, 4.0f, 4.0f };
+    __VOLK_ATTR_ALIGNED(16)
+    float init_4constant_float[4] = {4.0f, 4.0f, 4.0f, 4.0f};
     float32x4_t _4constant_float = vld1q_f32(init_4constant_float);
 
     int current_vector = 0;
     int sample_idx = 0;
-    for(number = 0; number < quarterPoints; number++)
+    for (number = 0; number < quarterPoints; number++)
         {
             //common to all outputs
-            _code_phase_out = vmulq_f32(_code_phase_step_chips, _4output_index); //compute the code phase point with the phase step
+            _code_phase_out = vmulq_f32(_code_phase_step_chips, _4output_index);  //compute the code phase point with the phase step
 
             //output vector dependant (different code phase offset)
-            for(current_vector = 0; current_vector < num_out_vectors; current_vector++)
+            for (current_vector = 0; current_vector < num_out_vectors; current_vector++)
                 {
-                    tmp_rem_code_phase_chips = rem_code_phase_chips[current_vector] - 0.5f; // adjust offset to perform correct rounding (chip transition at 0)
-                    _rem_code_phase = vld1q_dup_f32(&tmp_rem_code_phase_chips); //load float to all four float values in float32x4_t register
+                    tmp_rem_code_phase_chips = rem_code_phase_chips[current_vector] - 0.5f;  // adjust offset to perform correct rounding (chip transition at 0)
+                    _rem_code_phase = vld1q_dup_f32(&tmp_rem_code_phase_chips);              //load float to all four float values in float32x4_t register
 
-                    _code_phase_out_with_offset = vaddq_f32(_code_phase_out, _rem_code_phase); //add the phase offset
+                    _code_phase_out_with_offset = vaddq_f32(_code_phase_out, _rem_code_phase);  //add the phase offset
                     //_code_phase_out_int = _mm_cvtps_epi32(_code_phase_out_with_offset); //convert to integer
                     sign = vcvtq_f32_u32((vshrq_n_u32(vreinterpretq_u32_f32(_code_phase_out_with_offset), 31)));
                     PlusHalf = vaddq_f32(_code_phase_out_with_offset, half);
                     Round = vsubq_f32(PlusHalf, sign);
                     _code_phase_out_int = vcvtq_s32_f32(Round);
 
-                    negative_indexes = vcltq_s32(_code_phase_out_int, zero); //test for negative values
-                    _code_phase_out_int_neg = vaddq_s32(_code_phase_out_int, _code_length_chips); //the negative values branch
-                    _code_phase_out_int_neg = veorq_s32(_code_phase_out_int, vandq_s32( (int32x4_t)negative_indexes, veorq_s32( _code_phase_out_int_neg, _code_phase_out_int )));
+                    negative_indexes = vcltq_s32(_code_phase_out_int, zero);                       //test for negative values
+                    _code_phase_out_int_neg = vaddq_s32(_code_phase_out_int, _code_length_chips);  //the negative values branch
+                    _code_phase_out_int_neg = veorq_s32(_code_phase_out_int, vandq_s32((int32x4_t)negative_indexes, veorq_s32(_code_phase_out_int_neg, _code_phase_out_int)));
 
-                    overflow_indexes = vcgtq_s32(_code_phase_out_int_neg, _code_length_chips_minus1); //test for overflow values
-                    _code_phase_out_int_over = vsubq_s32(_code_phase_out_int_neg, _code_length_chips); //the negative values branch
-                    _code_phase_out_int_over = veorq_s32(_code_phase_out_int_neg, vandq_s32( (int32x4_t)overflow_indexes, veorq_s32( _code_phase_out_int_over, _code_phase_out_int_neg )));
+                    overflow_indexes = vcgtq_s32(_code_phase_out_int_neg, _code_length_chips_minus1);   //test for overflow values
+                    _code_phase_out_int_over = vsubq_s32(_code_phase_out_int_neg, _code_length_chips);  //the negative values branch
+                    _code_phase_out_int_over = veorq_s32(_code_phase_out_int_neg, vandq_s32((int32x4_t)overflow_indexes, veorq_s32(_code_phase_out_int_over, _code_phase_out_int_neg)));
 
-                    vst1q_s32((int32_t*)local_code_chip_index, _code_phase_out_int_over); // Store the results back
+                    vst1q_s32((int32_t*)local_code_chip_index, _code_phase_out_int_over);  // Store the results back
 
                     //todo: optimize the local code lookup table with intrinsics, if possible
                     _result[current_vector][sample_idx] = local_code[local_code_chip_index[0]];
@@ -357,9 +372,9 @@ static inline void volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn_neon(lv_16sc_t**
             sample_idx += 4;
         }
 
-    for(number = quarterPoints * 4; number < num_output_samples; number++)
+    for (number = quarterPoints * 4; number < num_output_samples; number++)
         {
-            for(current_vector = 0; current_vector < num_out_vectors; current_vector++)
+            for (current_vector = 0; current_vector < num_out_vectors; current_vector++)
                 {
                     local_code_chip_index[0] = (int)(code_phase_step_chips * (float)(number) + rem_code_phase_chips[current_vector]);
                     if (local_code_chip_index[0] < 0.0) local_code_chip_index[0] += code_length_chips - 1;

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32f_index_max_32u.h

@@ -29,7 +29,6 @@
  */
 
 
-
 /*!
  * \page volk_gnsssdr_32f_index_max_32u.h
  *
@@ -63,7 +62,7 @@
 
 static inline void volk_gnsssdr_32f_index_max_32u_a_avx(uint32_t* target, const float* src0, uint32_t num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             uint32_t number = 0;
             const uint32_t quarterPoints = num_points / 8;
@@ -71,7 +70,7 @@ static inline void volk_gnsssdr_32f_index_max_32u_a_avx(uint32_t* target, const
             float* inputPtr = (float*)src0;
 
             __m256 indexIncrementValues = _mm256_set1_ps(8);
-            __m256 currentIndexes = _mm256_set_ps(-1,-2,-3,-4,-5,-6,-7,-8);
+            __m256 currentIndexes = _mm256_set_ps(-1, -2, -3, -4, -5, -6, -7, -8);
 
             float max = src0[0];
             float index = 0;
@@ -80,25 +79,28 @@ static inline void volk_gnsssdr_32f_index_max_32u_a_avx(uint32_t* target, const
             __m256 compareResults;
             __m256 currentValues;
 
-            __VOLK_ATTR_ALIGNED(32) float maxValuesBuffer[8];
-            __VOLK_ATTR_ALIGNED(32) float maxIndexesBuffer[8];
+            __VOLK_ATTR_ALIGNED(32)
+            float maxValuesBuffer[8];
+            __VOLK_ATTR_ALIGNED(32)
+            float maxIndexesBuffer[8];
 
-            for(;number < quarterPoints; number++)
+            for (; number < quarterPoints; number++)
                 {
-                    currentValues  = _mm256_load_ps(inputPtr); inputPtr += 8;
+                    currentValues = _mm256_load_ps(inputPtr);
+                    inputPtr += 8;
                     currentIndexes = _mm256_add_ps(currentIndexes, indexIncrementValues);
                     compareResults = _mm256_cmp_ps(maxValues, currentValues, 0x1e);
                     maxValuesIndex = _mm256_blendv_ps(currentIndexes, maxValuesIndex, compareResults);
-                    maxValues      = _mm256_blendv_ps(currentValues, maxValues, compareResults);
+                    maxValues = _mm256_blendv_ps(currentValues, maxValues, compareResults);
                 }
 
             // Calculate the largest value from the remaining 8 points
             _mm256_store_ps(maxValuesBuffer, maxValues);
             _mm256_store_ps(maxIndexesBuffer, maxValuesIndex);
 
-            for(number = 0; number < 8; number++)
+            for (number = 0; number < 8; number++)
                 {
-                    if(maxValuesBuffer[number] > max)
+                    if (maxValuesBuffer[number] > max)
                         {
                             index = maxIndexesBuffer[number];
                             max = maxValuesBuffer[number];
@@ -106,9 +108,9 @@ static inline void volk_gnsssdr_32f_index_max_32u_a_avx(uint32_t* target, const
                 }
 
             number = quarterPoints * 8;
-            for(;number < num_points; number++)
+            for (; number < num_points; number++)
                 {
-                    if(src0[number] > max)
+                    if (src0[number] > max)
                         {
                             index = number;
                             max = src0[number];
@@ -126,7 +128,7 @@ static inline void volk_gnsssdr_32f_index_max_32u_a_avx(uint32_t* target, const
 
 static inline void volk_gnsssdr_32f_index_max_32u_u_avx(uint32_t* target, const float* src0, uint32_t num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             uint32_t number = 0;
             const uint32_t quarterPoints = num_points / 8;
@@ -134,7 +136,7 @@ static inline void volk_gnsssdr_32f_index_max_32u_u_avx(uint32_t* target, const
             float* inputPtr = (float*)src0;
 
             __m256 indexIncrementValues = _mm256_set1_ps(8);
-            __m256 currentIndexes = _mm256_set_ps(-1,-2,-3,-4,-5,-6,-7,-8);
+            __m256 currentIndexes = _mm256_set_ps(-1, -2, -3, -4, -5, -6, -7, -8);
 
             float max = src0[0];
             float index = 0;
@@ -143,25 +145,28 @@ static inline void volk_gnsssdr_32f_index_max_32u_u_avx(uint32_t* target, const
             __m256 compareResults;
             __m256 currentValues;
 
-            __VOLK_ATTR_ALIGNED(32) float maxValuesBuffer[8];
-            __VOLK_ATTR_ALIGNED(32) float maxIndexesBuffer[8];
+            __VOLK_ATTR_ALIGNED(32)
+            float maxValuesBuffer[8];
+            __VOLK_ATTR_ALIGNED(32)
+            float maxIndexesBuffer[8];
 
-            for(;number < quarterPoints; number++)
+            for (; number < quarterPoints; number++)
                 {
-                    currentValues  = _mm256_loadu_ps(inputPtr); inputPtr += 8;
+                    currentValues = _mm256_loadu_ps(inputPtr);
+                    inputPtr += 8;
                     currentIndexes = _mm256_add_ps(currentIndexes, indexIncrementValues);
                     compareResults = _mm256_cmp_ps(maxValues, currentValues, 0x1e);
                     maxValuesIndex = _mm256_blendv_ps(currentIndexes, maxValuesIndex, compareResults);
-                    maxValues      = _mm256_blendv_ps(currentValues, maxValues, compareResults);
+                    maxValues = _mm256_blendv_ps(currentValues, maxValues, compareResults);
                 }
 
             // Calculate the largest value from the remaining 8 points
             _mm256_store_ps(maxValuesBuffer, maxValues);
             _mm256_store_ps(maxIndexesBuffer, maxValuesIndex);
 
-            for(number = 0; number < 8; number++)
+            for (number = 0; number < 8; number++)
                 {
-                    if(maxValuesBuffer[number] > max)
+                    if (maxValuesBuffer[number] > max)
                         {
                             index = maxIndexesBuffer[number];
                             max = maxValuesBuffer[number];
@@ -169,9 +174,9 @@ static inline void volk_gnsssdr_32f_index_max_32u_u_avx(uint32_t* target, const
                 }
 
             number = quarterPoints * 8;
-            for(;number < num_points; number++)
+            for (; number < num_points; number++)
                 {
-                    if(src0[number] > max)
+                    if (src0[number] > max)
                         {
                             index = number;
                             max = src0[number];
@@ -185,11 +190,11 @@ static inline void volk_gnsssdr_32f_index_max_32u_u_avx(uint32_t* target, const
 
 
 #ifdef LV_HAVE_SSE4_1
-#include<smmintrin.h>
+#include <smmintrin.h>
 
 static inline void volk_gnsssdr_32f_index_max_32u_a_sse4_1(uint32_t* target, const float* src0, uint32_t num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             uint32_t number = 0;
             const uint32_t quarterPoints = num_points / 4;
@@ -197,7 +202,7 @@ static inline void volk_gnsssdr_32f_index_max_32u_a_sse4_1(uint32_t* target, con
             float* inputPtr = (float*)src0;
 
             __m128 indexIncrementValues = _mm_set1_ps(4);
-            __m128 currentIndexes = _mm_set_ps(-1,-2,-3,-4);
+            __m128 currentIndexes = _mm_set_ps(-1, -2, -3, -4);
 
             float max = src0[0];
             float index = 0;
@@ -206,25 +211,28 @@ static inline void volk_gnsssdr_32f_index_max_32u_a_sse4_1(uint32_t* target, con
             __m128 compareResults;
             __m128 currentValues;
 
-            __VOLK_ATTR_ALIGNED(16) float maxValuesBuffer[4];
-            __VOLK_ATTR_ALIGNED(16) float maxIndexesBuffer[4];
+            __VOLK_ATTR_ALIGNED(16)
+            float maxValuesBuffer[4];
+            __VOLK_ATTR_ALIGNED(16)
+            float maxIndexesBuffer[4];
 
-            for(;number < quarterPoints; number++)
+            for (; number < quarterPoints; number++)
                 {
-                    currentValues  = _mm_load_ps(inputPtr); inputPtr += 4;
+                    currentValues = _mm_load_ps(inputPtr);
+                    inputPtr += 4;
                     currentIndexes = _mm_add_ps(currentIndexes, indexIncrementValues);
                     compareResults = _mm_cmpgt_ps(maxValues, currentValues);
                     maxValuesIndex = _mm_blendv_ps(currentIndexes, maxValuesIndex, compareResults);
-                    maxValues      = _mm_blendv_ps(currentValues, maxValues, compareResults);
+                    maxValues = _mm_blendv_ps(currentValues, maxValues, compareResults);
                 }
 
             // Calculate the largest value from the remaining 4 points
             _mm_store_ps(maxValuesBuffer, maxValues);
             _mm_store_ps(maxIndexesBuffer, maxValuesIndex);
 
-            for(number = 0; number < 4; number++)
+            for (number = 0; number < 4; number++)
                 {
-                    if(maxValuesBuffer[number] > max)
+                    if (maxValuesBuffer[number] > max)
                         {
                             index = maxIndexesBuffer[number];
                             max = maxValuesBuffer[number];
@@ -232,9 +240,9 @@ static inline void volk_gnsssdr_32f_index_max_32u_a_sse4_1(uint32_t* target, con
                 }
 
             number = quarterPoints * 4;
-            for(;number < num_points; number++)
+            for (; number < num_points; number++)
                 {
-                    if(src0[number] > max)
+                    if (src0[number] > max)
                         {
                             index = number;
                             max = src0[number];
@@ -248,11 +256,11 @@ static inline void volk_gnsssdr_32f_index_max_32u_a_sse4_1(uint32_t* target, con
 
 
 #ifdef LV_HAVE_SSE4_1
-#include<smmintrin.h>
+#include <smmintrin.h>
 
 static inline void volk_gnsssdr_32f_index_max_32u_u_sse4_1(uint32_t* target, const float* src0, uint32_t num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             uint32_t number = 0;
             const uint32_t quarterPoints = num_points / 4;
@@ -260,7 +268,7 @@ static inline void volk_gnsssdr_32f_index_max_32u_u_sse4_1(uint32_t* target, con
             float* inputPtr = (float*)src0;
 
             __m128 indexIncrementValues = _mm_set1_ps(4);
-            __m128 currentIndexes = _mm_set_ps(-1,-2,-3,-4);
+            __m128 currentIndexes = _mm_set_ps(-1, -2, -3, -4);
 
             float max = src0[0];
             float index = 0;
@@ -269,25 +277,28 @@ static inline void volk_gnsssdr_32f_index_max_32u_u_sse4_1(uint32_t* target, con
             __m128 compareResults;
             __m128 currentValues;
 
-            __VOLK_ATTR_ALIGNED(16) float maxValuesBuffer[4];
-            __VOLK_ATTR_ALIGNED(16) float maxIndexesBuffer[4];
+            __VOLK_ATTR_ALIGNED(16)
+            float maxValuesBuffer[4];
+            __VOLK_ATTR_ALIGNED(16)
+            float maxIndexesBuffer[4];
 
-            for(;number < quarterPoints; number++)
+            for (; number < quarterPoints; number++)
                 {
-                    currentValues  = _mm_loadu_ps(inputPtr); inputPtr += 4;
+                    currentValues = _mm_loadu_ps(inputPtr);
+                    inputPtr += 4;
                     currentIndexes = _mm_add_ps(currentIndexes, indexIncrementValues);
                     compareResults = _mm_cmpgt_ps(maxValues, currentValues);
                     maxValuesIndex = _mm_blendv_ps(currentIndexes, maxValuesIndex, compareResults);
-                    maxValues      = _mm_blendv_ps(currentValues, maxValues, compareResults);
+                    maxValues = _mm_blendv_ps(currentValues, maxValues, compareResults);
                 }
 
             // Calculate the largest value from the remaining 4 points
             _mm_store_ps(maxValuesBuffer, maxValues);
             _mm_store_ps(maxIndexesBuffer, maxValuesIndex);
 
-            for(number = 0; number < 4; number++)
+            for (number = 0; number < 4; number++)
                 {
-                    if(maxValuesBuffer[number] > max)
+                    if (maxValuesBuffer[number] > max)
                         {
                             index = maxIndexesBuffer[number];
                             max = maxValuesBuffer[number];
@@ -295,9 +306,9 @@ static inline void volk_gnsssdr_32f_index_max_32u_u_sse4_1(uint32_t* target, con
                 }
 
             number = quarterPoints * 4;
-            for(;number < num_points; number++)
+            for (; number < num_points; number++)
                 {
-                    if(src0[number] > max)
+                    if (src0[number] > max)
                         {
                             index = number;
                             max = src0[number];
@@ -312,11 +323,11 @@ static inline void volk_gnsssdr_32f_index_max_32u_u_sse4_1(uint32_t* target, con
 
 #ifdef LV_HAVE_SSE
 
-#include<xmmintrin.h>
+#include <xmmintrin.h>
 
 static inline void volk_gnsssdr_32f_index_max_32u_a_sse(uint32_t* target, const float* src0, uint32_t num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             uint32_t number = 0;
             const uint32_t quarterPoints = num_points / 4;
@@ -324,7 +335,7 @@ static inline void volk_gnsssdr_32f_index_max_32u_a_sse(uint32_t* target, const
             float* inputPtr = (float*)src0;
 
             __m128 indexIncrementValues = _mm_set1_ps(4);
-            __m128 currentIndexes = _mm_set_ps(-1,-2,-3,-4);
+            __m128 currentIndexes = _mm_set_ps(-1, -2, -3, -4);
 
             float max = src0[0];
             float index = 0;
@@ -333,25 +344,28 @@ static inline void volk_gnsssdr_32f_index_max_32u_a_sse(uint32_t* target, const
             __m128 compareResults;
             __m128 currentValues;
 
-            __VOLK_ATTR_ALIGNED(16) float maxValuesBuffer[4];
-            __VOLK_ATTR_ALIGNED(16) float maxIndexesBuffer[4];
+            __VOLK_ATTR_ALIGNED(16)
+            float maxValuesBuffer[4];
+            __VOLK_ATTR_ALIGNED(16)
+            float maxIndexesBuffer[4];
 
-            for(;number < quarterPoints; number++)
+            for (; number < quarterPoints; number++)
                 {
-                    currentValues  = _mm_load_ps(inputPtr); inputPtr += 4;
+                    currentValues = _mm_load_ps(inputPtr);
+                    inputPtr += 4;
                     currentIndexes = _mm_add_ps(currentIndexes, indexIncrementValues);
                     compareResults = _mm_cmpgt_ps(maxValues, currentValues);
-                    maxValuesIndex = _mm_or_ps(_mm_and_ps(compareResults, maxValuesIndex) , _mm_andnot_ps(compareResults, currentIndexes));
-                    maxValues      = _mm_or_ps(_mm_and_ps(compareResults, maxValues) , _mm_andnot_ps(compareResults, currentValues));
+                    maxValuesIndex = _mm_or_ps(_mm_and_ps(compareResults, maxValuesIndex), _mm_andnot_ps(compareResults, currentIndexes));
+                    maxValues = _mm_or_ps(_mm_and_ps(compareResults, maxValues), _mm_andnot_ps(compareResults, currentValues));
                 }
 
             // Calculate the largest value from the remaining 4 points
             _mm_store_ps(maxValuesBuffer, maxValues);
             _mm_store_ps(maxIndexesBuffer, maxValuesIndex);
 
-            for(number = 0; number < 4; number++)
+            for (number = 0; number < 4; number++)
                 {
-                    if(maxValuesBuffer[number] > max)
+                    if (maxValuesBuffer[number] > max)
                         {
                             index = maxIndexesBuffer[number];
                             max = maxValuesBuffer[number];
@@ -359,9 +373,9 @@ static inline void volk_gnsssdr_32f_index_max_32u_a_sse(uint32_t* target, const
                 }
 
             number = quarterPoints * 4;
-            for(;number < num_points; number++)
+            for (; number < num_points; number++)
                 {
-                    if(src0[number] > max)
+                    if (src0[number] > max)
                         {
                             index = number;
                             max = src0[number];
@@ -376,11 +390,11 @@ static inline void volk_gnsssdr_32f_index_max_32u_a_sse(uint32_t* target, const
 
 #ifdef LV_HAVE_SSE
 
-#include<xmmintrin.h>
+#include <xmmintrin.h>
 
 static inline void volk_gnsssdr_32f_index_max_32u_u_sse(uint32_t* target, const float* src0, uint32_t num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             uint32_t number = 0;
             const uint32_t quarterPoints = num_points / 4;
@@ -388,7 +402,7 @@ static inline void volk_gnsssdr_32f_index_max_32u_u_sse(uint32_t* target, const
             float* inputPtr = (float*)src0;
 
             __m128 indexIncrementValues = _mm_set1_ps(4);
-            __m128 currentIndexes = _mm_set_ps(-1,-2,-3,-4);
+            __m128 currentIndexes = _mm_set_ps(-1, -2, -3, -4);
 
             float max = src0[0];
             float index = 0;
@@ -397,25 +411,28 @@ static inline void volk_gnsssdr_32f_index_max_32u_u_sse(uint32_t* target, const
             __m128 compareResults;
             __m128 currentValues;
 
-            __VOLK_ATTR_ALIGNED(16) float maxValuesBuffer[4];
-            __VOLK_ATTR_ALIGNED(16) float maxIndexesBuffer[4];
+            __VOLK_ATTR_ALIGNED(16)
+            float maxValuesBuffer[4];
+            __VOLK_ATTR_ALIGNED(16)
+            float maxIndexesBuffer[4];
 
-            for(;number < quarterPoints; number++)
+            for (; number < quarterPoints; number++)
                 {
-                    currentValues  = _mm_loadu_ps(inputPtr); inputPtr += 4;
+                    currentValues = _mm_loadu_ps(inputPtr);
+                    inputPtr += 4;
                     currentIndexes = _mm_add_ps(currentIndexes, indexIncrementValues);
                     compareResults = _mm_cmpgt_ps(maxValues, currentValues);
-                    maxValuesIndex = _mm_or_ps(_mm_and_ps(compareResults, maxValuesIndex) , _mm_andnot_ps(compareResults, currentIndexes));
-                    maxValues      = _mm_or_ps(_mm_and_ps(compareResults, maxValues) , _mm_andnot_ps(compareResults, currentValues));
+                    maxValuesIndex = _mm_or_ps(_mm_and_ps(compareResults, maxValuesIndex), _mm_andnot_ps(compareResults, currentIndexes));
+                    maxValues = _mm_or_ps(_mm_and_ps(compareResults, maxValues), _mm_andnot_ps(compareResults, currentValues));
                 }
 
             // Calculate the largest value from the remaining 4 points
             _mm_store_ps(maxValuesBuffer, maxValues);
             _mm_store_ps(maxIndexesBuffer, maxValuesIndex);
 
-            for(number = 0; number < 4; number++)
+            for (number = 0; number < 4; number++)
                 {
-                    if(maxValuesBuffer[number] > max)
+                    if (maxValuesBuffer[number] > max)
                         {
                             index = maxIndexesBuffer[number];
                             max = maxValuesBuffer[number];
@@ -423,9 +440,9 @@ static inline void volk_gnsssdr_32f_index_max_32u_u_sse(uint32_t* target, const
                 }
 
             number = quarterPoints * 4;
-            for(;number < num_points; number++)
+            for (; number < num_points; number++)
                 {
-                    if(src0[number] > max)
+                    if (src0[number] > max)
                         {
                             index = number;
                             max = src0[number];
@@ -442,16 +459,16 @@ static inline void volk_gnsssdr_32f_index_max_32u_u_sse(uint32_t* target, const
 
 static inline void volk_gnsssdr_32f_index_max_32u_generic(uint32_t* target, const float* src0, uint32_t num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             float max = src0[0];
             uint32_t index = 0;
 
             uint32_t i = 1;
 
-            for(; i < num_points; ++i)
+            for (; i < num_points; ++i)
                 {
-                    if(src0[i] > max)
+                    if (src0[i] > max)
                         {
                             index = i;
                             max = src0[i];
@@ -469,14 +486,15 @@ static inline void volk_gnsssdr_32f_index_max_32u_generic(uint32_t* target, cons
 
 static inline void volk_gnsssdr_32f_index_max_32u_neon(uint32_t* target, const float* src0, uint32_t num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             uint32_t number = 0;
             const uint32_t quarterPoints = num_points / 4;
 
             float* inputPtr = (float*)src0;
             float32x4_t indexIncrementValues = vdupq_n_f32(4);
-            __VOLK_ATTR_ALIGNED(16) float currentIndexes_float[4] = { -4.0f, -3.0f, -2.0f, -1.0f };
+            __VOLK_ATTR_ALIGNED(16)
+            float currentIndexes_float[4] = {-4.0f, -3.0f, -2.0f, -1.0f};
             float32x4_t currentIndexes = vld1q_f32(currentIndexes_float);
 
             float max = src0[0];
@@ -487,25 +505,28 @@ static inline void volk_gnsssdr_32f_index_max_32u_neon(uint32_t* target, const f
             uint32x4_t currentIndexes_u;
             float32x4_t currentValues;
 
-            __VOLK_ATTR_ALIGNED(16) float maxValuesBuffer[4];
-            __VOLK_ATTR_ALIGNED(16) float maxIndexesBuffer[4];
+            __VOLK_ATTR_ALIGNED(16)
+            float maxValuesBuffer[4];
+            __VOLK_ATTR_ALIGNED(16)
+            float maxIndexesBuffer[4];
 
-            for(;number < quarterPoints; number++)
+            for (; number < quarterPoints; number++)
                 {
-                    currentValues    = vld1q_f32(inputPtr); inputPtr += 4;
-                    currentIndexes   = vaddq_f32(currentIndexes, indexIncrementValues);
+                    currentValues = vld1q_f32(inputPtr);
+                    inputPtr += 4;
+                    currentIndexes = vaddq_f32(currentIndexes, indexIncrementValues);
                     currentIndexes_u = vcvtq_u32_f32(currentIndexes);
-                    compareResults   = vcgtq_f32( maxValues, currentValues);
-                    maxValuesIndex   = vorrq_u32( vandq_u32( compareResults, maxValuesIndex ), vbicq_u32(currentIndexes_u, compareResults) );
-                    maxValues        = vmaxq_f32(currentValues, maxValues);
+                    compareResults = vcgtq_f32(maxValues, currentValues);
+                    maxValuesIndex = vorrq_u32(vandq_u32(compareResults, maxValuesIndex), vbicq_u32(currentIndexes_u, compareResults));
+                    maxValues = vmaxq_f32(currentValues, maxValues);
                 }
 
             // Calculate the largest value from the remaining 4 points
             vst1q_f32(maxValuesBuffer, maxValues);
             vst1q_f32(maxIndexesBuffer, vcvtq_f32_u32(maxValuesIndex));
-            for(number = 0; number < 4; number++)
+            for (number = 0; number < 4; number++)
                 {
-                    if(maxValuesBuffer[number] > max)
+                    if (maxValuesBuffer[number] > max)
                         {
                             index = maxIndexesBuffer[number];
                             max = maxValuesBuffer[number];
@@ -513,9 +534,9 @@ static inline void volk_gnsssdr_32f_index_max_32u_neon(uint32_t* target, const f
                 }
 
             number = quarterPoints * 4;
-            for(;number < num_points; number++)
+            for (; number < num_points; number++)
                 {
-                    if(src0[number] > max)
+                    if (src0[number] > max)
                         {
                             index = number;
                             max = src0[number];
@@ -528,4 +549,3 @@ static inline void volk_gnsssdr_32f_index_max_32u_neon(uint32_t* target, const f
 #endif /*LV_HAVE_NEON*/
 
 #endif /*INCLUDED_volk_gnsssdr_32f_index_max_32u_H*/
-

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32f_resamplerxnpuppet_32f.h

@@ -42,31 +42,30 @@
 #include <string.h>
 
 
-
 #ifdef LV_HAVE_GENERIC
 static inline void volk_gnsssdr_32f_resamplerxnpuppet_32f_generic(float* result, const float* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1  };
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
 
-    float** result_aux =  (float**)volk_gnsssdr_malloc(sizeof(float*) * num_out_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
-    }
+    float** result_aux = (float**)volk_gnsssdr_malloc(sizeof(float*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_32f_xn_resampler_32f_xn_generic(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((float*)result, (float*)result_aux[0], sizeof(float) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -77,26 +76,26 @@ static inline void volk_gnsssdr_32f_resamplerxnpuppet_32f_generic(float* result,
 static inline void volk_gnsssdr_32f_resamplerxnpuppet_32f_a_sse3(float* result, const float* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
 
-    float** result_aux =  (float**)volk_gnsssdr_malloc(sizeof(float*) * num_out_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
-    }
+    float** result_aux = (float**)volk_gnsssdr_malloc(sizeof(float*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_32f_xn_resampler_32f_xn_a_sse3(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((float*)result, (float*)result_aux[0], sizeof(float) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -106,26 +105,26 @@ static inline void volk_gnsssdr_32f_resamplerxnpuppet_32f_a_sse3(float* result,
 static inline void volk_gnsssdr_32f_resamplerxnpuppet_32f_u_sse3(float* result, const float* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
 
-    float** result_aux =  (float**)volk_gnsssdr_malloc(sizeof(float*) * num_out_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
-    }
+    float** result_aux = (float**)volk_gnsssdr_malloc(sizeof(float*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_32f_xn_resampler_32f_xn_u_sse3(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((float*)result, (float*)result_aux[0], sizeof(float) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -136,26 +135,26 @@ static inline void volk_gnsssdr_32f_resamplerxnpuppet_32f_u_sse3(float* result,
 static inline void volk_gnsssdr_32f_resamplerxnpuppet_32f_u_sse4_1(float* result, const float* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
 
-    float** result_aux =  (float**)volk_gnsssdr_malloc(sizeof(float*) * num_out_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
-    }
+    float** result_aux = (float**)volk_gnsssdr_malloc(sizeof(float*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_32f_xn_resampler_32f_xn_u_sse4_1(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((float*)result, (float*)result_aux[0], sizeof(float) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -165,26 +164,26 @@ static inline void volk_gnsssdr_32f_resamplerxnpuppet_32f_u_sse4_1(float* result
 static inline void volk_gnsssdr_32f_resamplerxnpuppet_32f_a_sse4_1(float* result, const float* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
 
-    float** result_aux =  (float**)volk_gnsssdr_malloc(sizeof(float*) * num_out_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
-    }
+    float** result_aux = (float**)volk_gnsssdr_malloc(sizeof(float*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_32f_xn_resampler_32f_xn_a_sse4_1(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((float*)result, (float*)result_aux[0], sizeof(float) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -194,26 +193,26 @@ static inline void volk_gnsssdr_32f_resamplerxnpuppet_32f_a_sse4_1(float* result
 static inline void volk_gnsssdr_32f_resamplerxnpuppet_32f_a_avx(float* result, const float* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
 
-    float** result_aux =  (float**)volk_gnsssdr_malloc(sizeof(float*) * num_out_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
-    }
+    float** result_aux = (float**)volk_gnsssdr_malloc(sizeof(float*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_32f_xn_resampler_32f_xn_a_avx(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((float*)result, (float*)result_aux[0], sizeof(float) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 #endif
@@ -223,26 +222,26 @@ static inline void volk_gnsssdr_32f_resamplerxnpuppet_32f_a_avx(float* result, c
 static inline void volk_gnsssdr_32f_resamplerxnpuppet_32f_u_avx(float* result, const float* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
 
-    float** result_aux =  (float**)volk_gnsssdr_malloc(sizeof(float*) * num_out_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
-    }
+    float** result_aux = (float**)volk_gnsssdr_malloc(sizeof(float*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_32f_xn_resampler_32f_xn_u_avx(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((float*)result, (float*)result_aux[0], sizeof(float) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 #endif
@@ -251,29 +250,28 @@ static inline void volk_gnsssdr_32f_resamplerxnpuppet_32f_u_avx(float* result, c
 static inline void volk_gnsssdr_32f_resamplerxnpuppet_32f_neon(float* result, const float* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
 
-    float** result_aux =  (float**)volk_gnsssdr_malloc(sizeof(float*) * num_out_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
-    }
+    float** result_aux = (float**)volk_gnsssdr_malloc(sizeof(float*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_32f_xn_resampler_32f_xn_neon(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((float*)result, (float*)result_aux[0], sizeof(float) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 #endif
 
-#endif // INCLUDED_volk_gnsssdr_32f_resamplerpuppet_32f_H
-
+#endif  // INCLUDED_volk_gnsssdr_32f_resamplerpuppet_32f_H

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32f_sincos_32fc.h

@@ -97,7 +97,7 @@ static inline void volk_gnsssdr_32f_sincos_32fc_u_sse4_1(lv_32fc_t* out, const f
     cp4 = _mm_set1_ps(0.49603e-4);
     cp5 = _mm_set1_ps(0.551e-6);
 
-    for(;number < quarterPoints; number++)
+    for (; number < quarterPoints; number++)
         {
             aVal = _mm_loadu_ps(aPtr);
             __VOLK_GNSSSDR_PREFETCH(aPtr + 8);
@@ -108,12 +108,12 @@ static inline void volk_gnsssdr_32f_sincos_32fc_u_sse4_1(lv_32fc_t* out, const f
             s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4A));
             s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4B));
 
-            s = _mm_div_ps(s, _mm_set1_ps(8.0));    // The constant is 2^N, for 3 times argument reduction
+            s = _mm_div_ps(s, _mm_set1_ps(8.0));  // The constant is 2^N, for 3 times argument reduction
             s = _mm_mul_ps(s, s);
             // Evaluate Taylor series
             s = _mm_mul_ps(_mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(_mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(s, cp5), cp4), s), cp3), s), cp2), s), cp1), s);
 
-            for(i = 0; i < 3; i++)
+            for (i = 0; i < 3; i++)
                 {
                     s = _mm_mul_ps(s, _mm_sub_ps(ffours, s));
                 }
@@ -145,7 +145,7 @@ static inline void volk_gnsssdr_32f_sincos_32fc_u_sse4_1(lv_32fc_t* out, const f
         }
 
     number = quarterPoints * 4;
-    for(;number < num_points; number++)
+    for (; number < num_points; number++)
         {
             float _in = *aPtr++;
             *bPtr++ = lv_cmake(cosf(_in), sinf(_in));
@@ -191,7 +191,7 @@ static inline void volk_gnsssdr_32f_sincos_32fc_a_sse4_1(lv_32fc_t* out, const f
     cp4 = _mm_set1_ps(0.49603e-4);
     cp5 = _mm_set1_ps(0.551e-6);
 
-    for(;number < quarterPoints; number++)
+    for (; number < quarterPoints; number++)
         {
             aVal = _mm_load_ps(aPtr);
             __VOLK_GNSSSDR_PREFETCH(aPtr + 8);
@@ -202,12 +202,12 @@ static inline void volk_gnsssdr_32f_sincos_32fc_a_sse4_1(lv_32fc_t* out, const f
             s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4A));
             s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4B));
 
-            s = _mm_div_ps(s, _mm_set1_ps(8.0));    // The constant is 2^N, for 3 times argument reduction
+            s = _mm_div_ps(s, _mm_set1_ps(8.0));  // The constant is 2^N, for 3 times argument reduction
             s = _mm_mul_ps(s, s);
             // Evaluate Taylor series
             s = _mm_mul_ps(_mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(_mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(s, cp5), cp4), s), cp3), s), cp2), s), cp1), s);
 
-            for(i = 0; i < 3; i++)
+            for (i = 0; i < 3; i++)
                 {
                     s = _mm_mul_ps(s, _mm_sub_ps(ffours, s));
                 }
@@ -239,7 +239,7 @@ static inline void volk_gnsssdr_32f_sincos_32fc_a_sse4_1(lv_32fc_t* out, const f
         }
 
     number = quarterPoints * 4;
-    for(;number < num_points; number++)
+    for (; number < num_points; number++)
         {
             float _in = *aPtr++;
             *bPtr++ = lv_cmake(cosf(_in), sinf(_in));
@@ -265,31 +265,49 @@ static inline void volk_gnsssdr_32f_sincos_32fc_a_sse2(lv_32fc_t* out, const flo
     __m128 sine, cosine, aux, x;
     __m128 xmm1, xmm2, xmm3 = _mm_setzero_ps(), sign_bit_sin, y;
 
-    __m128i  emm0, emm2, emm4;
+    __m128i emm0, emm2, emm4;
 
     /* declare some SSE constants */
-    __VOLK_ATTR_ALIGNED(16) static const int _ps_inv_sign_mask[4] = { ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000 };
-    __VOLK_ATTR_ALIGNED(16) static const int _ps_sign_mask[4] = { (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000 };
+    __VOLK_ATTR_ALIGNED(16)
+    static const int _ps_inv_sign_mask[4] = {~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000};
+    __VOLK_ATTR_ALIGNED(16)
+    static const int _ps_sign_mask[4] = {(int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000};
 
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_cephes_FOPI[4] = { 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516 };
-    __VOLK_ATTR_ALIGNED(16) static const int _pi32_1[4] = { 1, 1, 1, 1 };
-    __VOLK_ATTR_ALIGNED(16) static const int _pi32_inv1[4] = { ~1, ~1, ~1, ~1 };
-    __VOLK_ATTR_ALIGNED(16) static const int _pi32_2[4] = { 2, 2, 2, 2};
-    __VOLK_ATTR_ALIGNED(16) static const int _pi32_4[4] = { 4, 4, 4, 4};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_cephes_FOPI[4] = {1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516};
+    __VOLK_ATTR_ALIGNED(16)
+    static const int _pi32_1[4] = {1, 1, 1, 1};
+    __VOLK_ATTR_ALIGNED(16)
+    static const int _pi32_inv1[4] = {~1, ~1, ~1, ~1};
+    __VOLK_ATTR_ALIGNED(16)
+    static const int _pi32_2[4] = {2, 2, 2, 2};
+    __VOLK_ATTR_ALIGNED(16)
+    static const int _pi32_4[4] = {4, 4, 4, 4};
 
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_minus_cephes_DP1[4] = { -0.78515625, -0.78515625, -0.78515625, -0.78515625 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_minus_cephes_DP2[4] = { -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_minus_cephes_DP3[4] = { -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_coscof_p0[4] = { 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_coscof_p1[4] = { -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_coscof_p2[4] = { 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_sincof_p0[4] = { -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_sincof_p1[4] = { 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_sincof_p2[4] = { -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_0p5[4] = { 0.5f, 0.5f, 0.5f, 0.5f };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_1[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_minus_cephes_DP1[4] = {-0.78515625, -0.78515625, -0.78515625, -0.78515625};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_minus_cephes_DP2[4] = {-2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_minus_cephes_DP3[4] = {-3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_coscof_p0[4] = {2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_coscof_p1[4] = {-1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_coscof_p2[4] = {4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_sincof_p0[4] = {-1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_sincof_p1[4] = {8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_sincof_p2[4] = {-1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_0p5[4] = {0.5f, 0.5f, 0.5f, 0.5f};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_1[4] = {1.0f, 1.0f, 1.0f, 1.0f};
 
-    for(;number < sse_iters; number++)
+    for (; number < sse_iters; number++)
         {
             x = _mm_load_ps(aPtr);
             __VOLK_GNSSSDR_PREFETCH(aPtr + 8);
@@ -307,19 +325,19 @@ static inline void volk_gnsssdr_32f_sincos_32fc_a_sse2(lv_32fc_t* out, const flo
             emm2 = _mm_cvttps_epi32(y);
 
             /* j=(j+1) & (~1) (see the cephes sources) */
-            emm2 = _mm_add_epi32(emm2, *(__m128i *)_pi32_1);
-            emm2 = _mm_and_si128(emm2, *(__m128i *)_pi32_inv1);
+            emm2 = _mm_add_epi32(emm2, *(__m128i*)_pi32_1);
+            emm2 = _mm_and_si128(emm2, *(__m128i*)_pi32_inv1);
             y = _mm_cvtepi32_ps(emm2);
 
             emm4 = emm2;
 
             /* get the swap sign flag for the sine */
-            emm0 = _mm_and_si128(emm2, *(__m128i *)_pi32_4);
+            emm0 = _mm_and_si128(emm2, *(__m128i*)_pi32_4);
             emm0 = _mm_slli_epi32(emm0, 29);
             __m128 swap_sign_bit_sin = _mm_castsi128_ps(emm0);
 
             /* get the polynom selection mask for the sine*/
-            emm2 = _mm_and_si128(emm2, *(__m128i *)_pi32_2);
+            emm2 = _mm_and_si128(emm2, *(__m128i*)_pi32_2);
             emm2 = _mm_cmpeq_epi32(emm2, _mm_setzero_si128());
             __m128 poly_mask = _mm_castsi128_ps(emm2);
 
@@ -335,15 +353,15 @@ static inline void volk_gnsssdr_32f_sincos_32fc_a_sse2(lv_32fc_t* out, const flo
             x = _mm_add_ps(x, xmm2);
             x = _mm_add_ps(x, xmm3);
 
-            emm4 = _mm_sub_epi32(emm4, *(__m128i *)_pi32_2);
-            emm4 = _mm_andnot_si128(emm4, *(__m128i *)_pi32_4);
+            emm4 = _mm_sub_epi32(emm4, *(__m128i*)_pi32_2);
+            emm4 = _mm_andnot_si128(emm4, *(__m128i*)_pi32_4);
             emm4 = _mm_slli_epi32(emm4, 29);
             __m128 sign_bit_cos = _mm_castsi128_ps(emm4);
 
             sign_bit_sin = _mm_xor_ps(sign_bit_sin, swap_sign_bit_sin);
 
             /* Evaluate the first polynom  (0 <= x <= Pi/4) */
-            __m128 z = _mm_mul_ps(x,x);
+            __m128 z = _mm_mul_ps(x, x);
             y = *(__m128*)_ps_coscof_p0;
 
             y = _mm_mul_ps(y, z);
@@ -371,11 +389,11 @@ static inline void volk_gnsssdr_32f_sincos_32fc_a_sse2(lv_32fc_t* out, const flo
             xmm3 = poly_mask;
             __m128 ysin2 = _mm_and_ps(xmm3, y2);
             __m128 ysin1 = _mm_andnot_ps(xmm3, y);
-            y2 = _mm_sub_ps(y2,ysin2);
+            y2 = _mm_sub_ps(y2, ysin2);
             y = _mm_sub_ps(y, ysin1);
 
-            xmm1 = _mm_add_ps(ysin1,ysin2);
-            xmm2 = _mm_add_ps(y,y2);
+            xmm1 = _mm_add_ps(ysin1, ysin2);
+            xmm2 = _mm_add_ps(y, y2);
 
             /* update the sign */
             sine = _mm_xor_ps(xmm1, sign_bit_sin);
@@ -392,12 +410,11 @@ static inline void volk_gnsssdr_32f_sincos_32fc_a_sse2(lv_32fc_t* out, const flo
             aPtr += 4;
         }
 
-    for(number = sse_iters * 4; number < num_points; number++)
+    for (number = sse_iters * 4; number < num_points; number++)
         {
             _in = *aPtr++;
-            *bPtr++ = lv_cmake((float)cosf(_in), (float)sinf(_in) );
+            *bPtr++ = lv_cmake((float)cosf(_in), (float)sinf(_in));
         }
-
 }
 #endif /* LV_HAVE_SSE2  */
 
@@ -418,31 +435,49 @@ static inline void volk_gnsssdr_32f_sincos_32fc_u_sse2(lv_32fc_t* out, const flo
     __m128 sine, cosine, aux, x;
     __m128 xmm1, xmm2, xmm3 = _mm_setzero_ps(), sign_bit_sin, y;
 
-    __m128i  emm0, emm2, emm4;
+    __m128i emm0, emm2, emm4;
 
     /* declare some SSE constants */
-    __VOLK_ATTR_ALIGNED(16) static const int _ps_inv_sign_mask[4] = { ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000 };
-    __VOLK_ATTR_ALIGNED(16) static const int _ps_sign_mask[4] = { (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000 };
+    __VOLK_ATTR_ALIGNED(16)
+    static const int _ps_inv_sign_mask[4] = {~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000};
+    __VOLK_ATTR_ALIGNED(16)
+    static const int _ps_sign_mask[4] = {(int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000};
 
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_cephes_FOPI[4] = { 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516 };
-    __VOLK_ATTR_ALIGNED(16) static const int _pi32_1[4]  = { 1, 1, 1, 1 };
-    __VOLK_ATTR_ALIGNED(16) static const int _pi32_inv1[4] = { ~1, ~1, ~1, ~1 };
-    __VOLK_ATTR_ALIGNED(16) static const int _pi32_2[4] = { 2, 2, 2, 2};
-    __VOLK_ATTR_ALIGNED(16) static const int _pi32_4[4] = { 4, 4, 4, 4};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_cephes_FOPI[4] = {1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516};
+    __VOLK_ATTR_ALIGNED(16)
+    static const int _pi32_1[4] = {1, 1, 1, 1};
+    __VOLK_ATTR_ALIGNED(16)
+    static const int _pi32_inv1[4] = {~1, ~1, ~1, ~1};
+    __VOLK_ATTR_ALIGNED(16)
+    static const int _pi32_2[4] = {2, 2, 2, 2};
+    __VOLK_ATTR_ALIGNED(16)
+    static const int _pi32_4[4] = {4, 4, 4, 4};
 
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_minus_cephes_DP1[4] = { -0.78515625, -0.78515625, -0.78515625, -0.78515625 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_minus_cephes_DP2[4] = { -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_minus_cephes_DP3[4] = { -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_coscof_p0[4] = { 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_coscof_p1[4] = { -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_coscof_p2[4] = { 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_sincof_p0[4] = { -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_sincof_p1[4] = { 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_sincof_p2[4] = { -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_0p5[4] = { 0.5f, 0.5f, 0.5f, 0.5f };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_1[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_minus_cephes_DP1[4] = {-0.78515625, -0.78515625, -0.78515625, -0.78515625};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_minus_cephes_DP2[4] = {-2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_minus_cephes_DP3[4] = {-3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_coscof_p0[4] = {2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_coscof_p1[4] = {-1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_coscof_p2[4] = {4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_sincof_p0[4] = {-1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_sincof_p1[4] = {8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_sincof_p2[4] = {-1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_0p5[4] = {0.5f, 0.5f, 0.5f, 0.5f};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_1[4] = {1.0f, 1.0f, 1.0f, 1.0f};
 
-    for(;number < sse_iters; number++)
+    for (; number < sse_iters; number++)
         {
             x = _mm_loadu_ps(aPtr);
             __VOLK_GNSSSDR_PREFETCH(aPtr + 8);
@@ -460,19 +495,19 @@ static inline void volk_gnsssdr_32f_sincos_32fc_u_sse2(lv_32fc_t* out, const flo
             emm2 = _mm_cvttps_epi32(y);
 
             /* j=(j+1) & (~1) (see the cephes sources) */
-            emm2 = _mm_add_epi32(emm2, *(__m128i *)_pi32_1);
-            emm2 = _mm_and_si128(emm2, *(__m128i *)_pi32_inv1);
+            emm2 = _mm_add_epi32(emm2, *(__m128i*)_pi32_1);
+            emm2 = _mm_and_si128(emm2, *(__m128i*)_pi32_inv1);
             y = _mm_cvtepi32_ps(emm2);
 
             emm4 = emm2;
 
             /* get the swap sign flag for the sine */
-            emm0 = _mm_and_si128(emm2, *(__m128i *)_pi32_4);
+            emm0 = _mm_and_si128(emm2, *(__m128i*)_pi32_4);
             emm0 = _mm_slli_epi32(emm0, 29);
             __m128 swap_sign_bit_sin = _mm_castsi128_ps(emm0);
 
             /* get the polynom selection mask for the sine*/
-            emm2 = _mm_and_si128(emm2, *(__m128i *)_pi32_2);
+            emm2 = _mm_and_si128(emm2, *(__m128i*)_pi32_2);
             emm2 = _mm_cmpeq_epi32(emm2, _mm_setzero_si128());
             __m128 poly_mask = _mm_castsi128_ps(emm2);
 
@@ -488,15 +523,15 @@ static inline void volk_gnsssdr_32f_sincos_32fc_u_sse2(lv_32fc_t* out, const flo
             x = _mm_add_ps(x, xmm2);
             x = _mm_add_ps(x, xmm3);
 
-            emm4 = _mm_sub_epi32(emm4, *(__m128i *)_pi32_2);
-            emm4 = _mm_andnot_si128(emm4, *(__m128i *)_pi32_4);
+            emm4 = _mm_sub_epi32(emm4, *(__m128i*)_pi32_2);
+            emm4 = _mm_andnot_si128(emm4, *(__m128i*)_pi32_4);
             emm4 = _mm_slli_epi32(emm4, 29);
             __m128 sign_bit_cos = _mm_castsi128_ps(emm4);
 
             sign_bit_sin = _mm_xor_ps(sign_bit_sin, swap_sign_bit_sin);
 
             /* Evaluate the first polynom  (0 <= x <= Pi/4) */
-            __m128 z = _mm_mul_ps(x,x);
+            __m128 z = _mm_mul_ps(x, x);
             y = *(__m128*)_ps_coscof_p0;
 
             y = _mm_mul_ps(y, z);
@@ -524,11 +559,11 @@ static inline void volk_gnsssdr_32f_sincos_32fc_u_sse2(lv_32fc_t* out, const flo
             xmm3 = poly_mask;
             __m128 ysin2 = _mm_and_ps(xmm3, y2);
             __m128 ysin1 = _mm_andnot_ps(xmm3, y);
-            y2 = _mm_sub_ps(y2,ysin2);
+            y2 = _mm_sub_ps(y2, ysin2);
             y = _mm_sub_ps(y, ysin1);
 
-            xmm1 = _mm_add_ps(ysin1,ysin2);
-            xmm2 = _mm_add_ps(y,y2);
+            xmm1 = _mm_add_ps(ysin1, ysin2);
+            xmm2 = _mm_add_ps(y, y2);
 
             /* update the sign */
             sine = _mm_xor_ps(xmm1, sign_bit_sin);
@@ -545,12 +580,11 @@ static inline void volk_gnsssdr_32f_sincos_32fc_u_sse2(lv_32fc_t* out, const flo
             aPtr += 4;
         }
 
-    for(number = sse_iters * 4; number < num_points; number++)
+    for (number = sse_iters * 4; number < num_points; number++)
         {
             _in = *aPtr++;
-            *bPtr++ = lv_cmake((float)cosf(_in), (float)sinf(_in) );
+            *bPtr++ = lv_cmake((float)cosf(_in), (float)sinf(_in));
         }
-
 }
 #endif /* LV_HAVE_SSE2  */
 
@@ -561,10 +595,10 @@ static inline void volk_gnsssdr_32f_sincos_32fc_generic(lv_32fc_t* out, const fl
 {
     float _in;
     unsigned int i;
-    for(i = 0; i < num_points; i++)
+    for (i = 0; i < num_points; i++)
         {
             _in = *in++;
-            *out++ = lv_cmake((float)cosf(_in), (float)sinf(_in) );
+            *out++ = lv_cmake((float)cosf(_in), (float)sinf(_in));
         }
 }
 
@@ -586,12 +620,12 @@ static inline void volk_gnsssdr_32f_sincos_32fc_generic_fxpt(lv_32fc_t* out, con
     const int32_t diffbits = bitlength - Nbits;
     uint32_t ux;
     unsigned int i;
-    for(i = 0; i < num_points; i++)
+    for (i = 0; i < num_points; i++)
         {
             _in = *in++;
             d = (int32_t)floor(_in / TWO_PI + 0.5);
             _in -= d * TWO_PI;
-            x = (int32_t) ((float)_in * TWO_TO_THE_31_DIV_PI);
+            x = (int32_t)((float)_in * TWO_TO_THE_31_DIV_PI);
 
             ux = x;
             sin_index = ux >> diffbits;
@@ -601,7 +635,7 @@ static inline void volk_gnsssdr_32f_sincos_32fc_generic_fxpt(lv_32fc_t* out, con
             cos_index = ux >> diffbits;
             c = sine_table_10bits[cos_index][0] * (ux >> 1) + sine_table_10bits[cos_index][1];
 
-            *out++ = lv_cmake((float)c, (float)s );
+            *out++ = lv_cmake((float)c, (float)s);
         }
 }
 
@@ -637,7 +671,7 @@ static inline void volk_gnsssdr_32f_sincos_32fc_neon(lv_32fc_t* out, const float
 
     uint32x4_t emm2, poly_mask, sign_mask_sin, sign_mask_cos;
 
-    for(;number < neon_iters; number++)
+    for (; number < neon_iters; number++)
         {
             x = vld1q_f32(aPtr);
             __VOLK_GNSSSDR_PREFETCH(aPtr + 8);
@@ -677,7 +711,7 @@ static inline void volk_gnsssdr_32f_sincos_32fc_neon(lv_32fc_t* out, const float
 
             /* Evaluate the first polynom  (0 <= x <= Pi/4) in y1,
                     and the second polynom      (Pi/4 <= x <= 0) in y2 */
-            z = vmulq_f32(x,x);
+            z = vmulq_f32(x, x);
 
             y1 = vmulq_n_f32(z, c_coscof_p0);
             y2 = vmulq_n_f32(z, c_sincof_p0);
@@ -706,10 +740,10 @@ static inline void volk_gnsssdr_32f_sincos_32fc_neon(lv_32fc_t* out, const float
             aPtr += 4;
         }
 
-    for(number = neon_iters * 4; number < num_points; number++)
+    for (number = neon_iters * 4; number < num_points; number++)
         {
             _in = *aPtr++;
-            *bPtr++ = lv_cmake((float)cosf(_in), (float)sinf(_in) );
+            *bPtr++ = lv_cmake((float)cosf(_in), (float)sinf(_in));
         }
 }
 

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32f_xn_resampler_32f_xn.h

@@ -110,7 +110,8 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_a_sse3(float** result, c
     const __m128 rem_code_phase_chips_reg = _mm_set_ps1(rem_code_phase_chips);
     const __m128 code_phase_step_chips_reg = _mm_set_ps1(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     int local_code_chip_index_;
 
     const __m128i zeros = _mm_setzero_si128();
@@ -124,7 +125,7 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_a_sse3(float** result, c
             shifts_chips_reg = _mm_set_ps1((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             __m128 indexn = _mm_set_ps(3.0f, 2.0f, 1.0f, 0.0f);
-            for(n = 0; n < quarterPoints; n++)
+            for (n = 0; n < quarterPoints; n++)
                 {
                     aux = _mm_mul_ps(code_phase_step_chips_reg, indexn);
                     aux = _mm_add_ps(aux, aux2);
@@ -145,18 +146,18 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_a_sse3(float** result, c
                     aux_i = _mm_and_si128(code_length_chips_reg_i, negatives);
                     local_code_chip_index_reg = _mm_add_epi32(local_code_chip_index_reg, aux_i);
                     _mm_store_si128((__m128i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 4; ++k)
+                    for (k = 0; k < 4; ++k)
                         {
                             _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
                         }
                     indexn = _mm_add_ps(indexn, fours);
                 }
-            for(n = quarterPoints * 4; n < num_points; n++)
+            for (n = quarterPoints * 4; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
                     //Take into account that in multitap correlators, the shifts can be negative!
-                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1) ;
+                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1);
                     local_code_chip_index_ = local_code_chip_index_ % code_length_chips;
                     _result[current_correlator_tap][n] = local_code[local_code_chip_index_];
                 }
@@ -180,7 +181,8 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_u_sse3(float** result, c
     const __m128 rem_code_phase_chips_reg = _mm_set_ps1(rem_code_phase_chips);
     const __m128 code_phase_step_chips_reg = _mm_set_ps1(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     int local_code_chip_index_;
 
     const __m128i zeros = _mm_setzero_si128();
@@ -194,7 +196,7 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_u_sse3(float** result, c
             shifts_chips_reg = _mm_set_ps1((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             __m128 indexn = _mm_set_ps(3.0f, 2.0f, 1.0f, 0.0f);
-            for(n = 0; n < quarterPoints; n++)
+            for (n = 0; n < quarterPoints; n++)
                 {
                     aux = _mm_mul_ps(code_phase_step_chips_reg, indexn);
                     aux = _mm_add_ps(aux, aux2);
@@ -215,18 +217,18 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_u_sse3(float** result, c
                     aux_i = _mm_and_si128(code_length_chips_reg_i, negatives);
                     local_code_chip_index_reg = _mm_add_epi32(local_code_chip_index_reg, aux_i);
                     _mm_store_si128((__m128i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 4; ++k)
+                    for (k = 0; k < 4; ++k)
                         {
                             _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
                         }
                     indexn = _mm_add_ps(indexn, fours);
                 }
-            for(n = quarterPoints * 4; n < num_points; n++)
+            for (n = quarterPoints * 4; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
                     //Take into account that in multitap correlators, the shifts can be negative!
-                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1) ;
+                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1);
                     local_code_chip_index_ = local_code_chip_index_ % code_length_chips;
                     _result[current_correlator_tap][n] = local_code[local_code_chip_index_];
                 }
@@ -248,7 +250,8 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_a_sse4_1(float** result,
     const __m128 rem_code_phase_chips_reg = _mm_set_ps1(rem_code_phase_chips);
     const __m128 code_phase_step_chips_reg = _mm_set_ps1(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     int local_code_chip_index_;
 
     const __m128i zeros = _mm_setzero_si128();
@@ -262,7 +265,7 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_a_sse4_1(float** result,
             shifts_chips_reg = _mm_set_ps1((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             __m128 indexn = _mm_set_ps(3.0f, 2.0f, 1.0f, 0.0f);
-            for(n = 0; n < quarterPoints; n++)
+            for (n = 0; n < quarterPoints; n++)
                 {
                     aux = _mm_mul_ps(code_phase_step_chips_reg, indexn);
                     aux = _mm_add_ps(aux, aux2);
@@ -280,18 +283,18 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_a_sse4_1(float** result,
                     aux_i = _mm_and_si128(code_length_chips_reg_i, negatives);
                     local_code_chip_index_reg = _mm_add_epi32(local_code_chip_index_reg, aux_i);
                     _mm_store_si128((__m128i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 4; ++k)
+                    for (k = 0; k < 4; ++k)
                         {
                             _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
                         }
                     indexn = _mm_add_ps(indexn, fours);
                 }
-            for(n = quarterPoints * 4; n < num_points; n++)
+            for (n = quarterPoints * 4; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
                     //Take into account that in multitap correlators, the shifts can be negative!
-                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1) ;
+                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1);
                     local_code_chip_index_ = local_code_chip_index_ % code_length_chips;
                     _result[current_correlator_tap][n] = local_code[local_code_chip_index_];
                 }
@@ -314,7 +317,8 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_u_sse4_1(float** result,
     const __m128 rem_code_phase_chips_reg = _mm_set_ps1(rem_code_phase_chips);
     const __m128 code_phase_step_chips_reg = _mm_set_ps1(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     int local_code_chip_index_;
 
     const __m128i zeros = _mm_setzero_si128();
@@ -328,7 +332,7 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_u_sse4_1(float** result,
             shifts_chips_reg = _mm_set_ps1((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             __m128 indexn = _mm_set_ps(3.0f, 2.0f, 1.0f, 0.0f);
-            for(n = 0; n < quarterPoints; n++)
+            for (n = 0; n < quarterPoints; n++)
                 {
                     aux = _mm_mul_ps(code_phase_step_chips_reg, indexn);
                     aux = _mm_add_ps(aux, aux2);
@@ -346,18 +350,18 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_u_sse4_1(float** result,
                     aux_i = _mm_and_si128(code_length_chips_reg_i, negatives);
                     local_code_chip_index_reg = _mm_add_epi32(local_code_chip_index_reg, aux_i);
                     _mm_store_si128((__m128i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 4; ++k)
+                    for (k = 0; k < 4; ++k)
                         {
                             _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
                         }
                     indexn = _mm_add_ps(indexn, fours);
                 }
-            for(n = quarterPoints * 4; n < num_points; n++)
+            for (n = quarterPoints * 4; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
                     //Take into account that in multitap correlators, the shifts can be negative!
-                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1) ;
+                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1);
                     local_code_chip_index_ = local_code_chip_index_ % code_length_chips;
                     _result[current_correlator_tap][n] = local_code[local_code_chip_index_];
                 }
@@ -380,7 +384,8 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_a_avx(float** result, co
     const __m256 rem_code_phase_chips_reg = _mm256_set1_ps(rem_code_phase_chips);
     const __m256 code_phase_step_chips_reg = _mm256_set1_ps(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(32) int local_code_chip_index[8];
+    __VOLK_ATTR_ALIGNED(32)
+    int local_code_chip_index[8];
     int local_code_chip_index_;
 
     const __m256 zeros = _mm256_setzero_ps();
@@ -395,7 +400,7 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_a_avx(float** result, co
             shifts_chips_reg = _mm256_set1_ps((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm256_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             indexn = n0;
-            for(n = 0; n < avx_iters; n++)
+            for (n = 0; n < avx_iters; n++)
                 {
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&_result[current_correlator_tap][8 * n + 7], 1, 0);
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&local_code_chip_index[8], 1, 3);
@@ -413,13 +418,13 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_a_avx(float** result, co
 
                     // no negatives
                     c = _mm256_cvtepi32_ps(local_code_chip_index_reg);
-                    negatives = _mm256_cmp_ps(c, zeros, 0x01 );
+                    negatives = _mm256_cmp_ps(c, zeros, 0x01);
                     aux3 = _mm256_and_ps(code_length_chips_reg_f, negatives);
                     aux = _mm256_add_ps(c, aux3);
                     local_code_chip_index_reg = _mm256_cvttps_epi32(aux);
 
                     _mm256_store_si256((__m256i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 8; ++k)
+                    for (k = 0; k < 8; ++k)
                         {
                             _result[current_correlator_tap][n * 8 + k] = local_code[local_code_chip_index[k]];
                         }
@@ -429,12 +434,12 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_a_avx(float** result, co
     _mm256_zeroupper();
     for (current_correlator_tap = 0; current_correlator_tap < num_out_vectors; current_correlator_tap++)
         {
-            for(n = avx_iters * 8; n < num_points; n++)
+            for (n = avx_iters * 8; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
                     //Take into account that in multitap correlators, the shifts can be negative!
-                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1) ;
+                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1);
                     local_code_chip_index_ = local_code_chip_index_ % code_length_chips;
                     _result[current_correlator_tap][n] = local_code[local_code_chip_index_];
                 }
@@ -457,7 +462,8 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_u_avx(float** result, co
     const __m256 rem_code_phase_chips_reg = _mm256_set1_ps(rem_code_phase_chips);
     const __m256 code_phase_step_chips_reg = _mm256_set1_ps(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(32) int local_code_chip_index[8];
+    __VOLK_ATTR_ALIGNED(32)
+    int local_code_chip_index[8];
     int local_code_chip_index_;
 
     const __m256 zeros = _mm256_setzero_ps();
@@ -472,7 +478,7 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_u_avx(float** result, co
             shifts_chips_reg = _mm256_set1_ps((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm256_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             indexn = n0;
-            for(n = 0; n < avx_iters; n++)
+            for (n = 0; n < avx_iters; n++)
                 {
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&_result[current_correlator_tap][8 * n + 7], 1, 0);
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&local_code_chip_index[8], 1, 3);
@@ -490,13 +496,13 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_u_avx(float** result, co
 
                     // no negatives
                     c = _mm256_cvtepi32_ps(local_code_chip_index_reg);
-                    negatives = _mm256_cmp_ps(c, zeros, 0x01 );
+                    negatives = _mm256_cmp_ps(c, zeros, 0x01);
                     aux3 = _mm256_and_ps(code_length_chips_reg_f, negatives);
                     aux = _mm256_add_ps(c, aux3);
                     local_code_chip_index_reg = _mm256_cvttps_epi32(aux);
 
                     _mm256_store_si256((__m256i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 8; ++k)
+                    for (k = 0; k < 8; ++k)
                         {
                             _result[current_correlator_tap][n * 8 + k] = local_code[local_code_chip_index[k]];
                         }
@@ -506,12 +512,12 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_u_avx(float** result, co
     _mm256_zeroupper();
     for (current_correlator_tap = 0; current_correlator_tap < num_out_vectors; current_correlator_tap++)
         {
-            for(n = avx_iters * 8; n < num_points; n++)
+            for (n = avx_iters * 8; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
                     //Take into account that in multitap correlators, the shifts can be negative!
-                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1) ;
+                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1);
                     local_code_chip_index_ = local_code_chip_index_ % code_length_chips;
                     _result[current_correlator_tap][n] = local_code[local_code_chip_index_];
                 }
@@ -536,19 +542,21 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_neon(float** result, con
     const float32x4_t rem_code_phase_chips_reg = vdupq_n_f32(rem_code_phase_chips);
     const float32x4_t code_phase_step_chips_reg = vdupq_n_f32(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(16) int32_t local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int32_t local_code_chip_index[4];
     int32_t local_code_chip_index_;
 
     const int32x4_t zeros = vdupq_n_s32(0);
     const float32x4_t code_length_chips_reg_f = vdupq_n_f32((float)code_length_chips);
     const int32x4_t code_length_chips_reg_i = vdupq_n_s32((int32_t)code_length_chips);
-    int32x4_t local_code_chip_index_reg, aux_i,  negatives, i;
+    int32x4_t local_code_chip_index_reg, aux_i, negatives, i;
     float32x4_t aux, aux2, shifts_chips_reg, fi, c, j, cTrunc, base, indexn, reciprocal;
-    __VOLK_ATTR_ALIGNED(16) const float vec[4] = { 0.0f, 1.0f, 2.0f, 3.0f };
+    __VOLK_ATTR_ALIGNED(16)
+    const float vec[4] = {0.0f, 1.0f, 2.0f, 3.0f};
     uint32x4_t igx;
     reciprocal = vrecpeq_f32(code_length_chips_reg_f);
     reciprocal = vmulq_f32(vrecpsq_f32(code_length_chips_reg_f, reciprocal), reciprocal);
-    reciprocal = vmulq_f32(vrecpsq_f32(code_length_chips_reg_f, reciprocal), reciprocal); // this refinement is required!
+    reciprocal = vmulq_f32(vrecpsq_f32(code_length_chips_reg_f, reciprocal), reciprocal);  // this refinement is required!
     float32x4_t n0 = vld1q_f32((float*)vec);
 
     for (current_correlator_tap = 0; current_correlator_tap < num_out_vectors; current_correlator_tap++)
@@ -556,7 +564,7 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_neon(float** result, con
             shifts_chips_reg = vdupq_n_f32((float)shifts_chips[current_correlator_tap]);
             aux2 = vsubq_f32(shifts_chips_reg, rem_code_phase_chips_reg);
             indexn = n0;
-            for(n = 0; n < neon_iters; n++)
+            for (n = 0; n < neon_iters; n++)
                 {
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&_result[current_correlator_tap][4 * n + 3], 1, 0);
                     __VOLK_GNSSSDR_PREFETCH(&local_code_chip_index[4]);
@@ -572,7 +580,7 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_neon(float** result, con
 
                     // fmod
                     c = vmulq_f32(aux, reciprocal);
-                    i =  vcvtq_s32_f32(c);
+                    i = vcvtq_s32_f32(c);
                     cTrunc = vcvtq_f32_s32(i);
                     base = vmulq_f32(cTrunc, code_length_chips_reg_f);
                     aux = vsubq_f32(aux, base);
@@ -584,13 +592,13 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_neon(float** result, con
 
                     vst1q_s32((int32_t*)local_code_chip_index, local_code_chip_index_reg);
 
-                    for(k = 0; k < 4; ++k)
+                    for (k = 0; k < 4; ++k)
                         {
                             _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
                         }
                     indexn = vaddq_f32(indexn, fours);
                 }
-            for(n = neon_iters * 4; n < num_points; n++)
+            for (n = neon_iters * 4; n < num_points; n++)
                 {
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&_result[current_correlator_tap][n], 1, 0);
                     // resample code for current tap
@@ -606,5 +614,3 @@ static inline void volk_gnsssdr_32f_xn_resampler_32f_xn_neon(float** result, con
 #endif
 
 #endif /*INCLUDED_volk_gnsssdr_32f_xn_resampler_32f_xn_H*/
-
-

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn.h

@@ -85,11 +85,11 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_generic(lv_32f
     unsigned int n;
     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
         {
-            result[n_vec] = lv_cmake(0,0);
+            result[n_vec] = lv_cmake(0, 0);
         }
     for (n = 0; n < num_points; n++)
         {
-            tmp32_1 = *in_common++ * (*phase);//if(n<10 || n >= 8108) printf("generic phase %i: %f,%f\n", n,lv_creal(*phase),lv_cimag(*phase));
+            tmp32_1 = *in_common++ * (*phase);  //if(n<10 || n >= 8108) printf("generic phase %i: %f,%f\n", n,lv_creal(*phase),lv_cimag(*phase));
 
             // Regenerate phase
             if (n % 256 == 0)
@@ -126,7 +126,7 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_generic_reload
     unsigned int j;
     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
         {
-            result[n_vec] = lv_cmake(0,0);
+            result[n_vec] = lv_cmake(0, 0);
         }
 
     for (n = 0; n < num_points / ROTATOR_RELOAD; n++)
@@ -141,7 +141,7 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_generic_reload
                             result[n_vec] += tmp32_2;
                         }
                 }
-            /* Regenerate phase */
+                /* Regenerate phase */
 #ifdef __cplusplus
             (*phase) /= std::abs((*phase));
 #else
@@ -175,8 +175,8 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_u_avx(lv_32fc_
     const unsigned int sixteenthPoints = num_points / 16;
 
     const float* aPtr = (float*)in_common;
-    const float* bPtr[ num_a_vectors];
-    for( vec_ind = 0; vec_ind < num_a_vectors; ++vec_ind )
+    const float* bPtr[num_a_vectors];
+    for (vec_ind = 0; vec_ind < num_a_vectors; ++vec_ind)
         {
             bPtr[vec_ind] = in_a[vec_ind];
         }
@@ -194,7 +194,7 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_u_avx(lv_32fc_
     __m256 dotProdVal2[num_a_vectors];
     __m256 dotProdVal3[num_a_vectors];
 
-    for( vec_ind = 0; vec_ind < num_a_vectors; vec_ind++ )
+    for (vec_ind = 0; vec_ind < num_a_vectors; vec_ind++)
         {
             dotProdVal0[vec_ind] = _mm256_setzero_ps();
             dotProdVal1[vec_ind] = _mm256_setzero_ps();
@@ -204,57 +204,62 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_u_avx(lv_32fc_
 
     // Set up the complex rotator
     __m256 z0, z1, z2, z3;
-    __VOLK_ATTR_ALIGNED(32) lv_32fc_t phase_vec[16];
-    for( vec_ind = 0; vec_ind < 16; ++vec_ind )
+    __VOLK_ATTR_ALIGNED(32)
+    lv_32fc_t phase_vec[16];
+    for (vec_ind = 0; vec_ind < 16; ++vec_ind)
         {
             phase_vec[vec_ind] = _phase;
             _phase *= phase_inc;
         }
 
-    z0 = _mm256_load_ps( (float *)phase_vec );
-    z1 = _mm256_load_ps( (float *)(phase_vec + 4) );
-    z2 = _mm256_load_ps( (float *)(phase_vec + 8) );
-    z3 = _mm256_load_ps( (float *)(phase_vec + 12) );
+    z0 = _mm256_load_ps((float*)phase_vec);
+    z1 = _mm256_load_ps((float*)(phase_vec + 4));
+    z2 = _mm256_load_ps((float*)(phase_vec + 8));
+    z3 = _mm256_load_ps((float*)(phase_vec + 12));
 
-    lv_32fc_t dz = phase_inc; dz *= dz; dz *= dz; dz *= dz; dz *= dz; // dz = phase_inc^16;
+    lv_32fc_t dz = phase_inc;
+    dz *= dz;
+    dz *= dz;
+    dz *= dz;
+    dz *= dz;  // dz = phase_inc^16;
 
-    for( vec_ind = 0; vec_ind < 4; ++vec_ind )
+    for (vec_ind = 0; vec_ind < 4; ++vec_ind)
         {
             phase_vec[vec_ind] = dz;
         }
 
-    __m256 dz_reg = _mm256_load_ps( (float *)phase_vec );
-    dz_reg = _mm256_complexnormalise_ps( dz_reg );
+    __m256 dz_reg = _mm256_load_ps((float*)phase_vec);
+    dz_reg = _mm256_complexnormalise_ps(dz_reg);
 
-    for(;number < sixteenthPoints; number++)
+    for (; number < sixteenthPoints; number++)
         {
             a0Val = _mm256_loadu_ps(aPtr);
-            a1Val = _mm256_loadu_ps(aPtr+8);
-            a2Val = _mm256_loadu_ps(aPtr+16);
-            a3Val = _mm256_loadu_ps(aPtr+24);
+            a1Val = _mm256_loadu_ps(aPtr + 8);
+            a2Val = _mm256_loadu_ps(aPtr + 16);
+            a3Val = _mm256_loadu_ps(aPtr + 24);
 
-            a0Val = _mm256_complexmul_ps( a0Val, z0 );
-            a1Val = _mm256_complexmul_ps( a1Val, z1 );
-            a2Val = _mm256_complexmul_ps( a2Val, z2 );
-            a3Val = _mm256_complexmul_ps( a3Val, z3 );
+            a0Val = _mm256_complexmul_ps(a0Val, z0);
+            a1Val = _mm256_complexmul_ps(a1Val, z1);
+            a2Val = _mm256_complexmul_ps(a2Val, z2);
+            a3Val = _mm256_complexmul_ps(a3Val, z3);
 
-            z0 = _mm256_complexmul_ps( z0, dz_reg );
-            z1 = _mm256_complexmul_ps( z1, dz_reg );
-            z2 = _mm256_complexmul_ps( z2, dz_reg );
-            z3 = _mm256_complexmul_ps( z3, dz_reg );
+            z0 = _mm256_complexmul_ps(z0, dz_reg);
+            z1 = _mm256_complexmul_ps(z1, dz_reg);
+            z2 = _mm256_complexmul_ps(z2, dz_reg);
+            z3 = _mm256_complexmul_ps(z3, dz_reg);
 
-            for( vec_ind = 0; vec_ind < num_a_vectors; ++vec_ind )
+            for (vec_ind = 0; vec_ind < num_a_vectors; ++vec_ind)
                 {
-                    x0Val[vec_ind] = _mm256_loadu_ps(bPtr[vec_ind]); // t0|t1|t2|t3|t4|t5|t6|t7
-                    x1Val[vec_ind] = _mm256_loadu_ps(bPtr[vec_ind]+8);
-                    x0loVal[vec_ind] = _mm256_unpacklo_ps(x0Val[vec_ind], x0Val[vec_ind]); // t0|t0|t1|t1|t4|t4|t5|t5
-                    x0hiVal[vec_ind] = _mm256_unpackhi_ps(x0Val[vec_ind], x0Val[vec_ind]); // t2|t2|t3|t3|t6|t6|t7|t7
+                    x0Val[vec_ind] = _mm256_loadu_ps(bPtr[vec_ind]);  // t0|t1|t2|t3|t4|t5|t6|t7
+                    x1Val[vec_ind] = _mm256_loadu_ps(bPtr[vec_ind] + 8);
+                    x0loVal[vec_ind] = _mm256_unpacklo_ps(x0Val[vec_ind], x0Val[vec_ind]);  // t0|t0|t1|t1|t4|t4|t5|t5
+                    x0hiVal[vec_ind] = _mm256_unpackhi_ps(x0Val[vec_ind], x0Val[vec_ind]);  // t2|t2|t3|t3|t6|t6|t7|t7
                     x1loVal[vec_ind] = _mm256_unpacklo_ps(x1Val[vec_ind], x1Val[vec_ind]);
                     x1hiVal[vec_ind] = _mm256_unpackhi_ps(x1Val[vec_ind], x1Val[vec_ind]);
 
                     // TODO: it may be possible to rearrange swizzling to better pipeline data
-                    b0Val[vec_ind] = _mm256_permute2f128_ps(x0loVal[vec_ind], x0hiVal[vec_ind], 0x20); // t0|t0|t1|t1|t2|t2|t3|t3
-                    b1Val[vec_ind] = _mm256_permute2f128_ps(x0loVal[vec_ind], x0hiVal[vec_ind], 0x31); // t4|t4|t5|t5|t6|t6|t7|t7
+                    b0Val[vec_ind] = _mm256_permute2f128_ps(x0loVal[vec_ind], x0hiVal[vec_ind], 0x20);  // t0|t0|t1|t1|t2|t2|t3|t3
+                    b1Val[vec_ind] = _mm256_permute2f128_ps(x0loVal[vec_ind], x0hiVal[vec_ind], 0x31);  // t4|t4|t5|t5|t6|t6|t7|t7
                     b2Val[vec_ind] = _mm256_permute2f128_ps(x1loVal[vec_ind], x1hiVal[vec_ind], 0x20);
                     b3Val[vec_ind] = _mm256_permute2f128_ps(x1loVal[vec_ind], x1hiVal[vec_ind], 0x31);
 
@@ -274,43 +279,44 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_u_avx(lv_32fc_
             // Force the rotators back onto the unit circle
             if ((number % 64) == 0)
                 {
-                    z0 = _mm256_complexnormalise_ps( z0 );
-                    z1 = _mm256_complexnormalise_ps( z1 );
-                    z2 = _mm256_complexnormalise_ps( z2 );
-                    z3 = _mm256_complexnormalise_ps( z3 );
+                    z0 = _mm256_complexnormalise_ps(z0);
+                    z1 = _mm256_complexnormalise_ps(z1);
+                    z2 = _mm256_complexnormalise_ps(z2);
+                    z3 = _mm256_complexnormalise_ps(z3);
                 }
 
             aPtr += 32;
         }
-    __VOLK_ATTR_ALIGNED(32) lv_32fc_t dotProductVector[4];
+    __VOLK_ATTR_ALIGNED(32)
+    lv_32fc_t dotProductVector[4];
 
-    for( vec_ind = 0; vec_ind < num_a_vectors; ++vec_ind )
+    for (vec_ind = 0; vec_ind < num_a_vectors; ++vec_ind)
         {
             dotProdVal0[vec_ind] = _mm256_add_ps(dotProdVal0[vec_ind], dotProdVal1[vec_ind]);
             dotProdVal0[vec_ind] = _mm256_add_ps(dotProdVal0[vec_ind], dotProdVal2[vec_ind]);
             dotProdVal0[vec_ind] = _mm256_add_ps(dotProdVal0[vec_ind], dotProdVal3[vec_ind]);
 
-            _mm256_store_ps((float *)dotProductVector, dotProdVal0[vec_ind]); // Store the results back into the dot product vector
+            _mm256_store_ps((float*)dotProductVector, dotProdVal0[vec_ind]);  // Store the results back into the dot product vector
 
-            result[ vec_ind ] = lv_cmake( 0, 0 );
-            for( i = 0; i < 4; ++i )
+            result[vec_ind] = lv_cmake(0, 0);
+            for (i = 0; i < 4; ++i)
                 {
                     result[vec_ind] += dotProductVector[i];
                 }
         }
 
-    z0 = _mm256_complexnormalise_ps( z0 );
+    z0 = _mm256_complexnormalise_ps(z0);
     _mm256_store_ps((float*)phase_vec, z0);
     _phase = phase_vec[0];
     _mm256_zeroupper();
 
-    number = sixteenthPoints*16;
-    for(;number < num_points; number++)
+    number = sixteenthPoints * 16;
+    for (; number < num_points; number++)
         {
-            wo = (*aPtr++)*_phase;
+            wo = (*aPtr++) * _phase;
             _phase *= phase_inc;
 
-            for( vec_ind = 0; vec_ind < num_a_vectors; ++vec_ind )
+            for (vec_ind = 0; vec_ind < num_a_vectors; ++vec_ind)
                 {
                     result[vec_ind] += wo * in_a[vec_ind][number];
                 }
@@ -333,8 +339,8 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_a_avx(lv_32fc_
     const unsigned int sixteenthPoints = num_points / 16;
 
     const float* aPtr = (float*)in_common;
-    const float* bPtr[ num_a_vectors];
-    for( vec_ind = 0; vec_ind < num_a_vectors; ++vec_ind )
+    const float* bPtr[num_a_vectors];
+    for (vec_ind = 0; vec_ind < num_a_vectors; ++vec_ind)
         {
             bPtr[vec_ind] = in_a[vec_ind];
         }
@@ -352,7 +358,7 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_a_avx(lv_32fc_
     __m256 dotProdVal2[num_a_vectors];
     __m256 dotProdVal3[num_a_vectors];
 
-    for( vec_ind = 0; vec_ind < num_a_vectors; vec_ind++ )
+    for (vec_ind = 0; vec_ind < num_a_vectors; vec_ind++)
         {
             dotProdVal0[vec_ind] = _mm256_setzero_ps();
             dotProdVal1[vec_ind] = _mm256_setzero_ps();
@@ -362,58 +368,62 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_a_avx(lv_32fc_
 
     // Set up the complex rotator
     __m256 z0, z1, z2, z3;
-    __VOLK_ATTR_ALIGNED(32) lv_32fc_t phase_vec[16];
-    for( vec_ind = 0; vec_ind < 16; ++vec_ind )
+    __VOLK_ATTR_ALIGNED(32)
+    lv_32fc_t phase_vec[16];
+    for (vec_ind = 0; vec_ind < 16; ++vec_ind)
         {
             phase_vec[vec_ind] = _phase;
             _phase *= phase_inc;
         }
 
-    z0 = _mm256_load_ps( (float *)phase_vec );
-    z1 = _mm256_load_ps( (float *)(phase_vec + 4) );
-    z2 = _mm256_load_ps( (float *)(phase_vec + 8) );
-    z3 = _mm256_load_ps( (float *)(phase_vec + 12) );
+    z0 = _mm256_load_ps((float*)phase_vec);
+    z1 = _mm256_load_ps((float*)(phase_vec + 4));
+    z2 = _mm256_load_ps((float*)(phase_vec + 8));
+    z3 = _mm256_load_ps((float*)(phase_vec + 12));
 
-    lv_32fc_t dz = phase_inc; dz *= dz; dz *= dz; dz *= dz; dz *= dz; // dz = phase_inc^16;
+    lv_32fc_t dz = phase_inc;
+    dz *= dz;
+    dz *= dz;
+    dz *= dz;
+    dz *= dz;  // dz = phase_inc^16;
 
-    for( vec_ind = 0; vec_ind < 4; ++vec_ind )
+    for (vec_ind = 0; vec_ind < 4; ++vec_ind)
         {
             phase_vec[vec_ind] = dz;
         }
 
-    __m256 dz_reg = _mm256_load_ps( (float *)phase_vec );
-    dz_reg = _mm256_complexnormalise_ps( dz_reg );
+    __m256 dz_reg = _mm256_load_ps((float*)phase_vec);
+    dz_reg = _mm256_complexnormalise_ps(dz_reg);
 
-    for(;number < sixteenthPoints; number++)
+    for (; number < sixteenthPoints; number++)
         {
-
             a0Val = _mm256_load_ps(aPtr);
-            a1Val = _mm256_load_ps(aPtr+8);
-            a2Val = _mm256_load_ps(aPtr+16);
-            a3Val = _mm256_load_ps(aPtr+24);
+            a1Val = _mm256_load_ps(aPtr + 8);
+            a2Val = _mm256_load_ps(aPtr + 16);
+            a3Val = _mm256_load_ps(aPtr + 24);
 
-            a0Val = _mm256_complexmul_ps( a0Val, z0 );
-            a1Val = _mm256_complexmul_ps( a1Val, z1 );
-            a2Val = _mm256_complexmul_ps( a2Val, z2 );
-            a3Val = _mm256_complexmul_ps( a3Val, z3 );
+            a0Val = _mm256_complexmul_ps(a0Val, z0);
+            a1Val = _mm256_complexmul_ps(a1Val, z1);
+            a2Val = _mm256_complexmul_ps(a2Val, z2);
+            a3Val = _mm256_complexmul_ps(a3Val, z3);
 
-            z0 = _mm256_complexmul_ps( z0, dz_reg );
-            z1 = _mm256_complexmul_ps( z1, dz_reg );
-            z2 = _mm256_complexmul_ps( z2, dz_reg );
-            z3 = _mm256_complexmul_ps( z3, dz_reg );
+            z0 = _mm256_complexmul_ps(z0, dz_reg);
+            z1 = _mm256_complexmul_ps(z1, dz_reg);
+            z2 = _mm256_complexmul_ps(z2, dz_reg);
+            z3 = _mm256_complexmul_ps(z3, dz_reg);
 
-            for( vec_ind = 0; vec_ind < num_a_vectors; ++vec_ind )
+            for (vec_ind = 0; vec_ind < num_a_vectors; ++vec_ind)
                 {
-                    x0Val[vec_ind] = _mm256_loadu_ps(bPtr[vec_ind]); // t0|t1|t2|t3|t4|t5|t6|t7
-                    x1Val[vec_ind] = _mm256_loadu_ps(bPtr[vec_ind]+8);
-                    x0loVal[vec_ind] = _mm256_unpacklo_ps(x0Val[vec_ind], x0Val[vec_ind]); // t0|t0|t1|t1|t4|t4|t5|t5
-                    x0hiVal[vec_ind] = _mm256_unpackhi_ps(x0Val[vec_ind], x0Val[vec_ind]); // t2|t2|t3|t3|t6|t6|t7|t7
+                    x0Val[vec_ind] = _mm256_loadu_ps(bPtr[vec_ind]);  // t0|t1|t2|t3|t4|t5|t6|t7
+                    x1Val[vec_ind] = _mm256_loadu_ps(bPtr[vec_ind] + 8);
+                    x0loVal[vec_ind] = _mm256_unpacklo_ps(x0Val[vec_ind], x0Val[vec_ind]);  // t0|t0|t1|t1|t4|t4|t5|t5
+                    x0hiVal[vec_ind] = _mm256_unpackhi_ps(x0Val[vec_ind], x0Val[vec_ind]);  // t2|t2|t3|t3|t6|t6|t7|t7
                     x1loVal[vec_ind] = _mm256_unpacklo_ps(x1Val[vec_ind], x1Val[vec_ind]);
                     x1hiVal[vec_ind] = _mm256_unpackhi_ps(x1Val[vec_ind], x1Val[vec_ind]);
 
                     // TODO: it may be possible to rearrange swizzling to better pipeline data
-                    b0Val[vec_ind] = _mm256_permute2f128_ps(x0loVal[vec_ind], x0hiVal[vec_ind], 0x20); // t0|t0|t1|t1|t2|t2|t3|t3
-                    b1Val[vec_ind] = _mm256_permute2f128_ps(x0loVal[vec_ind], x0hiVal[vec_ind], 0x31); // t4|t4|t5|t5|t6|t6|t7|t7
+                    b0Val[vec_ind] = _mm256_permute2f128_ps(x0loVal[vec_ind], x0hiVal[vec_ind], 0x20);  // t0|t0|t1|t1|t2|t2|t3|t3
+                    b1Val[vec_ind] = _mm256_permute2f128_ps(x0loVal[vec_ind], x0hiVal[vec_ind], 0x31);  // t4|t4|t5|t5|t6|t6|t7|t7
                     b2Val[vec_ind] = _mm256_permute2f128_ps(x1loVal[vec_ind], x1hiVal[vec_ind], 0x20);
                     b3Val[vec_ind] = _mm256_permute2f128_ps(x1loVal[vec_ind], x1hiVal[vec_ind], 0x31);
 
@@ -433,43 +443,44 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_a_avx(lv_32fc_
             // Force the rotators back onto the unit circle
             if ((number % 64) == 0)
                 {
-                    z0 = _mm256_complexnormalise_ps( z0 );
-                    z1 = _mm256_complexnormalise_ps( z1 );
-                    z2 = _mm256_complexnormalise_ps( z2 );
-                    z3 = _mm256_complexnormalise_ps( z3 );
+                    z0 = _mm256_complexnormalise_ps(z0);
+                    z1 = _mm256_complexnormalise_ps(z1);
+                    z2 = _mm256_complexnormalise_ps(z2);
+                    z3 = _mm256_complexnormalise_ps(z3);
                 }
 
             aPtr += 32;
         }
-    __VOLK_ATTR_ALIGNED(32) lv_32fc_t dotProductVector[4];
+    __VOLK_ATTR_ALIGNED(32)
+    lv_32fc_t dotProductVector[4];
 
-    for( vec_ind = 0; vec_ind < num_a_vectors; ++vec_ind )
+    for (vec_ind = 0; vec_ind < num_a_vectors; ++vec_ind)
         {
             dotProdVal0[vec_ind] = _mm256_add_ps(dotProdVal0[vec_ind], dotProdVal1[vec_ind]);
             dotProdVal0[vec_ind] = _mm256_add_ps(dotProdVal0[vec_ind], dotProdVal2[vec_ind]);
             dotProdVal0[vec_ind] = _mm256_add_ps(dotProdVal0[vec_ind], dotProdVal3[vec_ind]);
 
-            _mm256_store_ps((float *)dotProductVector, dotProdVal0[vec_ind]); // Store the results back into the dot product vector
+            _mm256_store_ps((float*)dotProductVector, dotProdVal0[vec_ind]);  // Store the results back into the dot product vector
 
-            result[ vec_ind ] = lv_cmake( 0, 0 );
-            for( i = 0; i < 4; ++i )
+            result[vec_ind] = lv_cmake(0, 0);
+            for (i = 0; i < 4; ++i)
                 {
                     result[vec_ind] += dotProductVector[i];
                 }
         }
 
-    z0 = _mm256_complexnormalise_ps( z0 );
+    z0 = _mm256_complexnormalise_ps(z0);
     _mm256_store_ps((float*)phase_vec, z0);
     _phase = phase_vec[0];
     _mm256_zeroupper();
 
-    number = sixteenthPoints*16;
-    for(;number < num_points; number++)
+    number = sixteenthPoints * 16;
+    for (; number < num_points; number++)
         {
-            wo = (*aPtr++)*_phase;
+            wo = (*aPtr++) * _phase;
             _phase *= phase_inc;
 
-            for( vec_ind = 0; vec_ind < num_a_vectors; ++vec_ind )
+            for (vec_ind = 0; vec_ind < num_a_vectors; ++vec_ind)
                 {
                     result[vec_ind] += wo * in_a[vec_ind][number];
                 }
@@ -482,5 +493,3 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_a_avx(lv_32fc_
 #endif /* LV_HAVE_AVX */
 
 #endif /* INCLUDED_volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_H */
-
-

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc.h

@@ -42,7 +42,7 @@
 
 #ifdef LV_HAVE_GENERIC
 
-static inline void volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc_generic(lv_32fc_t* result, const lv_32fc_t* local_code,  const float* in, unsigned int num_points)
+static inline void volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc_generic(lv_32fc_t* result, const lv_32fc_t* local_code, const float* in, unsigned int num_points)
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.25;
@@ -53,15 +53,15 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc_generic(lv
     phase_inc[0] = lv_cmake(cos(phase_step_rad), sin(phase_step_rad));
     unsigned int n;
     int num_a_vectors = 3;
-    float ** in_a = (float **)volk_gnsssdr_malloc(sizeof(float *) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    float** in_a = (float**)volk_gnsssdr_malloc(sizeof(float*) * num_a_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_a_vectors; n++)
         {
-            in_a[n] = (float *)volk_gnsssdr_malloc(sizeof(float ) * num_points, volk_gnsssdr_get_alignment());
+            in_a[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
             memcpy((float*)in_a[n], (float*)in, sizeof(float) * num_points);
         }
-    volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_generic(result, local_code, phase_inc[0], phase, (const float**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_generic(result, local_code, phase_inc[0], phase, (const float**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
@@ -71,7 +71,7 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc_generic(lv
 
 
 #ifdef LV_HAVE_GENERIC
-static inline void volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc_generic_reload(lv_32fc_t* result, const lv_32fc_t* local_code,  const float* in, unsigned int num_points)
+static inline void volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc_generic_reload(lv_32fc_t* result, const lv_32fc_t* local_code, const float* in, unsigned int num_points)
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.25;
@@ -82,15 +82,15 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc_generic_re
     phase_inc[0] = lv_cmake(cos(phase_step_rad), sin(phase_step_rad));
     unsigned int n;
     int num_a_vectors = 3;
-    float ** in_a = (float **)volk_gnsssdr_malloc(sizeof(float *) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    float** in_a = (float**)volk_gnsssdr_malloc(sizeof(float*) * num_a_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_a_vectors; n++)
         {
-            in_a[n] = (float *)volk_gnsssdr_malloc(sizeof(float ) * num_points, volk_gnsssdr_get_alignment());
+            in_a[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
             memcpy((float*)in_a[n], (float*)in, sizeof(float) * num_points);
         }
-    volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_generic_reload(result, local_code, phase_inc[0], phase, (const float**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_generic_reload(result, local_code, phase_inc[0], phase, (const float**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
@@ -100,7 +100,7 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc_generic_re
 #endif  // Generic
 
 #ifdef LV_HAVE_AVX
-static inline void volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc_u_avx(lv_32fc_t* result, const lv_32fc_t* local_code,  const float* in, unsigned int num_points)
+static inline void volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc_u_avx(lv_32fc_t* result, const lv_32fc_t* local_code, const float* in, unsigned int num_points)
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.25;
@@ -111,15 +111,15 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc_u_avx(lv_3
     phase_inc[0] = lv_cmake(cos(phase_step_rad), sin(phase_step_rad));
     unsigned int n;
     int num_a_vectors = 3;
-    float ** in_a = (float **)volk_gnsssdr_malloc(sizeof(float *) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    float** in_a = (float**)volk_gnsssdr_malloc(sizeof(float*) * num_a_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_a_vectors; n++)
         {
-            in_a[n] = (float *)volk_gnsssdr_malloc(sizeof(float ) * num_points, volk_gnsssdr_get_alignment());
+            in_a[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
             memcpy((float*)in_a[n], (float*)in, sizeof(float) * num_points);
         }
-    volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_u_avx(result, local_code, phase_inc[0], phase, (const float**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_u_avx(result, local_code, phase_inc[0], phase, (const float**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
@@ -130,7 +130,7 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc_u_avx(lv_3
 
 
 #ifdef LV_HAVE_AVX
-static inline void volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc_a_avx(lv_32fc_t* result, const lv_32fc_t* local_code,  const float* in, unsigned int num_points)
+static inline void volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc_a_avx(lv_32fc_t* result, const lv_32fc_t* local_code, const float* in, unsigned int num_points)
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.25;
@@ -141,15 +141,15 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc_a_avx(lv_3
     phase_inc[0] = lv_cmake(cos(phase_step_rad), sin(phase_step_rad));
     unsigned int n;
     int num_a_vectors = 3;
-    float ** in_a = (float **)volk_gnsssdr_malloc(sizeof(float *) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    float** in_a = (float**)volk_gnsssdr_malloc(sizeof(float*) * num_a_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_a_vectors; n++)
         {
-            in_a[n] = (float *)volk_gnsssdr_malloc(sizeof(float ) * num_points, volk_gnsssdr_get_alignment());
+            in_a[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
             memcpy((float*)in_a[n], (float*)in, sizeof(float) * num_points);
         }
-    volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_a_avx(result, local_code, phase_inc[0], phase, (const float**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_a_avx(result, local_code, phase_inc[0], phase, (const float**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
@@ -159,4 +159,3 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc_a_avx(lv_3
 #endif  // AVX
 
 #endif  // INCLUDED_volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc_H
-

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32fc_convert_16ic.h

@@ -80,10 +80,12 @@ static inline void volk_gnsssdr_32fc_convert_16ic_u_sse2(lv_16sc_t* outputVector
     const __m128 vmin_val = _mm_set_ps1(min_val);
     const __m128 vmax_val = _mm_set_ps1(max_val);
 
-    for(i = 0; i < sse_iters; i++)
+    for (i = 0; i < sse_iters; i++)
         {
-            inputVal1 = _mm_loadu_ps((float*)inputVectorPtr); inputVectorPtr += 4;
-            inputVal2 = _mm_loadu_ps((float*)inputVectorPtr); inputVectorPtr += 4;
+            inputVal1 = _mm_loadu_ps((float*)inputVectorPtr);
+            inputVectorPtr += 4;
+            inputVal2 = _mm_loadu_ps((float*)inputVectorPtr);
+            inputVectorPtr += 4;
             __VOLK_GNSSSDR_PREFETCH(inputVectorPtr + 8);
 
             // Clip
@@ -99,12 +101,12 @@ static inline void volk_gnsssdr_32fc_convert_16ic_u_sse2(lv_16sc_t* outputVector
             outputVectorPtr += 8;
         }
 
-    for(i = sse_iters * 8; i < num_points * 2; i++)
+    for (i = sse_iters * 8; i < num_points * 2; i++)
         {
             aux = *inputVectorPtr++;
-            if(aux > max_val)
+            if (aux > max_val)
                 aux = max_val;
-            else if(aux < min_val)
+            else if (aux < min_val)
                 aux = min_val;
             *outputVectorPtr++ = (int16_t)rintf(aux);
         }
@@ -128,15 +130,17 @@ static inline void volk_gnsssdr_32fc_convert_16ic_u_sse(lv_16sc_t* outputVector,
     const float max_val = (float)SHRT_MAX;
 
     __m128 inputVal1, inputVal2;
-    __m128i intInputVal1, intInputVal2; // is __m128i defined in xmmintrin.h?
+    __m128i intInputVal1, intInputVal2;  // is __m128i defined in xmmintrin.h?
     __m128 ret1, ret2;
     const __m128 vmin_val = _mm_set_ps1(min_val);
     const __m128 vmax_val = _mm_set_ps1(max_val);
 
-    for(i = 0;i < sse_iters; i++)
+    for (i = 0; i < sse_iters; i++)
         {
-            inputVal1 = _mm_loadu_ps((float*)inputVectorPtr); inputVectorPtr += 4;
-            inputVal2 = _mm_loadu_ps((float*)inputVectorPtr); inputVectorPtr += 4;
+            inputVal1 = _mm_loadu_ps((float*)inputVectorPtr);
+            inputVectorPtr += 4;
+            inputVal2 = _mm_loadu_ps((float*)inputVectorPtr);
+            inputVectorPtr += 4;
             __VOLK_GNSSSDR_PREFETCH(inputVectorPtr + 8);
 
             // Clip
@@ -152,12 +156,12 @@ static inline void volk_gnsssdr_32fc_convert_16ic_u_sse(lv_16sc_t* outputVector,
             outputVectorPtr += 8;
         }
 
-    for(i = sse_iters * 8; i < num_points*2; i++)
+    for (i = sse_iters * 8; i < num_points * 2; i++)
         {
             aux = *inputVectorPtr++;
-            if(aux > max_val)
+            if (aux > max_val)
                 aux = max_val;
-            else if(aux < min_val)
+            else if (aux < min_val)
                 aux = min_val;
             *outputVectorPtr++ = (int16_t)rintf(aux);
         }
@@ -175,7 +179,7 @@ static inline void volk_gnsssdr_32fc_convert_16ic_u_avx2(lv_16sc_t* outputVector
     int16_t* outputVectorPtr = (int16_t*)outputVector;
     float aux;
     unsigned int i;
-    const float min_val = (float)SHRT_MIN; ///todo Something off here, compiler does not perform right cast
+    const float min_val = (float)SHRT_MIN;  ///todo Something off here, compiler does not perform right cast
     const float max_val = (float)SHRT_MAX;
 
     __m256 inputVal1, inputVal2;
@@ -184,10 +188,12 @@ static inline void volk_gnsssdr_32fc_convert_16ic_u_avx2(lv_16sc_t* outputVector
     const __m256 vmin_val = _mm256_set1_ps(min_val);
     const __m256 vmax_val = _mm256_set1_ps(max_val);
 
-    for(i = 0; i < avx2_iters; i++)
+    for (i = 0; i < avx2_iters; i++)
         {
-            inputVal1 = _mm256_loadu_ps((float*)inputVectorPtr); inputVectorPtr += 8;
-            inputVal2 = _mm256_loadu_ps((float*)inputVectorPtr); inputVectorPtr += 8;
+            inputVal1 = _mm256_loadu_ps((float*)inputVectorPtr);
+            inputVectorPtr += 8;
+            inputVal2 = _mm256_loadu_ps((float*)inputVectorPtr);
+            inputVectorPtr += 8;
             __VOLK_GNSSSDR_PREFETCH(inputVectorPtr + 16);
 
             // Clip
@@ -204,12 +210,12 @@ static inline void volk_gnsssdr_32fc_convert_16ic_u_avx2(lv_16sc_t* outputVector
             outputVectorPtr += 16;
         }
 
-    for(i = avx2_iters * 16; i < num_points * 2; i++)
+    for (i = avx2_iters * 16; i < num_points * 2; i++)
         {
             aux = *inputVectorPtr++;
-            if(aux > max_val)
+            if (aux > max_val)
                 aux = max_val;
-            else if(aux < min_val)
+            else if (aux < min_val)
                 aux = min_val;
             *outputVectorPtr++ = (int16_t)rintf(aux);
         }
@@ -238,10 +244,12 @@ static inline void volk_gnsssdr_32fc_convert_16ic_a_sse2(lv_16sc_t* outputVector
     const __m128 vmin_val = _mm_set_ps1(min_val);
     const __m128 vmax_val = _mm_set_ps1(max_val);
 
-    for(i = 0; i < sse_iters; i++)
+    for (i = 0; i < sse_iters; i++)
         {
-            inputVal1 = _mm_load_ps((float*)inputVectorPtr); inputVectorPtr += 4;
-            inputVal2 = _mm_load_ps((float*)inputVectorPtr); inputVectorPtr += 4;
+            inputVal1 = _mm_load_ps((float*)inputVectorPtr);
+            inputVectorPtr += 4;
+            inputVal2 = _mm_load_ps((float*)inputVectorPtr);
+            inputVectorPtr += 4;
             __VOLK_GNSSSDR_PREFETCH(inputVectorPtr + 8);
 
             // Clip
@@ -257,12 +265,12 @@ static inline void volk_gnsssdr_32fc_convert_16ic_a_sse2(lv_16sc_t* outputVector
             outputVectorPtr += 8;
         }
 
-    for(i = sse_iters * 8; i < num_points * 2; i++)
+    for (i = sse_iters * 8; i < num_points * 2; i++)
         {
             aux = *inputVectorPtr++;
-            if(aux > max_val)
+            if (aux > max_val)
                 aux = max_val;
-            else if(aux < min_val)
+            else if (aux < min_val)
                 aux = min_val;
             *outputVectorPtr++ = (int16_t)rintf(aux);
         }
@@ -289,10 +297,12 @@ static inline void volk_gnsssdr_32fc_convert_16ic_a_sse(lv_16sc_t* outputVector,
     const __m128 vmin_val = _mm_set_ps1(min_val);
     const __m128 vmax_val = _mm_set_ps1(max_val);
 
-    for(i = 0; i < sse_iters; i++)
+    for (i = 0; i < sse_iters; i++)
         {
-            inputVal1 = _mm_load_ps((float*)inputVectorPtr); inputVectorPtr += 4;
-            inputVal2 = _mm_load_ps((float*)inputVectorPtr); inputVectorPtr += 4;
+            inputVal1 = _mm_load_ps((float*)inputVectorPtr);
+            inputVectorPtr += 4;
+            inputVal2 = _mm_load_ps((float*)inputVectorPtr);
+            inputVectorPtr += 4;
             __VOLK_GNSSSDR_PREFETCH(inputVectorPtr + 8);
 
             // Clip
@@ -308,12 +318,12 @@ static inline void volk_gnsssdr_32fc_convert_16ic_a_sse(lv_16sc_t* outputVector,
             outputVectorPtr += 8;
         }
 
-    for(i = sse_iters * 8; i < num_points * 2; i++)
+    for (i = sse_iters * 8; i < num_points * 2; i++)
         {
             aux = *inputVectorPtr++;
-            if(aux > max_val)
+            if (aux > max_val)
                 aux = max_val;
-            else if(aux < min_val)
+            else if (aux < min_val)
                 aux = min_val;
             *outputVectorPtr++ = (int16_t)rintf(aux);
         }
@@ -332,7 +342,7 @@ static inline void volk_gnsssdr_32fc_convert_16ic_a_avx2(lv_16sc_t* outputVector
     int16_t* outputVectorPtr = (int16_t*)outputVector;
     float aux;
     unsigned int i;
-    const float min_val = (float)SHRT_MIN; ///todo Something off here, compiler does not perform right cast
+    const float min_val = (float)SHRT_MIN;  ///todo Something off here, compiler does not perform right cast
     const float max_val = (float)SHRT_MAX;
 
     __m256 inputVal1, inputVal2;
@@ -341,10 +351,12 @@ static inline void volk_gnsssdr_32fc_convert_16ic_a_avx2(lv_16sc_t* outputVector
     const __m256 vmin_val = _mm256_set1_ps(min_val);
     const __m256 vmax_val = _mm256_set1_ps(max_val);
 
-    for(i = 0; i < avx2_iters; i++)
+    for (i = 0; i < avx2_iters; i++)
         {
-            inputVal1 = _mm256_load_ps((float*)inputVectorPtr); inputVectorPtr += 8;
-            inputVal2 = _mm256_load_ps((float*)inputVectorPtr); inputVectorPtr += 8;
+            inputVal1 = _mm256_load_ps((float*)inputVectorPtr);
+            inputVectorPtr += 8;
+            inputVal2 = _mm256_load_ps((float*)inputVectorPtr);
+            inputVectorPtr += 8;
             __VOLK_GNSSSDR_PREFETCH(inputVectorPtr + 16);
 
             // Clip
@@ -361,12 +373,12 @@ static inline void volk_gnsssdr_32fc_convert_16ic_a_avx2(lv_16sc_t* outputVector
             outputVectorPtr += 16;
         }
 
-    for(i = avx2_iters * 16; i < num_points * 2; i++)
+    for (i = avx2_iters * 16; i < num_points * 2; i++)
         {
             aux = *inputVectorPtr++;
-            if(aux > max_val)
+            if (aux > max_val)
                 aux = max_val;
-            else if(aux < min_val)
+            else if (aux < min_val)
                 aux = min_val;
             *outputVectorPtr++ = (int16_t)rintf(aux);
         }
@@ -397,10 +409,12 @@ static inline void volk_gnsssdr_32fc_convert_16ic_neon(lv_16sc_t* outputVector,
     int16x4_t intInputVal1, intInputVal2;
     int16x8_t res;
 
-    for(i = 0; i < neon_iters; i++)
+    for (i = 0; i < neon_iters; i++)
         {
-            a = vld1q_f32((const float32_t*)(inputVectorPtr)); inputVectorPtr += 4;
-            b = vld1q_f32((const float32_t*)(inputVectorPtr)); inputVectorPtr += 4;
+            a = vld1q_f32((const float32_t*)(inputVectorPtr));
+            inputVectorPtr += 4;
+            b = vld1q_f32((const float32_t*)(inputVectorPtr));
+            inputVectorPtr += 4;
             __VOLK_GNSSSDR_PREFETCH(inputVectorPtr + 8);
 
             ret1 = vmaxq_f32(vminq_f32(a, max_val), min_val);
@@ -425,12 +439,12 @@ static inline void volk_gnsssdr_32fc_convert_16ic_neon(lv_16sc_t* outputVector,
             outputVectorPtr += 8;
         }
 
-    for(i = neon_iters * 8; i < num_points * 2; i++)
+    for (i = neon_iters * 8; i < num_points * 2; i++)
         {
             aux = *inputVectorPtr++;
-            if(aux > max_val_f)
+            if (aux > max_val_f)
                 aux = max_val_f;
-            else if(aux < min_val_f)
+            else if (aux < min_val_f)
                 aux = min_val_f;
             *outputVectorPtr++ = (int16_t)rintf(aux);
         }
@@ -449,14 +463,14 @@ static inline void volk_gnsssdr_32fc_convert_16ic_generic(lv_16sc_t* outputVecto
     const float max_val = (float)SHRT_MAX;
     float aux;
     unsigned int i;
-    for(i = 0; i < num_points * 2; i++)
+    for (i = 0; i < num_points * 2; i++)
         {
             aux = *inputVectorPtr++;
-            if(aux > max_val)
+            if (aux > max_val)
                 aux = max_val;
-            else if(aux < min_val)
+            else if (aux < min_val)
                 aux = min_val;
-           *outputVectorPtr++ = (int16_t)rintf(aux);
+            *outputVectorPtr++ = (int16_t)rintf(aux);
         }
 }
 #endif /* LV_HAVE_GENERIC */

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32fc_convert_8ic.h

@@ -72,12 +72,12 @@ static inline void volk_gnsssdr_32fc_convert_8ic_generic(lv_8sc_t* outputVector,
     const float max_val = (float)SCHAR_MAX;
     float aux;
     unsigned int i;
-    for(i = 0; i < num_points * 2; i++)
+    for (i = 0; i < num_points * 2; i++)
         {
             aux = *inputVectorPtr++ * max_val;
-            if(aux > max_val)
+            if (aux > max_val)
                 aux = max_val;
-            else if(aux < min_val)
+            else if (aux < min_val)
                 aux = min_val;
             *outputVectorPtr++ = (int8_t)rintf(aux);
         }
@@ -107,12 +107,16 @@ static inline void volk_gnsssdr_32fc_convert_8ic_u_avx2(lv_8sc_t* outputVector,
     const __m256 vmin_val = _mm256_set1_ps(min_val);
     const __m256 vmax_val = _mm256_set1_ps(max_val);
 
-    for(i = 0; i < avx2_iters; i++)
+    for (i = 0; i < avx2_iters; i++)
         {
-            inputVal1 = _mm256_loadu_ps((float*)inputVectorPtr); inputVectorPtr += 8;
-            inputVal2 = _mm256_loadu_ps((float*)inputVectorPtr); inputVectorPtr += 8;
-            inputVal3 = _mm256_loadu_ps((float*)inputVectorPtr); inputVectorPtr += 8;
-            inputVal4 = _mm256_loadu_ps((float*)inputVectorPtr); inputVectorPtr += 8;
+            inputVal1 = _mm256_loadu_ps((float*)inputVectorPtr);
+            inputVectorPtr += 8;
+            inputVal2 = _mm256_loadu_ps((float*)inputVectorPtr);
+            inputVectorPtr += 8;
+            inputVal3 = _mm256_loadu_ps((float*)inputVectorPtr);
+            inputVectorPtr += 8;
+            inputVal4 = _mm256_loadu_ps((float*)inputVectorPtr);
+            inputVectorPtr += 8;
             __VOLK_GNSSSDR_PREFETCH(inputVectorPtr + 32);
 
             inputVal1 = _mm256_mul_ps(inputVal1, vmax_val);
@@ -142,12 +146,12 @@ static inline void volk_gnsssdr_32fc_convert_8ic_u_avx2(lv_8sc_t* outputVector,
             outputVectorPtr += 32;
         }
 
-    for(i = avx2_iters * 32; i < num_points * 2; i++)
+    for (i = avx2_iters * 32; i < num_points * 2; i++)
         {
             aux = *inputVectorPtr++ * max_val;
-            if(aux > max_val)
+            if (aux > max_val)
                 aux = max_val;
-            else if(aux < min_val)
+            else if (aux < min_val)
                 aux = min_val;
             *outputVectorPtr++ = (int8_t)rintf(aux);
         }
@@ -177,12 +181,16 @@ static inline void volk_gnsssdr_32fc_convert_8ic_a_avx2(lv_8sc_t* outputVector,
     const __m256 vmin_val = _mm256_set1_ps(min_val);
     const __m256 vmax_val = _mm256_set1_ps(max_val);
 
-    for(i = 0; i < avx2_iters; i++)
+    for (i = 0; i < avx2_iters; i++)
         {
-            inputVal1 = _mm256_load_ps((float*)inputVectorPtr); inputVectorPtr += 8;
-            inputVal2 = _mm256_load_ps((float*)inputVectorPtr); inputVectorPtr += 8;
-            inputVal3 = _mm256_load_ps((float*)inputVectorPtr); inputVectorPtr += 8;
-            inputVal4 = _mm256_load_ps((float*)inputVectorPtr); inputVectorPtr += 8;
+            inputVal1 = _mm256_load_ps((float*)inputVectorPtr);
+            inputVectorPtr += 8;
+            inputVal2 = _mm256_load_ps((float*)inputVectorPtr);
+            inputVectorPtr += 8;
+            inputVal3 = _mm256_load_ps((float*)inputVectorPtr);
+            inputVectorPtr += 8;
+            inputVal4 = _mm256_load_ps((float*)inputVectorPtr);
+            inputVectorPtr += 8;
             __VOLK_GNSSSDR_PREFETCH(inputVectorPtr + 32);
 
             inputVal1 = _mm256_mul_ps(inputVal1, vmax_val);
@@ -212,12 +220,12 @@ static inline void volk_gnsssdr_32fc_convert_8ic_a_avx2(lv_8sc_t* outputVector,
             outputVectorPtr += 32;
         }
 
-    for(i = avx2_iters * 32; i < num_points * 2; i++)
+    for (i = avx2_iters * 32; i < num_points * 2; i++)
         {
             aux = *inputVectorPtr++ * max_val;
-            if(aux > max_val)
+            if (aux > max_val)
                 aux = max_val;
-            else if(aux < min_val)
+            else if (aux < min_val)
                 aux = min_val;
             *outputVectorPtr++ = (int8_t)rintf(aux);
         }
@@ -247,12 +255,16 @@ static inline void volk_gnsssdr_32fc_convert_8ic_u_sse2(lv_8sc_t* outputVector,
     const __m128 vmin_val = _mm_set_ps1(min_val);
     const __m128 vmax_val = _mm_set_ps1(max_val);
 
-    for(i = 0; i < sse_iters; i++)
+    for (i = 0; i < sse_iters; i++)
         {
-            inputVal1 = _mm_loadu_ps((float*)inputVectorPtr); inputVectorPtr += 4;
-            inputVal2 = _mm_loadu_ps((float*)inputVectorPtr); inputVectorPtr += 4;
-            inputVal3 = _mm_loadu_ps((float*)inputVectorPtr); inputVectorPtr += 4;
-            inputVal4 = _mm_loadu_ps((float*)inputVectorPtr); inputVectorPtr += 4;
+            inputVal1 = _mm_loadu_ps((float*)inputVectorPtr);
+            inputVectorPtr += 4;
+            inputVal2 = _mm_loadu_ps((float*)inputVectorPtr);
+            inputVectorPtr += 4;
+            inputVal3 = _mm_loadu_ps((float*)inputVectorPtr);
+            inputVectorPtr += 4;
+            inputVal4 = _mm_loadu_ps((float*)inputVectorPtr);
+            inputVectorPtr += 4;
 
             inputVal1 = _mm_mul_ps(inputVal1, vmax_val);
             inputVal2 = _mm_mul_ps(inputVal2, vmax_val);
@@ -278,12 +290,12 @@ static inline void volk_gnsssdr_32fc_convert_8ic_u_sse2(lv_8sc_t* outputVector,
             outputVectorPtr += 16;
         }
 
-    for(i = sse_iters * 16; i < num_points * 2; i++)
+    for (i = sse_iters * 16; i < num_points * 2; i++)
         {
             aux = *inputVectorPtr++ * max_val;
-            if(aux > max_val)
+            if (aux > max_val)
                 aux = max_val;
-            else if(aux < min_val)
+            else if (aux < min_val)
                 aux = min_val;
             *outputVectorPtr++ = (int8_t)rintf(aux);
         }
@@ -313,12 +325,16 @@ static inline void volk_gnsssdr_32fc_convert_8ic_a_sse2(lv_8sc_t* outputVector,
     const __m128 vmin_val = _mm_set_ps1(min_val);
     const __m128 vmax_val = _mm_set_ps1(max_val);
 
-    for(i = 0; i < sse_iters; i++)
+    for (i = 0; i < sse_iters; i++)
         {
-            inputVal1 = _mm_load_ps((float*)inputVectorPtr); inputVectorPtr += 4;
-            inputVal2 = _mm_load_ps((float*)inputVectorPtr); inputVectorPtr += 4;
-            inputVal3 = _mm_load_ps((float*)inputVectorPtr); inputVectorPtr += 4;
-            inputVal4 = _mm_load_ps((float*)inputVectorPtr); inputVectorPtr += 4;
+            inputVal1 = _mm_load_ps((float*)inputVectorPtr);
+            inputVectorPtr += 4;
+            inputVal2 = _mm_load_ps((float*)inputVectorPtr);
+            inputVectorPtr += 4;
+            inputVal3 = _mm_load_ps((float*)inputVectorPtr);
+            inputVectorPtr += 4;
+            inputVal4 = _mm_load_ps((float*)inputVectorPtr);
+            inputVectorPtr += 4;
 
             inputVal1 = _mm_mul_ps(inputVal1, vmax_val);
             inputVal2 = _mm_mul_ps(inputVal2, vmax_val);
@@ -344,12 +360,12 @@ static inline void volk_gnsssdr_32fc_convert_8ic_a_sse2(lv_8sc_t* outputVector,
             outputVectorPtr += 16;
         }
 
-    for(i = sse_iters * 16; i < num_points * 2; i++)
+    for (i = sse_iters * 16; i < num_points * 2; i++)
         {
             aux = *inputVectorPtr++ * max_val;
-            if(aux > max_val)
+            if (aux > max_val)
                 aux = max_val;
-            else if(aux < min_val)
+            else if (aux < min_val)
                 aux = min_val;
             *outputVectorPtr++ = (int8_t)rintf(aux);
         }
@@ -383,9 +399,10 @@ static inline void volk_gnsssdr_32fc_convert_8ic_neon(lv_8sc_t* outputVector, co
     int8x8_t res8_1, res8_2;
     int8x16_t outputVal;
 
-    for(i = 0; i < neon_iters; i++)
+    for (i = 0; i < neon_iters; i++)
         {
-            a = vld1q_f32((const float32_t*)inputVectorPtr); inputVectorPtr += 4;
+            a = vld1q_f32((const float32_t*)inputVectorPtr);
+            inputVectorPtr += 4;
             a = vmulq_f32(a, max_val);
             ret1 = vmaxq_f32(vminq_f32(a, max_val), min_val);
             sign = vcvtq_f32_u32((vshrq_n_u32(vreinterpretq_u32_f32(ret1), 31)));
@@ -394,7 +411,8 @@ static inline void volk_gnsssdr_32fc_convert_8ic_neon(lv_8sc_t* outputVector, co
             toint_a = vcvtq_s32_f32(Round);
             intInputVal1 = vqmovn_s32(toint_a);
 
-            a = vld1q_f32((const float32_t*)inputVectorPtr); inputVectorPtr += 4;
+            a = vld1q_f32((const float32_t*)inputVectorPtr);
+            inputVectorPtr += 4;
             a = vmulq_f32(a, max_val);
             ret1 = vmaxq_f32(vminq_f32(a, max_val), min_val);
             sign = vcvtq_f32_u32((vshrq_n_u32(vreinterpretq_u32_f32(ret1), 31)));
@@ -406,7 +424,8 @@ static inline void volk_gnsssdr_32fc_convert_8ic_neon(lv_8sc_t* outputVector, co
             pack16_8_1 = vcombine_s16(intInputVal1, intInputVal2);
             res8_1 = vqmovn_s16(pack16_8_1);
 
-            a = vld1q_f32((const float32_t*)inputVectorPtr); inputVectorPtr += 4;
+            a = vld1q_f32((const float32_t*)inputVectorPtr);
+            inputVectorPtr += 4;
             a = vmulq_f32(a, max_val);
             ret1 = vmaxq_f32(vminq_f32(a, max_val), min_val);
             sign = vcvtq_f32_u32((vshrq_n_u32(vreinterpretq_u32_f32(ret1), 31)));
@@ -415,7 +434,8 @@ static inline void volk_gnsssdr_32fc_convert_8ic_neon(lv_8sc_t* outputVector, co
             toint_a = vcvtq_s32_f32(Round);
             intInputVal1 = vqmovn_s32(toint_a);
 
-            a = vld1q_f32((const float32_t*)inputVectorPtr); inputVectorPtr += 4;
+            a = vld1q_f32((const float32_t*)inputVectorPtr);
+            inputVectorPtr += 4;
             a = vmulq_f32(a, max_val);
             ret1 = vmaxq_f32(vminq_f32(a, max_val), min_val);
             sign = vcvtq_f32_u32((vshrq_n_u32(vreinterpretq_u32_f32(ret1), 31)));
@@ -433,12 +453,12 @@ static inline void volk_gnsssdr_32fc_convert_8ic_neon(lv_8sc_t* outputVector, co
             outputVectorPtr += 16;
         }
 
-    for(i = neon_iters * 16; i < num_points * 2; i++)
+    for (i = neon_iters * 16; i < num_points * 2; i++)
         {
             aux = *inputVectorPtr++ * max_val_f;
-            if(aux > max_val_f)
+            if (aux > max_val_f)
                 aux = max_val_f;
-            else if(aux < min_val_f)
+            else if (aux < min_val_f)
                 aux = min_val_f;
             *outputVectorPtr++ = (int8_t)rintf(aux);
         }

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32fc_resamplerxnpuppet_32fc.h

@@ -42,31 +42,30 @@
 #include <string.h>
 
 
-
 #ifdef LV_HAVE_GENERIC
 static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_generic(lv_32fc_t* result, const lv_32fc_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1  };
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
 
-    lv_32fc_t** result_aux =  (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    lv_32fc_t** result_aux = (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_32fc_xn_resampler_32fc_xn_generic(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((lv_32fc_t*)result, (lv_32fc_t*)result_aux[0], sizeof(lv_32fc_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -78,26 +77,26 @@ static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_generic(lv_32fc_t* r
 static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_a_sse3(lv_32fc_t* result, const lv_32fc_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
 
-    lv_32fc_t** result_aux =  (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    lv_32fc_t** result_aux = (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_sse3(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((lv_32fc_t*)result, (lv_32fc_t*)result_aux[0], sizeof(lv_32fc_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -107,26 +106,26 @@ static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_a_sse3(lv_32fc_t* re
 static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_u_sse3(lv_32fc_t* result, const lv_32fc_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
 
-    lv_32fc_t** result_aux =  (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    lv_32fc_t** result_aux = (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_32fc_xn_resampler_32fc_xn_u_sse3(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((lv_32fc_t*)result, (lv_32fc_t*)result_aux[0], sizeof(lv_32fc_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -137,26 +136,26 @@ static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_u_sse3(lv_32fc_t* re
 static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_u_sse4_1(lv_32fc_t* result, const lv_32fc_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
 
-    lv_32fc_t** result_aux =  (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    lv_32fc_t** result_aux = (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_32fc_xn_resampler_32fc_xn_u_sse4_1(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((lv_32fc_t*)result, (lv_32fc_t*)result_aux[0], sizeof(lv_32fc_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -166,26 +165,26 @@ static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_u_sse4_1(lv_32fc_t*
 static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_a_sse4_1(lv_32fc_t* result, const lv_32fc_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
 
-    lv_32fc_t** result_aux =  (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    lv_32fc_t** result_aux = (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_sse4_1(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((lv_32fc_t*)result, (lv_32fc_t*)result_aux[0], sizeof(lv_32fc_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 
@@ -195,26 +194,26 @@ static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_a_sse4_1(lv_32fc_t*
 static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_a_avx(lv_32fc_t* result, const lv_32fc_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
 
-    lv_32fc_t** result_aux =  (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    lv_32fc_t** result_aux = (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_avx(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((lv_32fc_t*)result, (lv_32fc_t*)result_aux[0], sizeof(lv_32fc_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 #endif
@@ -224,26 +223,26 @@ static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_a_avx(lv_32fc_t* res
 static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_u_avx(lv_32fc_t* result, const lv_32fc_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
 
-    lv_32fc_t** result_aux =  (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    lv_32fc_t** result_aux = (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_32fc_xn_resampler_32fc_xn_u_avx(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((lv_32fc_t*)result, (lv_32fc_t*)result_aux[0], sizeof(lv_32fc_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 #endif
@@ -253,26 +252,26 @@ static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_u_avx(lv_32fc_t* res
 static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_a_avx2(lv_32fc_t* result, const lv_32fc_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
 
-    lv_32fc_t** result_aux =  (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    lv_32fc_t** result_aux = (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_avx2(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((lv_32fc_t*)result, (lv_32fc_t*)result_aux[0], sizeof(lv_32fc_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 #endif
@@ -282,26 +281,26 @@ static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_a_avx2(lv_32fc_t* re
 static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_u_avx2(lv_32fc_t* result, const lv_32fc_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
 
-    lv_32fc_t** result_aux =  (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    lv_32fc_t** result_aux = (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_32fc_xn_resampler_32fc_xn_u_avx2(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((lv_32fc_t*)result, (lv_32fc_t*)result_aux[0], sizeof(lv_32fc_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 #endif
@@ -311,28 +310,28 @@ static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_u_avx2(lv_32fc_t* re
 static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_neon(lv_32fc_t* result, const lv_32fc_t* local_code, unsigned int num_points)
 {
     int code_length_chips = 2046;
-    float code_phase_step_chips = ((float)(code_length_chips) + 0.1 )/( (float) num_points );
+    float code_phase_step_chips = ((float)(code_length_chips) + 0.1) / ((float)num_points);
     int num_out_vectors = 3;
     float rem_code_phase_chips = -0.234;
     unsigned int n;
-    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+    float shifts_chips[3] = {-0.1, 0.0, 0.1};
 
-    lv_32fc_t** result_aux =  (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_out_vectors; n++)
-    {
-       result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
-    }
+    lv_32fc_t** result_aux = (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
+        }
 
     volk_gnsssdr_32fc_xn_resampler_32fc_xn_neon(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
 
     memcpy((lv_32fc_t*)result, (lv_32fc_t*)result_aux[0], sizeof(lv_32fc_t) * num_points);
 
-    for(n = 0; n < num_out_vectors; n++)
-    {
-        volk_gnsssdr_free(result_aux[n]);
-    }
+    for (n = 0; n < num_out_vectors; n++)
+        {
+            volk_gnsssdr_free(result_aux[n]);
+        }
     volk_gnsssdr_free(result_aux);
 }
 #endif
 
-#endif // INCLUDED_volk_gnsssdr_32fc_resamplerpuppet_32fc_H
+#endif  // INCLUDED_volk_gnsssdr_32fc_resamplerpuppet_32fc_H

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn.h

@@ -85,11 +85,11 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_generic(lv_32fc
     unsigned int n;
     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
         {
-            result[n_vec] = lv_cmake(0,0);
+            result[n_vec] = lv_cmake(0, 0);
         }
     for (n = 0; n < num_points; n++)
         {
-            tmp32_1 = *in_common++ * (*phase);//if(n<10 || n >= 8108) printf("generic phase %i: %f,%f\n", n,lv_creal(*phase),lv_cimag(*phase));
+            tmp32_1 = *in_common++ * (*phase);  //if(n<10 || n >= 8108) printf("generic phase %i: %f,%f\n", n,lv_creal(*phase),lv_cimag(*phase));
 
             // Regenerate phase
             if (n % 256 == 0)
@@ -126,7 +126,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_generic_reload(
     unsigned int j;
     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
         {
-            result[n_vec] = lv_cmake(0,0);
+            result[n_vec] = lv_cmake(0, 0);
         }
 
     for (n = 0; n < num_points / ROTATOR_RELOAD; n++)
@@ -141,7 +141,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_generic_reload(
                             result[n_vec] += tmp32_2;
                         }
                 }
-            /* Regenerate phase */
+                /* Regenerate phase */
 #ifdef __cplusplus
             (*phase) /= std::abs((*phase));
 #else
@@ -169,7 +169,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_generic_reload(
 #include <pmmintrin.h>
 static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_sse3(lv_32fc_t* result, const lv_32fc_t* in_common, const lv_32fc_t phase_inc, lv_32fc_t* phase, const lv_32fc_t** in_a, int num_a_vectors, unsigned int num_points)
 {
-    lv_32fc_t dotProduct = lv_cmake(0,0);
+    lv_32fc_t dotProduct = lv_cmake(0, 0);
     lv_32fc_t tmp32_1, tmp32_2;
     const unsigned int sse_iters = num_points / 2;
     int n_vec;
@@ -179,7 +179,8 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_sse3(lv_32fc_
     const lv_32fc_t** _in_a = in_a;
     const lv_32fc_t* _in_common = in_common;
 
-    __VOLK_ATTR_ALIGNED(16) lv_32fc_t dotProductVector[2];
+    __VOLK_ATTR_ALIGNED(16)
+    lv_32fc_t dotProductVector[2];
 
     __m128* acc = (__m128*)volk_gnsssdr_malloc(num_a_vectors * sizeof(__m128), volk_gnsssdr_get_alignment());
 
@@ -191,11 +192,13 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_sse3(lv_32fc_
     // phase rotation registers
     __m128 a, two_phase_acc_reg, two_phase_inc_reg, yl, yh, tmp1, tmp1p, tmp2, tmp2p, z1;
 
-    __VOLK_ATTR_ALIGNED(16) lv_32fc_t two_phase_inc[2];
+    __VOLK_ATTR_ALIGNED(16)
+    lv_32fc_t two_phase_inc[2];
     two_phase_inc[0] = phase_inc * phase_inc;
     two_phase_inc[1] = phase_inc * phase_inc;
-    two_phase_inc_reg = _mm_load_ps((float*) two_phase_inc);
-    __VOLK_ATTR_ALIGNED(16) lv_32fc_t two_phase_acc[2];
+    two_phase_inc_reg = _mm_load_ps((float*)two_phase_inc);
+    __VOLK_ATTR_ALIGNED(16)
+    lv_32fc_t two_phase_acc[2];
     two_phase_acc[0] = (*phase);
     two_phase_acc[1] = (*phase) * phase_inc;
     two_phase_acc_reg = _mm_load_ps((float*)two_phase_acc);
@@ -203,12 +206,12 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_sse3(lv_32fc_
     const __m128 ylp = _mm_moveldup_ps(two_phase_inc_reg);
     const __m128 yhp = _mm_movehdup_ps(two_phase_inc_reg);
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             // Phase rotation on operand in_common starts here:
             a = _mm_loadu_ps((float*)_in_common);
-           // __VOLK_GNSSSDR_PREFETCH(_in_common + 4);
-            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
+            // __VOLK_GNSSSDR_PREFETCH(_in_common + 4);
+            yl = _mm_moveldup_ps(two_phase_acc_reg);  // Load yl with cr,cr,dr,dr
             yh = _mm_movehdup_ps(two_phase_acc_reg);
             tmp1 = _mm_mul_ps(a, yl);
             tmp1p = _mm_mul_ps(two_phase_acc_reg, ylp);
@@ -219,7 +222,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_sse3(lv_32fc_
             z1 = _mm_addsub_ps(tmp1, tmp2);
             two_phase_acc_reg = _mm_addsub_ps(tmp1p, tmp2p);
 
-            yl = _mm_moveldup_ps(z1); // Load yl with cr,cr,dr,dr
+            yl = _mm_moveldup_ps(z1);  // Load yl with cr,cr,dr,dr
             yh = _mm_movehdup_ps(z1);
 
             //next two samples
@@ -227,7 +230,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_sse3(lv_32fc_
 
             for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
                 {
-                    a = _mm_loadu_ps((float*)&(_in_a[n_vec][number*2]));
+                    a = _mm_loadu_ps((float*)&(_in_a[n_vec][number * 2]));
                     tmp1 = _mm_mul_ps(a, yl);
                     a = _mm_shuffle_ps(a, a, 0xB1);
                     tmp2 = _mm_mul_ps(a, yh);
@@ -247,8 +250,8 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_sse3(lv_32fc_
 
     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
         {
-            _mm_store_ps((float*)dotProductVector, acc[n_vec]); // Store the results back into the dot product vector
-            dotProduct = lv_cmake(0,0);
+            _mm_store_ps((float*)dotProductVector, acc[n_vec]);  // Store the results back into the dot product vector
+            dotProduct = lv_cmake(0, 0);
             for (i = 0; i < 2; ++i)
                 {
                     dotProduct = dotProduct + dotProductVector[i];
@@ -260,7 +263,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_sse3(lv_32fc_
     _mm_store_ps((float*)two_phase_acc, two_phase_acc_reg);
     (*phase) = two_phase_acc[0];
 
-    for(n = sse_iters * 2; n < num_points; n++)
+    for (n = sse_iters * 2; n < num_points; n++)
         {
             tmp32_1 = in_common[n] * (*phase);
             (*phase) *= phase_inc;
@@ -278,7 +281,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_sse3(lv_32fc_
 #include <pmmintrin.h>
 static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_sse3(lv_32fc_t* result, const lv_32fc_t* in_common, const lv_32fc_t phase_inc, lv_32fc_t* phase, const lv_32fc_t** in_a, int num_a_vectors, unsigned int num_points)
 {
-    lv_32fc_t dotProduct = lv_cmake(0,0);
+    lv_32fc_t dotProduct = lv_cmake(0, 0);
     lv_32fc_t tmp32_1, tmp32_2;
     const unsigned int sse_iters = num_points / 2;
     int n_vec;
@@ -288,7 +291,8 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_sse3(lv_32fc_
     const lv_32fc_t** _in_a = in_a;
     const lv_32fc_t* _in_common = in_common;
 
-    __VOLK_ATTR_ALIGNED(16) lv_32fc_t dotProductVector[2];
+    __VOLK_ATTR_ALIGNED(16)
+    lv_32fc_t dotProductVector[2];
 
     __m128* acc = (__m128*)volk_gnsssdr_malloc(num_a_vectors * sizeof(__m128), volk_gnsssdr_get_alignment());
 
@@ -300,11 +304,13 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_sse3(lv_32fc_
     // phase rotation registers
     __m128 a, two_phase_acc_reg, two_phase_inc_reg, yl, yh, tmp1, tmp1p, tmp2, tmp2p, z1;
 
-    __VOLK_ATTR_ALIGNED(16) lv_32fc_t two_phase_inc[2];
+    __VOLK_ATTR_ALIGNED(16)
+    lv_32fc_t two_phase_inc[2];
     two_phase_inc[0] = phase_inc * phase_inc;
     two_phase_inc[1] = phase_inc * phase_inc;
-    two_phase_inc_reg = _mm_load_ps((float*) two_phase_inc);
-    __VOLK_ATTR_ALIGNED(16) lv_32fc_t two_phase_acc[2];
+    two_phase_inc_reg = _mm_load_ps((float*)two_phase_inc);
+    __VOLK_ATTR_ALIGNED(16)
+    lv_32fc_t two_phase_acc[2];
     two_phase_acc[0] = (*phase);
     two_phase_acc[1] = (*phase) * phase_inc;
     two_phase_acc_reg = _mm_load_ps((float*)two_phase_acc);
@@ -312,12 +318,12 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_sse3(lv_32fc_
     const __m128 ylp = _mm_moveldup_ps(two_phase_inc_reg);
     const __m128 yhp = _mm_movehdup_ps(two_phase_inc_reg);
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             // Phase rotation on operand in_common starts here:
             a = _mm_load_ps((float*)_in_common);
-           // __VOLK_GNSSSDR_PREFETCH(_in_common + 4);
-            yl = _mm_moveldup_ps(two_phase_acc_reg); // Load yl with cr,cr,dr,dr
+            // __VOLK_GNSSSDR_PREFETCH(_in_common + 4);
+            yl = _mm_moveldup_ps(two_phase_acc_reg);  // Load yl with cr,cr,dr,dr
             yh = _mm_movehdup_ps(two_phase_acc_reg);
             tmp1 = _mm_mul_ps(a, yl);
             tmp1p = _mm_mul_ps(two_phase_acc_reg, ylp);
@@ -328,7 +334,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_sse3(lv_32fc_
             z1 = _mm_addsub_ps(tmp1, tmp2);
             two_phase_acc_reg = _mm_addsub_ps(tmp1p, tmp2p);
 
-            yl = _mm_moveldup_ps(z1); // Load yl with cr,cr,dr,dr
+            yl = _mm_moveldup_ps(z1);  // Load yl with cr,cr,dr,dr
             yh = _mm_movehdup_ps(z1);
 
             //next two samples
@@ -336,7 +342,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_sse3(lv_32fc_
 
             for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
                 {
-                    a = _mm_load_ps((float*)&(_in_a[n_vec][number*2]));
+                    a = _mm_load_ps((float*)&(_in_a[n_vec][number * 2]));
                     tmp1 = _mm_mul_ps(a, yl);
                     a = _mm_shuffle_ps(a, a, 0xB1);
                     tmp2 = _mm_mul_ps(a, yh);
@@ -356,8 +362,8 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_sse3(lv_32fc_
 
     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
         {
-            _mm_store_ps((float*)dotProductVector, acc[n_vec]); // Store the results back into the dot product vector
-            dotProduct = lv_cmake(0,0);
+            _mm_store_ps((float*)dotProductVector, acc[n_vec]);  // Store the results back into the dot product vector
+            dotProduct = lv_cmake(0, 0);
             for (i = 0; i < 2; ++i)
                 {
                     dotProduct = dotProduct + dotProductVector[i];
@@ -369,7 +375,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_sse3(lv_32fc_
     _mm_store_ps((float*)two_phase_acc, two_phase_acc_reg);
     (*phase) = two_phase_acc[0];
 
-    for(n = sse_iters * 2; n < num_points; n++)
+    for (n = sse_iters * 2; n < num_points; n++)
         {
             tmp32_1 = in_common[n] * (*phase);
             (*phase) *= phase_inc;
@@ -387,7 +393,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_sse3(lv_32fc_
 #include <immintrin.h>
 static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_avx(lv_32fc_t* result, const lv_32fc_t* in_common, const lv_32fc_t phase_inc, lv_32fc_t* phase, const lv_32fc_t** in_a, int num_a_vectors, unsigned int num_points)
 {
-    lv_32fc_t dotProduct = lv_cmake(0,0);
+    lv_32fc_t dotProduct = lv_cmake(0, 0);
     lv_32fc_t tmp32_1, tmp32_2;
     const unsigned int avx_iters = num_points / 4;
     int n_vec;
@@ -398,7 +404,8 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_avx(lv_32fc_t
     const lv_32fc_t* _in_common = in_common;
     lv_32fc_t _phase = (*phase);
 
-    __VOLK_ATTR_ALIGNED(32) lv_32fc_t dotProductVector[4];
+    __VOLK_ATTR_ALIGNED(32)
+    lv_32fc_t dotProductVector[4];
 
     __m256* acc = (__m256*)volk_gnsssdr_malloc(num_a_vectors * sizeof(__m256), volk_gnsssdr_get_alignment());
 
@@ -431,12 +438,12 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_avx(lv_32fc_t
     const __m256 ylp = _mm256_moveldup_ps(four_phase_inc_reg);
     const __m256 yhp = _mm256_movehdup_ps(four_phase_inc_reg);
 
-    for(number = 0; number < avx_iters; number++)
+    for (number = 0; number < avx_iters; number++)
         {
             // Phase rotation on operand in_common starts here:
             a = _mm256_loadu_ps((float*)_in_common);
             __VOLK_GNSSSDR_PREFETCH(_in_common + 16);
-            yl = _mm256_moveldup_ps(four_phase_acc_reg); // Load yl with cr,cr,dr,dr
+            yl = _mm256_moveldup_ps(four_phase_acc_reg);  // Load yl with cr,cr,dr,dr
             yh = _mm256_movehdup_ps(four_phase_acc_reg);
             tmp1 = _mm256_mul_ps(a, yl);
             tmp1p = _mm256_mul_ps(four_phase_acc_reg, ylp);
@@ -447,7 +454,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_avx(lv_32fc_t
             z = _mm256_addsub_ps(tmp1, tmp2);
             four_phase_acc_reg = _mm256_addsub_ps(tmp1p, tmp2p);
 
-            yl = _mm256_moveldup_ps(z); // Load yl with cr,cr,dr,dr
+            yl = _mm256_moveldup_ps(z);  // Load yl with cr,cr,dr,dr
             yh = _mm256_movehdup_ps(z);
 
             //next two samples
@@ -475,8 +482,8 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_avx(lv_32fc_t
 
     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
         {
-            _mm256_store_ps((float*)dotProductVector, acc[n_vec]); // Store the results back into the dot product vector
-            dotProduct = lv_cmake(0,0);
+            _mm256_store_ps((float*)dotProductVector, acc[n_vec]);  // Store the results back into the dot product vector
+            dotProduct = lv_cmake(0, 0);
             for (i = 0; i < 4; ++i)
                 {
                     dotProduct = dotProduct + dotProductVector[i];
@@ -492,10 +499,10 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_avx(lv_32fc_t
     four_phase_acc_reg = _mm256_div_ps(four_phase_acc_reg, tmp2);
 
     _mm256_store_ps((float*)four_phase_acc, four_phase_acc_reg);
-    _phase  = four_phase_acc[0];
+    _phase = four_phase_acc[0];
     _mm256_zeroupper();
 
-    for(n = avx_iters * 4; n < num_points; n++)
+    for (n = avx_iters * 4; n < num_points; n++)
         {
             tmp32_1 = *_in_common++ * _phase;
             _phase *= phase_inc;
@@ -514,7 +521,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_avx(lv_32fc_t
 #include <immintrin.h>
 static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_avx(lv_32fc_t* result, const lv_32fc_t* in_common, const lv_32fc_t phase_inc, lv_32fc_t* phase, const lv_32fc_t** in_a, int num_a_vectors, unsigned int num_points)
 {
-    lv_32fc_t dotProduct = lv_cmake(0,0);
+    lv_32fc_t dotProduct = lv_cmake(0, 0);
     lv_32fc_t tmp32_1, tmp32_2;
     const unsigned int avx_iters = num_points / 4;
     int n_vec;
@@ -525,7 +532,8 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_avx(lv_32fc_t
     const lv_32fc_t* _in_common = in_common;
     lv_32fc_t _phase = (*phase);
 
-    __VOLK_ATTR_ALIGNED(32) lv_32fc_t dotProductVector[4];
+    __VOLK_ATTR_ALIGNED(32)
+    lv_32fc_t dotProductVector[4];
 
     __m256* acc = (__m256*)volk_gnsssdr_malloc(num_a_vectors * sizeof(__m256), volk_gnsssdr_get_alignment());
 
@@ -538,7 +546,8 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_avx(lv_32fc_t
     // phase rotation registers
     __m256 a, four_phase_acc_reg, yl, yh, tmp1, tmp1p, tmp2, tmp2p, z;
 
-    __VOLK_ATTR_ALIGNED(32) lv_32fc_t four_phase_inc[4];
+    __VOLK_ATTR_ALIGNED(32)
+    lv_32fc_t four_phase_inc[4];
     const lv_32fc_t phase_inc2 = phase_inc * phase_inc;
     const lv_32fc_t phase_inc3 = phase_inc2 * phase_inc;
     const lv_32fc_t phase_inc4 = phase_inc3 * phase_inc;
@@ -548,7 +557,8 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_avx(lv_32fc_t
     four_phase_inc[3] = phase_inc4;
     const __m256 four_phase_inc_reg = _mm256_load_ps((float*)four_phase_inc);
 
-    __VOLK_ATTR_ALIGNED(32) lv_32fc_t four_phase_acc[4];
+    __VOLK_ATTR_ALIGNED(32)
+    lv_32fc_t four_phase_acc[4];
     four_phase_acc[0] = _phase;
     four_phase_acc[1] = _phase * phase_inc;
     four_phase_acc[2] = _phase * phase_inc2;
@@ -558,12 +568,12 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_avx(lv_32fc_t
     const __m256 ylp = _mm256_moveldup_ps(four_phase_inc_reg);
     const __m256 yhp = _mm256_movehdup_ps(four_phase_inc_reg);
 
-    for(number = 0; number < avx_iters; number++)
+    for (number = 0; number < avx_iters; number++)
         {
             // Phase rotation on operand in_common starts here:
             a = _mm256_load_ps((float*)_in_common);
             __VOLK_GNSSSDR_PREFETCH(_in_common + 16);
-            yl = _mm256_moveldup_ps(four_phase_acc_reg); // Load yl with cr,cr,dr,dr
+            yl = _mm256_moveldup_ps(four_phase_acc_reg);  // Load yl with cr,cr,dr,dr
             yh = _mm256_movehdup_ps(four_phase_acc_reg);
             tmp1 = _mm256_mul_ps(a, yl);
             tmp1p = _mm256_mul_ps(four_phase_acc_reg, ylp);
@@ -574,7 +584,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_avx(lv_32fc_t
             z = _mm256_addsub_ps(tmp1, tmp2);
             four_phase_acc_reg = _mm256_addsub_ps(tmp1p, tmp2p);
 
-            yl = _mm256_moveldup_ps(z); // Load yl with cr,cr,dr,dr
+            yl = _mm256_moveldup_ps(z);  // Load yl with cr,cr,dr,dr
             yh = _mm256_movehdup_ps(z);
 
             //next two samples
@@ -602,8 +612,8 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_avx(lv_32fc_t
 
     for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
         {
-            _mm256_store_ps((float*)dotProductVector, acc[n_vec]); // Store the results back into the dot product vector
-            dotProduct = lv_cmake(0,0);
+            _mm256_store_ps((float*)dotProductVector, acc[n_vec]);  // Store the results back into the dot product vector
+            dotProduct = lv_cmake(0, 0);
             for (i = 0; i < 4; ++i)
                 {
                     dotProduct = dotProduct + dotProductVector[i];
@@ -619,10 +629,10 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_avx(lv_32fc_t
     four_phase_acc_reg = _mm256_div_ps(four_phase_acc_reg, tmp2);
 
     _mm256_store_ps((float*)four_phase_acc, four_phase_acc_reg);
-    _phase  = four_phase_acc[0];
+    _phase = four_phase_acc[0];
     _mm256_zeroupper();
 
-    for(n = avx_iters * 4; n < num_points; n++)
+    for (n = avx_iters * 4; n < num_points; n++)
         {
             tmp32_1 = *_in_common++ * _phase;
             _phase *= phase_inc;
@@ -646,7 +656,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_neon(lv_32fc_t*
     int n_vec;
     int i;
     unsigned int number;
-    unsigned int n ;
+    unsigned int n;
     const lv_32fc_t** _in_a = in_a;
     const lv_32fc_t* _in_common = in_common;
     lv_32fc_t* _out = result;
@@ -656,36 +666,41 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_neon(lv_32fc_t*
 
     if (neon_iters > 0)
         {
-            lv_32fc_t dotProduct = lv_cmake(0,0);
+            lv_32fc_t dotProduct = lv_cmake(0, 0);
             float32_t arg_phase0 = cargf(_phase);
             float32_t arg_phase_inc = cargf(phase_inc);
             float32_t phase_est;
 
             lv_32fc_t ___phase4 = phase_inc * phase_inc * phase_inc * phase_inc;
-            __VOLK_ATTR_ALIGNED(16) float32_t __phase4_real[4] = { lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4) };
-            __VOLK_ATTR_ALIGNED(16) float32_t __phase4_imag[4] = { lv_cimag(___phase4), lv_cimag(___phase4), lv_cimag(___phase4), lv_cimag(___phase4) };
+            __VOLK_ATTR_ALIGNED(16)
+            float32_t __phase4_real[4] = {lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4), lv_creal(___phase4)};
+            __VOLK_ATTR_ALIGNED(16)
+            float32_t __phase4_imag[4] = {lv_cimag(___phase4), lv_cimag(___phase4), lv_cimag(___phase4), lv_cimag(___phase4)};
 
             float32x4_t _phase4_real = vld1q_f32(__phase4_real);
             float32x4_t _phase4_imag = vld1q_f32(__phase4_imag);
 
-            lv_32fc_t phase2 = (lv_32fc_t)(_phase) * phase_inc;
+            lv_32fc_t phase2 = (lv_32fc_t)(_phase)*phase_inc;
             lv_32fc_t phase3 = phase2 * phase_inc;
             lv_32fc_t phase4 = phase3 * phase_inc;
 
-            __VOLK_ATTR_ALIGNED(16) float32_t __phase_real[4] = { lv_creal((_phase)), lv_creal(phase2), lv_creal(phase3), lv_creal(phase4) };
-            __VOLK_ATTR_ALIGNED(16) float32_t __phase_imag[4] = { lv_cimag((_phase)), lv_cimag(phase2), lv_cimag(phase3), lv_cimag(phase4) };
+            __VOLK_ATTR_ALIGNED(16)
+            float32_t __phase_real[4] = {lv_creal((_phase)), lv_creal(phase2), lv_creal(phase3), lv_creal(phase4)};
+            __VOLK_ATTR_ALIGNED(16)
+            float32_t __phase_imag[4] = {lv_cimag((_phase)), lv_cimag(phase2), lv_cimag(phase3), lv_cimag(phase4)};
 
             float32x4_t _phase_real = vld1q_f32(__phase_real);
             float32x4_t _phase_imag = vld1q_f32(__phase_imag);
 
-            __VOLK_ATTR_ALIGNED(32) lv_32fc_t dotProductVector[4];
+            __VOLK_ATTR_ALIGNED(32)
+            lv_32fc_t dotProductVector[4];
 
             float32x4x2_t a_val, b_val, tmp32_real, tmp32_imag;
 
             float32x4x2_t* accumulator1 = (float32x4x2_t*)volk_gnsssdr_malloc(num_a_vectors * sizeof(float32x4x2_t), volk_gnsssdr_get_alignment());
             float32x4x2_t* accumulator2 = (float32x4x2_t*)volk_gnsssdr_malloc(num_a_vectors * sizeof(float32x4x2_t), volk_gnsssdr_get_alignment());
 
-            for(n_vec = 0; n_vec < num_a_vectors; n_vec++)
+            for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
                 {
                     accumulator1[n_vec].val[0] = vdupq_n_f32(0.0f);
                     accumulator1[n_vec].val[1] = vdupq_n_f32(0.0f);
@@ -693,7 +708,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_neon(lv_32fc_t*
                     accumulator2[n_vec].val[1] = vdupq_n_f32(0.0f);
                 }
 
-            for(number = 0; number < neon_iters; number++)
+            for (number = 0; number < neon_iters; number++)
                 {
                     /* load 4 complex numbers (float 32 bits each component) */
                     b_val = vld2q_f32((float32_t*)_in_common);
@@ -728,8 +743,10 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_neon(lv_32fc_t*
                             phase3 = phase2 * phase_inc;
                             phase4 = phase3 * phase_inc;
 
-                            __VOLK_ATTR_ALIGNED(16) float32_t ____phase_real[4] = { lv_creal((_phase)), lv_creal(phase2), lv_creal(phase3), lv_creal(phase4) };
-                            __VOLK_ATTR_ALIGNED(16) float32_t ____phase_imag[4] = { lv_cimag((_phase)), lv_cimag(phase2), lv_cimag(phase3), lv_cimag(phase4) };
+                            __VOLK_ATTR_ALIGNED(16)
+                            float32_t ____phase_real[4] = {lv_creal((_phase)), lv_creal(phase2), lv_creal(phase3), lv_creal(phase4)};
+                            __VOLK_ATTR_ALIGNED(16)
+                            float32_t ____phase_imag[4] = {lv_cimag((_phase)), lv_cimag(phase2), lv_cimag(phase3), lv_cimag(phase4)};
 
                             _phase_real = vld1q_f32(____phase_real);
                             _phase_imag = vld1q_f32(____phase_imag);
@@ -753,8 +770,8 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_neon(lv_32fc_t*
                 }
             for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
                 {
-                    vst2q_f32((float32_t*)dotProductVector, accumulator1[n_vec]); // Store the results back into the dot product vector
-                    dotProduct = lv_cmake(0,0);
+                    vst2q_f32((float32_t*)dotProductVector, accumulator1[n_vec]);  // Store the results back into the dot product vector
+                    dotProduct = lv_cmake(0, 0);
                     for (i = 0; i < 4; ++i)
                         {
                             dotProduct = dotProduct + dotProductVector[i];
@@ -770,7 +787,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_neon(lv_32fc_t*
             _phase = lv_cmake((float32_t)__phase_real[0], (float32_t)__phase_imag[0]);
         }
 
-    for(n = neon_iters * 4; n < num_points; n++)
+    for (n = neon_iters * 4; n < num_points; n++)
         {
             tmp32_1 = in_common[n] * _phase;
             _phase *= phase_inc;
@@ -786,4 +803,3 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_neon(lv_32fc_t*
 #endif /* LV_HAVE_NEON */
 
 #endif /* INCLUDED_volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_H */
-

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc.h

@@ -41,7 +41,7 @@
 #include <string.h>
 
 #ifdef LV_HAVE_GENERIC
-static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_generic(lv_32fc_t* result, const lv_32fc_t* local_code,  const lv_32fc_t* in, unsigned int num_points)
+static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_generic(lv_32fc_t* result, const lv_32fc_t* local_code, const lv_32fc_t* in, unsigned int num_points)
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.25;
@@ -53,14 +53,14 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_generic(lv_
     unsigned int n;
     int num_a_vectors = 3;
     lv_32fc_t** in_a = (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_32fc_t*)in_a[n], (lv_32fc_t*)in, sizeof(lv_32fc_t) * num_points);
         }
-    volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_generic_reload(result, local_code, phase_inc[0], phase, (const lv_32fc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_generic_reload(result, local_code, phase_inc[0], phase, (const lv_32fc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
@@ -71,7 +71,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_generic(lv_
 
 
 #ifdef LV_HAVE_GENERIC
-static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_generic_reload(lv_32fc_t* result, const lv_32fc_t* local_code,  const lv_32fc_t* in, unsigned int num_points)
+static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_generic_reload(lv_32fc_t* result, const lv_32fc_t* local_code, const lv_32fc_t* in, unsigned int num_points)
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.25;
@@ -83,14 +83,14 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_generic_rel
     unsigned int n;
     int num_a_vectors = 3;
     lv_32fc_t** in_a = (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_32fc_t*)in_a[n], (lv_32fc_t*)in, sizeof(lv_32fc_t) * num_points);
         }
-    volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_generic_reload(result, local_code, phase_inc[0], phase, (const lv_32fc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_generic_reload(result, local_code, phase_inc[0], phase, (const lv_32fc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
@@ -101,7 +101,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_generic_rel
 
 
 #ifdef LV_HAVE_SSE3
-static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_u_sse3(lv_32fc_t* result, const lv_32fc_t* local_code,  const lv_32fc_t* in, unsigned int num_points)
+static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_u_sse3(lv_32fc_t* result, const lv_32fc_t* local_code, const lv_32fc_t* in, unsigned int num_points)
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.25;
@@ -113,14 +113,14 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_u_sse3(lv_3
     unsigned int n;
     int num_a_vectors = 3;
     lv_32fc_t** in_a = (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_32fc_t*)in_a[n], (lv_32fc_t*)in, sizeof(lv_32fc_t) * num_points);
         }
-    volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_sse3(result, local_code, phase_inc[0], phase, (const lv_32fc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_sse3(result, local_code, phase_inc[0], phase, (const lv_32fc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
@@ -131,7 +131,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_u_sse3(lv_3
 
 
 #ifdef LV_HAVE_SSE3
-static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_a_sse3(lv_32fc_t* result, const lv_32fc_t* local_code,  const lv_32fc_t* in, unsigned int num_points)
+static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_a_sse3(lv_32fc_t* result, const lv_32fc_t* local_code, const lv_32fc_t* in, unsigned int num_points)
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.25;
@@ -143,14 +143,14 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_a_sse3(lv_3
     unsigned int n;
     int num_a_vectors = 3;
     lv_32fc_t** in_a = (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_32fc_t*)in_a[n], (lv_32fc_t*)in, sizeof(lv_32fc_t) * num_points);
         }
-    volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_sse3(result, local_code, phase_inc[0], phase, (const lv_32fc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_sse3(result, local_code, phase_inc[0], phase, (const lv_32fc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
@@ -161,7 +161,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_a_sse3(lv_3
 
 
 #ifdef LV_HAVE_AVX
-static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_u_avx(lv_32fc_t* result, const lv_32fc_t* local_code,  const lv_32fc_t* in, unsigned int num_points)
+static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_u_avx(lv_32fc_t* result, const lv_32fc_t* local_code, const lv_32fc_t* in, unsigned int num_points)
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.25;
@@ -173,14 +173,14 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_u_avx(lv_32
     unsigned int n;
     int num_a_vectors = 3;
     lv_32fc_t** in_a = (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_32fc_t*)in_a[n], (lv_32fc_t*)in, sizeof(lv_32fc_t) * num_points);
         }
-    volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_avx(result, local_code, phase_inc[0], phase, (const lv_32fc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_avx(result, local_code, phase_inc[0], phase, (const lv_32fc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
@@ -191,7 +191,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_u_avx(lv_32
 
 
 #ifdef LV_HAVE_AVX
-static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_a_avx(lv_32fc_t* result, const lv_32fc_t* local_code,  const lv_32fc_t* in, unsigned int num_points)
+static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_a_avx(lv_32fc_t* result, const lv_32fc_t* local_code, const lv_32fc_t* in, unsigned int num_points)
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.25;
@@ -203,14 +203,14 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_a_avx(lv_32
     unsigned int n;
     int num_a_vectors = 3;
     lv_32fc_t** in_a = (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_32fc_t*)in_a[n], (lv_32fc_t*)in, sizeof(lv_32fc_t) * num_points);
         }
-    volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_avx(result, local_code, phase_inc[0], phase, (const lv_32fc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_avx(result, local_code, phase_inc[0], phase, (const lv_32fc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }
@@ -221,7 +221,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_a_avx(lv_32
 
 
 #ifdef LV_HAVE_NEON
-static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_neon(lv_32fc_t* result, const lv_32fc_t* local_code,  const lv_32fc_t* in, unsigned int num_points)
+static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_neon(lv_32fc_t* result, const lv_32fc_t* local_code, const lv_32fc_t* in, unsigned int num_points)
 {
     // phases must be normalized. Phase rotator expects a complex exponential input!
     float rem_carrier_phase_in_rad = 0.25;
@@ -233,14 +233,14 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc_neon(lv_32f
     unsigned int n;
     int num_a_vectors = 3;
     lv_32fc_t** in_a = (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_a_vectors, volk_gnsssdr_get_alignment());
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             in_a[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
             memcpy((lv_32fc_t*)in_a[n], (lv_32fc_t*)in, sizeof(lv_32fc_t) * num_points);
         }
-    volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_neon(result, local_code, phase_inc[0], phase, (const lv_32fc_t**) in_a, num_a_vectors, num_points);
+    volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_neon(result, local_code, phase_inc[0], phase, (const lv_32fc_t**)in_a, num_a_vectors, num_points);
 
-    for(n = 0; n < num_a_vectors; n++)
+    for (n = 0; n < num_a_vectors; n++)
         {
             volk_gnsssdr_free(in_a[n]);
         }

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32fc_xn_resampler_32fc_xn.h

@@ -107,7 +107,8 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_sse3(lv_32fc_t** res
     const __m128 rem_code_phase_chips_reg = _mm_set_ps1(rem_code_phase_chips);
     const __m128 code_phase_step_chips_reg = _mm_set_ps1(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     int local_code_chip_index_;
 
     const __m128i zeros = _mm_setzero_si128();
@@ -121,7 +122,7 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_sse3(lv_32fc_t** res
             shifts_chips_reg = _mm_set_ps1((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             __m128 indexn = _mm_set_ps(3.0f, 2.0f, 1.0f, 0.0f);
-            for(n = 0; n < quarterPoints; n++)
+            for (n = 0; n < quarterPoints; n++)
                 {
                     aux = _mm_mul_ps(code_phase_step_chips_reg, indexn);
                     aux = _mm_add_ps(aux, aux2);
@@ -142,18 +143,18 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_sse3(lv_32fc_t** res
                     aux_i = _mm_and_si128(code_length_chips_reg_i, negatives);
                     local_code_chip_index_reg = _mm_add_epi32(local_code_chip_index_reg, aux_i);
                     _mm_store_si128((__m128i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 4; ++k)
+                    for (k = 0; k < 4; ++k)
                         {
                             _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
                         }
                     indexn = _mm_add_ps(indexn, fours);
                 }
-            for(n = quarterPoints * 4; n < num_points; n++)
+            for (n = quarterPoints * 4; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
                     //Take into account that in multitap correlators, the shifts can be negative!
-                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1) ;
+                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1);
                     local_code_chip_index_ = local_code_chip_index_ % code_length_chips;
                     _result[current_correlator_tap][n] = local_code[local_code_chip_index_];
                 }
@@ -177,7 +178,8 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_u_sse3(lv_32fc_t** res
     const __m128 rem_code_phase_chips_reg = _mm_set_ps1(rem_code_phase_chips);
     const __m128 code_phase_step_chips_reg = _mm_set_ps1(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     int local_code_chip_index_;
 
     const __m128i zeros = _mm_setzero_si128();
@@ -191,7 +193,7 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_u_sse3(lv_32fc_t** res
             shifts_chips_reg = _mm_set_ps1((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             __m128 indexn = _mm_set_ps(3.0f, 2.0f, 1.0f, 0.0f);
-            for(n = 0; n < quarterPoints; n++)
+            for (n = 0; n < quarterPoints; n++)
                 {
                     aux = _mm_mul_ps(code_phase_step_chips_reg, indexn);
                     aux = _mm_add_ps(aux, aux2);
@@ -212,18 +214,18 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_u_sse3(lv_32fc_t** res
                     aux_i = _mm_and_si128(code_length_chips_reg_i, negatives);
                     local_code_chip_index_reg = _mm_add_epi32(local_code_chip_index_reg, aux_i);
                     _mm_store_si128((__m128i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 4; ++k)
+                    for (k = 0; k < 4; ++k)
                         {
                             _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
                         }
                     indexn = _mm_add_ps(indexn, fours);
                 }
-            for(n = quarterPoints * 4; n < num_points; n++)
+            for (n = quarterPoints * 4; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
                     //Take into account that in multitap correlators, the shifts can be negative!
-                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1) ;
+                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1);
                     local_code_chip_index_ = local_code_chip_index_ % code_length_chips;
                     _result[current_correlator_tap][n] = local_code[local_code_chip_index_];
                 }
@@ -245,7 +247,8 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_sse4_1(lv_32fc_t** r
     const __m128 rem_code_phase_chips_reg = _mm_set_ps1(rem_code_phase_chips);
     const __m128 code_phase_step_chips_reg = _mm_set_ps1(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     int local_code_chip_index_;
 
     const __m128i zeros = _mm_setzero_si128();
@@ -259,7 +262,7 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_sse4_1(lv_32fc_t** r
             shifts_chips_reg = _mm_set_ps1((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             __m128 indexn = _mm_set_ps(3.0f, 2.0f, 1.0f, 0.0f);
-            for(n = 0; n < quarterPoints; n++)
+            for (n = 0; n < quarterPoints; n++)
                 {
                     aux = _mm_mul_ps(code_phase_step_chips_reg, indexn);
                     aux = _mm_add_ps(aux, aux2);
@@ -277,18 +280,18 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_sse4_1(lv_32fc_t** r
                     aux_i = _mm_and_si128(code_length_chips_reg_i, negatives);
                     local_code_chip_index_reg = _mm_add_epi32(local_code_chip_index_reg, aux_i);
                     _mm_store_si128((__m128i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 4; ++k)
+                    for (k = 0; k < 4; ++k)
                         {
                             _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
                         }
                     indexn = _mm_add_ps(indexn, fours);
                 }
-            for(n = quarterPoints * 4; n < num_points; n++)
+            for (n = quarterPoints * 4; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
                     //Take into account that in multitap correlators, the shifts can be negative!
-                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1) ;
+                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1);
                     local_code_chip_index_ = local_code_chip_index_ % code_length_chips;
                     _result[current_correlator_tap][n] = local_code[local_code_chip_index_];
                 }
@@ -311,7 +314,8 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_u_sse4_1(lv_32fc_t** r
     const __m128 rem_code_phase_chips_reg = _mm_set_ps1(rem_code_phase_chips);
     const __m128 code_phase_step_chips_reg = _mm_set_ps1(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(16) int local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int local_code_chip_index[4];
     int local_code_chip_index_;
 
     const __m128i zeros = _mm_setzero_si128();
@@ -325,7 +329,7 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_u_sse4_1(lv_32fc_t** r
             shifts_chips_reg = _mm_set_ps1((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             __m128 indexn = _mm_set_ps(3.0f, 2.0f, 1.0f, 0.0f);
-            for(n = 0; n < quarterPoints; n++)
+            for (n = 0; n < quarterPoints; n++)
                 {
                     aux = _mm_mul_ps(code_phase_step_chips_reg, indexn);
                     aux = _mm_add_ps(aux, aux2);
@@ -343,18 +347,18 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_u_sse4_1(lv_32fc_t** r
                     aux_i = _mm_and_si128(code_length_chips_reg_i, negatives);
                     local_code_chip_index_reg = _mm_add_epi32(local_code_chip_index_reg, aux_i);
                     _mm_store_si128((__m128i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 4; ++k)
+                    for (k = 0; k < 4; ++k)
                         {
                             _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
                         }
                     indexn = _mm_add_ps(indexn, fours);
                 }
-            for(n = quarterPoints * 4; n < num_points; n++)
+            for (n = quarterPoints * 4; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
                     //Take into account that in multitap correlators, the shifts can be negative!
-                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1) ;
+                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1);
                     local_code_chip_index_ = local_code_chip_index_ % code_length_chips;
                     _result[current_correlator_tap][n] = local_code[local_code_chip_index_];
                 }
@@ -377,7 +381,8 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_avx(lv_32fc_t** resu
     const __m256 rem_code_phase_chips_reg = _mm256_set1_ps(rem_code_phase_chips);
     const __m256 code_phase_step_chips_reg = _mm256_set1_ps(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(32) int local_code_chip_index[8];
+    __VOLK_ATTR_ALIGNED(32)
+    int local_code_chip_index[8];
     int local_code_chip_index_;
 
     const __m256 zeros = _mm256_setzero_ps();
@@ -392,7 +397,7 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_avx(lv_32fc_t** resu
             shifts_chips_reg = _mm256_set1_ps((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm256_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             indexn = n0;
-            for(n = 0; n < avx_iters; n++)
+            for (n = 0; n < avx_iters; n++)
                 {
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&_result[current_correlator_tap][8 * n + 7], 1, 0);
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&local_code_chip_index[8], 1, 3);
@@ -410,13 +415,13 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_avx(lv_32fc_t** resu
 
                     // no negatives
                     c = _mm256_cvtepi32_ps(local_code_chip_index_reg);
-                    negatives = _mm256_cmp_ps(c, zeros, 0x01 );
+                    negatives = _mm256_cmp_ps(c, zeros, 0x01);
                     aux3 = _mm256_and_ps(code_length_chips_reg_f, negatives);
                     aux = _mm256_add_ps(c, aux3);
                     local_code_chip_index_reg = _mm256_cvttps_epi32(aux);
 
                     _mm256_store_si256((__m256i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 8; ++k)
+                    for (k = 0; k < 8; ++k)
                         {
                             _result[current_correlator_tap][n * 8 + k] = local_code[local_code_chip_index[k]];
                         }
@@ -426,12 +431,12 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_avx(lv_32fc_t** resu
     _mm256_zeroupper();
     for (current_correlator_tap = 0; current_correlator_tap < num_out_vectors; current_correlator_tap++)
         {
-            for(n = avx_iters * 8; n < num_points; n++)
+            for (n = avx_iters * 8; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
                     //Take into account that in multitap correlators, the shifts can be negative!
-                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1) ;
+                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1);
                     local_code_chip_index_ = local_code_chip_index_ % code_length_chips;
                     _result[current_correlator_tap][n] = local_code[local_code_chip_index_];
                 }
@@ -454,7 +459,8 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_u_avx(lv_32fc_t** resu
     const __m256 rem_code_phase_chips_reg = _mm256_set1_ps(rem_code_phase_chips);
     const __m256 code_phase_step_chips_reg = _mm256_set1_ps(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(32) int local_code_chip_index[8];
+    __VOLK_ATTR_ALIGNED(32)
+    int local_code_chip_index[8];
     int local_code_chip_index_;
 
     const __m256 zeros = _mm256_setzero_ps();
@@ -469,7 +475,7 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_u_avx(lv_32fc_t** resu
             shifts_chips_reg = _mm256_set1_ps((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm256_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             indexn = n0;
-            for(n = 0; n < avx_iters; n++)
+            for (n = 0; n < avx_iters; n++)
                 {
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&_result[current_correlator_tap][8 * n + 7], 1, 0);
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&local_code_chip_index[8], 1, 3);
@@ -487,13 +493,13 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_u_avx(lv_32fc_t** resu
 
                     // no negatives
                     c = _mm256_cvtepi32_ps(local_code_chip_index_reg);
-                    negatives = _mm256_cmp_ps(c, zeros, 0x01 );
+                    negatives = _mm256_cmp_ps(c, zeros, 0x01);
                     aux3 = _mm256_and_ps(code_length_chips_reg_f, negatives);
                     aux = _mm256_add_ps(c, aux3);
                     local_code_chip_index_reg = _mm256_cvttps_epi32(aux);
 
                     _mm256_store_si256((__m256i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 8; ++k)
+                    for (k = 0; k < 8; ++k)
                         {
                             _result[current_correlator_tap][n * 8 + k] = local_code[local_code_chip_index[k]];
                         }
@@ -503,12 +509,12 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_u_avx(lv_32fc_t** resu
     _mm256_zeroupper();
     for (current_correlator_tap = 0; current_correlator_tap < num_out_vectors; current_correlator_tap++)
         {
-            for(n = avx_iters * 8; n < num_points; n++)
+            for (n = avx_iters * 8; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
                     //Take into account that in multitap correlators, the shifts can be negative!
-                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1) ;
+                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1);
                     local_code_chip_index_ = local_code_chip_index_ % code_length_chips;
                     _result[current_correlator_tap][n] = local_code[local_code_chip_index_];
                 }
@@ -531,7 +537,8 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_u_avx2(lv_32fc_t** res
     const __m256 rem_code_phase_chips_reg = _mm256_set1_ps(rem_code_phase_chips);
     const __m256 code_phase_step_chips_reg = _mm256_set1_ps(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(32) int local_code_chip_index[8];
+    __VOLK_ATTR_ALIGNED(32)
+    int local_code_chip_index[8];
     int local_code_chip_index_;
 
     const __m256 zeros = _mm256_setzero_ps();
@@ -546,7 +553,7 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_u_avx2(lv_32fc_t** res
             shifts_chips_reg = _mm256_set1_ps((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm256_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             indexn = n0;
-            for(n = 0; n < avx_iters; n++)
+            for (n = 0; n < avx_iters; n++)
                 {
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&_result[current_correlator_tap][8 * n + 7], 1, 0);
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&local_code_chip_index[8], 1, 3);
@@ -565,13 +572,13 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_u_avx2(lv_32fc_t** res
 
                     // no negatives
                     c = _mm256_cvtepi32_ps(local_code_chip_index_reg);
-                    negatives = _mm256_cmp_ps(c, zeros, 0x01 );
+                    negatives = _mm256_cmp_ps(c, zeros, 0x01);
                     aux3 = _mm256_and_ps(code_length_chips_reg_f, negatives);
                     aux = _mm256_add_ps(c, aux3);
                     local_code_chip_index_reg = _mm256_cvttps_epi32(aux);
 
                     _mm256_store_si256((__m256i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 8; ++k)
+                    for (k = 0; k < 8; ++k)
                         {
                             _result[current_correlator_tap][n * 8 + k] = local_code[local_code_chip_index[k]];
                         }
@@ -581,12 +588,12 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_u_avx2(lv_32fc_t** res
     _mm256_zeroupper();
     for (current_correlator_tap = 0; current_correlator_tap < num_out_vectors; current_correlator_tap++)
         {
-            for(n = avx_iters * 8; n < num_points; n++)
+            for (n = avx_iters * 8; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
                     //Take into account that in multitap correlators, the shifts can be negative!
-                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1) ;
+                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1);
                     local_code_chip_index_ = local_code_chip_index_ % code_length_chips;
                     _result[current_correlator_tap][n] = local_code[local_code_chip_index_];
                 }
@@ -609,7 +616,8 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_avx2(lv_32fc_t** res
     const __m256 rem_code_phase_chips_reg = _mm256_set1_ps(rem_code_phase_chips);
     const __m256 code_phase_step_chips_reg = _mm256_set1_ps(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(32) int local_code_chip_index[8];
+    __VOLK_ATTR_ALIGNED(32)
+    int local_code_chip_index[8];
     int local_code_chip_index_;
 
     const __m256 zeros = _mm256_setzero_ps();
@@ -624,7 +632,7 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_avx2(lv_32fc_t** res
             shifts_chips_reg = _mm256_set1_ps((float)shifts_chips[current_correlator_tap]);
             aux2 = _mm256_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
             indexn = n0;
-            for(n = 0; n < avx_iters; n++)
+            for (n = 0; n < avx_iters; n++)
                 {
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&_result[current_correlator_tap][8 * n + 7], 1, 0);
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&local_code_chip_index[8], 1, 3);
@@ -643,13 +651,13 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_avx2(lv_32fc_t** res
 
                     // no negatives
                     c = _mm256_cvtepi32_ps(local_code_chip_index_reg);
-                    negatives = _mm256_cmp_ps(c, zeros, 0x01 );
+                    negatives = _mm256_cmp_ps(c, zeros, 0x01);
                     aux3 = _mm256_and_ps(code_length_chips_reg_f, negatives);
                     aux = _mm256_add_ps(c, aux3);
                     local_code_chip_index_reg = _mm256_cvttps_epi32(aux);
 
                     _mm256_store_si256((__m256i*)local_code_chip_index, local_code_chip_index_reg);
-                    for(k = 0; k < 8; ++k)
+                    for (k = 0; k < 8; ++k)
                         {
                             _result[current_correlator_tap][n * 8 + k] = local_code[local_code_chip_index[k]];
                         }
@@ -659,12 +667,12 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_avx2(lv_32fc_t** res
     _mm256_zeroupper();
     for (current_correlator_tap = 0; current_correlator_tap < num_out_vectors; current_correlator_tap++)
         {
-            for(n = avx_iters * 8; n < num_points; n++)
+            for (n = avx_iters * 8; n < num_points; n++)
                 {
                     // resample code for current tap
                     local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
                     //Take into account that in multitap correlators, the shifts can be negative!
-                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1) ;
+                    if (local_code_chip_index_ < 0) local_code_chip_index_ += (int)code_length_chips * (abs(local_code_chip_index_) / code_length_chips + 1);
                     local_code_chip_index_ = local_code_chip_index_ % code_length_chips;
                     _result[current_correlator_tap][n] = local_code[local_code_chip_index_];
                 }
@@ -689,19 +697,21 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_neon(lv_32fc_t** resul
     const float32x4_t rem_code_phase_chips_reg = vdupq_n_f32(rem_code_phase_chips);
     const float32x4_t code_phase_step_chips_reg = vdupq_n_f32(code_phase_step_chips);
 
-    __VOLK_ATTR_ALIGNED(16) int32_t local_code_chip_index[4];
+    __VOLK_ATTR_ALIGNED(16)
+    int32_t local_code_chip_index[4];
     int32_t local_code_chip_index_;
 
     const int32x4_t zeros = vdupq_n_s32(0);
     const float32x4_t code_length_chips_reg_f = vdupq_n_f32((float)code_length_chips);
     const int32x4_t code_length_chips_reg_i = vdupq_n_s32((int32_t)code_length_chips);
-    int32x4_t local_code_chip_index_reg, aux_i,  negatives, i;
+    int32x4_t local_code_chip_index_reg, aux_i, negatives, i;
     float32x4_t aux, aux2, shifts_chips_reg, fi, c, j, cTrunc, base, indexn, reciprocal;
-    __VOLK_ATTR_ALIGNED(16) const float vec[4] = { 0.0f, 1.0f, 2.0f, 3.0f };
+    __VOLK_ATTR_ALIGNED(16)
+    const float vec[4] = {0.0f, 1.0f, 2.0f, 3.0f};
     uint32x4_t igx;
     reciprocal = vrecpeq_f32(code_length_chips_reg_f);
     reciprocal = vmulq_f32(vrecpsq_f32(code_length_chips_reg_f, reciprocal), reciprocal);
-    reciprocal = vmulq_f32(vrecpsq_f32(code_length_chips_reg_f, reciprocal), reciprocal); // this refinement is required!
+    reciprocal = vmulq_f32(vrecpsq_f32(code_length_chips_reg_f, reciprocal), reciprocal);  // this refinement is required!
     float32x4_t n0 = vld1q_f32((float*)vec);
 
     for (current_correlator_tap = 0; current_correlator_tap < num_out_vectors; current_correlator_tap++)
@@ -709,7 +719,7 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_neon(lv_32fc_t** resul
             shifts_chips_reg = vdupq_n_f32((float)shifts_chips[current_correlator_tap]);
             aux2 = vsubq_f32(shifts_chips_reg, rem_code_phase_chips_reg);
             indexn = n0;
-            for(n = 0; n < neon_iters; n++)
+            for (n = 0; n < neon_iters; n++)
                 {
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&_result[current_correlator_tap][4 * n + 3], 1, 0);
                     __VOLK_GNSSSDR_PREFETCH(&local_code_chip_index[4]);
@@ -725,7 +735,7 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_neon(lv_32fc_t** resul
 
                     // fmod
                     c = vmulq_f32(aux, reciprocal);
-                    i =  vcvtq_s32_f32(c);
+                    i = vcvtq_s32_f32(c);
                     cTrunc = vcvtq_f32_s32(i);
                     base = vmulq_f32(cTrunc, code_length_chips_reg_f);
                     aux = vsubq_f32(aux, base);
@@ -737,13 +747,13 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_neon(lv_32fc_t** resul
 
                     vst1q_s32((int32_t*)local_code_chip_index, local_code_chip_index_reg);
 
-                    for(k = 0; k < 4; ++k)
+                    for (k = 0; k < 4; ++k)
                         {
                             _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
                         }
                     indexn = vaddq_f32(indexn, fours);
                 }
-            for(n = neon_iters * 4; n < num_points; n++)
+            for (n = neon_iters * 4; n < num_points; n++)
                 {
                     __VOLK_GNSSSDR_PREFETCH_LOCALITY(&_result[current_correlator_tap][n], 1, 0);
                     // resample code for current tap

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_64f_accumulator_64f.h

@@ -69,11 +69,12 @@ static inline void volk_gnsssdr_64f_accumulator_64f_u_avx(double* result, const
     unsigned int i;
     const double* aPtr = inputBuffer;
 
-    __VOLK_ATTR_ALIGNED(32) double tempBuffer[4];
+    __VOLK_ATTR_ALIGNED(32)
+    double tempBuffer[4];
     __m256d accumulator = _mm256_setzero_pd();
     __m256d aVal = _mm256_setzero_pd();
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             aVal = _mm256_loadu_pd(aPtr);
             accumulator = _mm256_add_pd(accumulator, aVal);
@@ -82,12 +83,12 @@ static inline void volk_gnsssdr_64f_accumulator_64f_u_avx(double* result, const
 
     _mm256_storeu_pd((double*)tempBuffer, accumulator);
 
-    for(i = 0; i < 4; ++i)
+    for (i = 0; i < 4; ++i)
         {
             returnValue += tempBuffer[i];
         }
 
-    for(i = 0; i < (num_points % 4); ++i)
+    for (i = 0; i < (num_points % 4); ++i)
         {
             returnValue += (*aPtr++);
         }
@@ -100,7 +101,7 @@ static inline void volk_gnsssdr_64f_accumulator_64f_u_avx(double* result, const
 #ifdef LV_HAVE_SSE3
 #include <pmmintrin.h>
 
-static inline void volk_gnsssdr_64f_accumulator_64f_u_sse3(double* result,const double* inputBuffer, unsigned int num_points)
+static inline void volk_gnsssdr_64f_accumulator_64f_u_sse3(double* result, const double* inputBuffer, unsigned int num_points)
 {
     double returnValue = 0;
     const unsigned int sse_iters = num_points / 2;
@@ -108,11 +109,12 @@ static inline void volk_gnsssdr_64f_accumulator_64f_u_sse3(double* result,const
     unsigned int i;
     const double* aPtr = inputBuffer;
 
-    __VOLK_ATTR_ALIGNED(16) double tempBuffer[2];
+    __VOLK_ATTR_ALIGNED(16)
+    double tempBuffer[2];
     __m128d accumulator = _mm_setzero_pd();
     __m128d aVal = _mm_setzero_pd();
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             aVal = _mm_loadu_pd(aPtr);
             accumulator = _mm_add_pd(accumulator, aVal);
@@ -121,12 +123,12 @@ static inline void volk_gnsssdr_64f_accumulator_64f_u_sse3(double* result,const
 
     _mm_storeu_pd((double*)tempBuffer, accumulator);
 
-    for(i = 0; i < 2; ++i)
+    for (i = 0; i < 2; ++i)
         {
             returnValue += tempBuffer[i];
         }
 
-    for(i = 0; i < (num_points % 2); ++i)
+    for (i = 0; i < (num_points % 2); ++i)
         {
             returnValue += (*aPtr++);
         }
@@ -138,13 +140,13 @@ static inline void volk_gnsssdr_64f_accumulator_64f_u_sse3(double* result,const
 
 #ifdef LV_HAVE_GENERIC
 
-static inline void volk_gnsssdr_64f_accumulator_64f_generic(double* result,const double* inputBuffer, unsigned int num_points)
+static inline void volk_gnsssdr_64f_accumulator_64f_generic(double* result, const double* inputBuffer, unsigned int num_points)
 {
     const double* aPtr = inputBuffer;
     double returnValue = 0;
     unsigned int number;
 
-    for(number = 0; number < num_points; number++)
+    for (number = 0; number < num_points; number++)
         {
             returnValue += (*aPtr++);
         }
@@ -156,7 +158,7 @@ static inline void volk_gnsssdr_64f_accumulator_64f_generic(double* result,const
 #ifdef LV_HAVE_AVX
 #include <immintrin.h>
 
-static inline void volk_gnsssdr_64f_accumulator_64f_a_avx(double* result,const double* inputBuffer, unsigned int num_points)
+static inline void volk_gnsssdr_64f_accumulator_64f_a_avx(double* result, const double* inputBuffer, unsigned int num_points)
 {
     double returnValue = 0;
     const unsigned int sse_iters = num_points / 4;
@@ -164,11 +166,12 @@ static inline void volk_gnsssdr_64f_accumulator_64f_a_avx(double* result,const d
     unsigned int i;
     const double* aPtr = inputBuffer;
 
-    __VOLK_ATTR_ALIGNED(32) double tempBuffer[4];
+    __VOLK_ATTR_ALIGNED(32)
+    double tempBuffer[4];
     __m256d accumulator = _mm256_setzero_pd();
     __m256d aVal = _mm256_setzero_pd();
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             aVal = _mm256_load_pd(aPtr);
             accumulator = _mm256_add_pd(accumulator, aVal);
@@ -177,12 +180,12 @@ static inline void volk_gnsssdr_64f_accumulator_64f_a_avx(double* result,const d
 
     _mm256_store_pd((double*)tempBuffer, accumulator);
 
-    for(i = 0; i < 4; ++i)
+    for (i = 0; i < 4; ++i)
         {
             returnValue += tempBuffer[i];
         }
 
-    for(i = 0; i < (num_points % 4); ++i)
+    for (i = 0; i < (num_points % 4); ++i)
         {
             returnValue += (*aPtr++);
         }
@@ -195,7 +198,7 @@ static inline void volk_gnsssdr_64f_accumulator_64f_a_avx(double* result,const d
 #ifdef LV_HAVE_SSE3
 #include <pmmintrin.h>
 
-static inline void volk_gnsssdr_64f_accumulator_64f_a_sse3(double* result,const double* inputBuffer, unsigned int num_points)
+static inline void volk_gnsssdr_64f_accumulator_64f_a_sse3(double* result, const double* inputBuffer, unsigned int num_points)
 {
     double returnValue = 0;
     const unsigned int sse_iters = num_points / 2;
@@ -203,11 +206,12 @@ static inline void volk_gnsssdr_64f_accumulator_64f_a_sse3(double* result,const
     unsigned int i;
     const double* aPtr = inputBuffer;
 
-    __VOLK_ATTR_ALIGNED(16) double tempBuffer[2];
+    __VOLK_ATTR_ALIGNED(16)
+    double tempBuffer[2];
     __m128d accumulator = _mm_setzero_pd();
     __m128d aVal = _mm_setzero_pd();
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             aVal = _mm_load_pd(aPtr);
             accumulator = _mm_add_pd(accumulator, aVal);
@@ -216,12 +220,12 @@ static inline void volk_gnsssdr_64f_accumulator_64f_a_sse3(double* result,const
 
     _mm_store_pd((double*)tempBuffer, accumulator);
 
-    for(i = 0; i < 2; ++i)
+    for (i = 0; i < 2; ++i)
         {
             returnValue += tempBuffer[i];
         }
 
-    for(i = 0; i < (num_points % 2); ++i)
+    for (i = 0; i < (num_points % 2); ++i)
         {
             returnValue += (*aPtr++);
         }

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_8i_accumulator_s8i.h

@@ -70,11 +70,12 @@ static inline void volk_gnsssdr_8i_accumulator_s8i_u_sse3(char* result, const ch
     unsigned int i;
     const char* aPtr = inputBuffer;
 
-    __VOLK_ATTR_ALIGNED(16) char tempBuffer[16];
+    __VOLK_ATTR_ALIGNED(16)
+    char tempBuffer[16];
     __m128i accumulator = _mm_setzero_si128();
     __m128i aVal = _mm_setzero_si128();
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             aVal = _mm_lddqu_si128((__m128i*)aPtr);
             accumulator = _mm_add_epi8(accumulator, aVal);
@@ -82,12 +83,12 @@ static inline void volk_gnsssdr_8i_accumulator_s8i_u_sse3(char* result, const ch
         }
     _mm_storeu_si128((__m128i*)tempBuffer, accumulator);
 
-    for(i = 0; i < 16; ++i)
+    for (i = 0; i < 16; ++i)
         {
             returnValue += tempBuffer[i];
         }
 
-    for(i = 0; i < (num_points % 16); ++i)
+    for (i = 0; i < (num_points % 16); ++i)
         {
             returnValue += (*aPtr++);
         }
@@ -104,7 +105,7 @@ static inline void volk_gnsssdr_8i_accumulator_s8i_generic(char* result, const c
     const char* aPtr = inputBuffer;
     char returnValue = 0;
     unsigned int number;
-    for(number = 0;number < num_points; number++)
+    for (number = 0; number < num_points; number++)
         {
             returnValue += (*aPtr++);
         }
@@ -125,24 +126,25 @@ static inline void volk_gnsssdr_8i_accumulator_s8i_a_sse3(char* result, const ch
 
     const char* aPtr = inputBuffer;
 
-    __VOLK_ATTR_ALIGNED(16) char tempBuffer[16];
+    __VOLK_ATTR_ALIGNED(16)
+    char tempBuffer[16];
     __m128i accumulator = _mm_setzero_si128();
     __m128i aVal = _mm_setzero_si128();
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             aVal = _mm_load_si128((__m128i*)aPtr);
             accumulator = _mm_add_epi8(accumulator, aVal);
             aPtr += 16;
         }
-    _mm_store_si128((__m128i*)tempBuffer,accumulator);
+    _mm_store_si128((__m128i*)tempBuffer, accumulator);
 
-    for(i = 0; i < 16; ++i)
+    for (i = 0; i < 16; ++i)
         {
             returnValue += tempBuffer[i];
         }
 
-    for(i = 0; i < (num_points % 16); ++i)
+    for (i = 0; i < (num_points % 16); ++i)
         {
             returnValue += (*aPtr++);
         }
@@ -164,24 +166,25 @@ static inline void volk_gnsssdr_8i_accumulator_s8i_a_avx2(char* result, const ch
 
     const char* aPtr = inputBuffer;
 
-    __VOLK_ATTR_ALIGNED(32) char tempBuffer[32];
+    __VOLK_ATTR_ALIGNED(32)
+    char tempBuffer[32];
     __m256i accumulator = _mm256_setzero_si256();
     __m256i aVal = _mm256_setzero_si256();
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             aVal = _mm256_load_si256((__m256i*)aPtr);
             accumulator = _mm256_add_epi8(accumulator, aVal);
             aPtr += 32;
         }
-    _mm256_store_si256((__m256i*)tempBuffer,accumulator);
+    _mm256_store_si256((__m256i*)tempBuffer, accumulator);
 
-    for(i = 0; i < 32; ++i)
+    for (i = 0; i < 32; ++i)
         {
             returnValue += tempBuffer[i];
         }
 
-    for(i = 0; i < (num_points % 32); ++i)
+    for (i = 0; i < (num_points % 32); ++i)
         {
             returnValue += (*aPtr++);
         }
@@ -202,11 +205,12 @@ static inline void volk_gnsssdr_8i_accumulator_s8i_u_avx2(char* result, const ch
     unsigned int i;
     const char* aPtr = inputBuffer;
 
-    __VOLK_ATTR_ALIGNED(32) char tempBuffer[32];
+    __VOLK_ATTR_ALIGNED(32)
+    char tempBuffer[32];
     __m256i accumulator = _mm256_setzero_si256();
     __m256i aVal = _mm256_setzero_si256();
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             aVal = _mm256_lddqu_si256((__m256i*)aPtr);
             accumulator = _mm256_add_epi8(accumulator, aVal);
@@ -214,12 +218,12 @@ static inline void volk_gnsssdr_8i_accumulator_s8i_u_avx2(char* result, const ch
         }
     _mm256_storeu_si256((__m256i*)tempBuffer, accumulator);
 
-    for(i = 0; i < 32; ++i)
+    for (i = 0; i < 32; ++i)
         {
             returnValue += tempBuffer[i];
         }
 
-    for(i = 0; i < (num_points % 32); ++i)
+    for (i = 0; i < (num_points % 32); ++i)
         {
             returnValue += (*aPtr++);
         }

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_8i_index_max_16u.h

@@ -60,11 +60,11 @@
 
 
 #ifdef LV_HAVE_AVX2
-#include<immintrin.h>
+#include <immintrin.h>
 
 static inline void volk_gnsssdr_8i_index_max_16u_u_avx2(unsigned int* target, const char* src0, unsigned int num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             const unsigned int avx2_iters = num_points / 32;
             unsigned int number;
@@ -74,14 +74,15 @@ static inline void volk_gnsssdr_8i_index_max_16u_u_avx2(unsigned int* target, co
             char max = src0[0];
             unsigned int index = 0;
             unsigned int mask;
-            __VOLK_ATTR_ALIGNED(32) char currentValuesBuffer[32];
+            __VOLK_ATTR_ALIGNED(32)
+            char currentValuesBuffer[32];
             __m256i maxValues, compareResults, currentValues;
 
             maxValues = _mm256_set1_epi8(max);
 
-            for(number = 0; number < avx2_iters; number++)
+            for (number = 0; number < avx2_iters; number++)
                 {
-                    currentValues  = _mm256_loadu_si256((__m256i*)inputPtr);
+                    currentValues = _mm256_loadu_si256((__m256i*)inputPtr);
                     compareResults = _mm256_cmpgt_epi8(maxValues, currentValues);
                     mask = _mm256_movemask_epi8(compareResults);
 
@@ -94,7 +95,7 @@ static inline void volk_gnsssdr_8i_index_max_16u_u_avx2(unsigned int* target, co
                                 {
                                     if ((mask & 1) == 1)
                                         {
-                                            if(currentValuesBuffer[i] > max)
+                                            if (currentValuesBuffer[i] > max)
                                                 {
                                                     index = inputPtr - basePtr + i;
                                                     max = currentValuesBuffer[i];
@@ -108,9 +109,9 @@ static inline void volk_gnsssdr_8i_index_max_16u_u_avx2(unsigned int* target, co
                     inputPtr += 32;
                 }
 
-            for(i = 0; i<(num_points % 32); ++i)
+            for (i = 0; i < (num_points % 32); ++i)
                 {
-                    if(src0[i] > max)
+                    if (src0[i] > max)
                         {
                             index = i;
                             max = src0[i];
@@ -128,7 +129,7 @@ static inline void volk_gnsssdr_8i_index_max_16u_u_avx2(unsigned int* target, co
 
 static inline void volk_gnsssdr_8i_index_max_16u_u_avx(unsigned int* target, const char* src0, unsigned int num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             const unsigned int sse_iters = num_points / 32;
             unsigned int number;
@@ -137,33 +138,34 @@ static inline void volk_gnsssdr_8i_index_max_16u_u_avx(unsigned int* target, con
             char* inputPtr = (char*)src0;
             char max = src0[0];
             unsigned int index = 0;
-            __VOLK_ATTR_ALIGNED(32) char currentValuesBuffer[32];
+            __VOLK_ATTR_ALIGNED(32)
+            char currentValuesBuffer[32];
             __m256i ones, compareResults, currentValues;
             __m128i compareResultslo, compareResultshi, maxValues, lo, hi;
 
             ones = _mm256_set1_epi8(0xFF);
             maxValues = _mm_set1_epi8(max);
 
-            for(number = 0; number < sse_iters; number++)
+            for (number = 0; number < sse_iters; number++)
                 {
-                    currentValues  = _mm256_lddqu_si256((__m256i*)inputPtr);
+                    currentValues = _mm256_lddqu_si256((__m256i*)inputPtr);
 
                     lo = _mm256_castsi256_si128(currentValues);
-                    hi = _mm256_extractf128_si256(currentValues,1);
+                    hi = _mm256_extractf128_si256(currentValues, 1);
 
                     compareResultslo = _mm_cmpgt_epi8(maxValues, lo);
                     compareResultshi = _mm_cmpgt_epi8(maxValues, hi);
 
                     //compareResults = _mm256_set_m128i(compareResultshi , compareResultslo); //not defined in some versions of immintrin.h
-                    compareResults = _mm256_insertf128_si256(_mm256_castsi128_si256(compareResultslo),(compareResultshi),1);
+                    compareResults = _mm256_insertf128_si256(_mm256_castsi128_si256(compareResultslo), (compareResultshi), 1);
 
                     if (!_mm256_testc_si256(compareResults, ones))
                         {
                             _mm256_storeu_si256((__m256i*)&currentValuesBuffer, currentValues);
 
-                            for(i = 0; i < 32; i++)
+                            for (i = 0; i < 32; i++)
                                 {
-                                    if(currentValuesBuffer[i] > max)
+                                    if (currentValuesBuffer[i] > max)
                                         {
                                             index = inputPtr - basePtr + i;
                                             max = currentValuesBuffer[i];
@@ -175,9 +177,9 @@ static inline void volk_gnsssdr_8i_index_max_16u_u_avx(unsigned int* target, con
                     inputPtr += 32;
                 }
 
-            for(i = 0; i<(num_points % 32); ++i)
+            for (i = 0; i < (num_points % 32); ++i)
                 {
-                    if(src0[i] > max)
+                    if (src0[i] > max)
                         {
                             index = i;
                             max = src0[i];
@@ -195,7 +197,7 @@ static inline void volk_gnsssdr_8i_index_max_16u_u_avx(unsigned int* target, con
 
 static inline void volk_gnsssdr_8i_index_max_16u_u_sse4_1(unsigned int* target, const char* src0, unsigned int num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             const unsigned int sse_iters = num_points / 16;
             unsigned int number;
@@ -204,14 +206,15 @@ static inline void volk_gnsssdr_8i_index_max_16u_u_sse4_1(unsigned int* target,
             char* inputPtr = (char*)src0;
             char max = src0[0];
             unsigned int index = 0;
-            __VOLK_ATTR_ALIGNED(16) char currentValuesBuffer[16];
+            __VOLK_ATTR_ALIGNED(16)
+            char currentValuesBuffer[16];
             __m128i maxValues, compareResults, currentValues;
 
             maxValues = _mm_set1_epi8(max);
 
-            for(number = 0; number < sse_iters; number++)
+            for (number = 0; number < sse_iters; number++)
                 {
-                    currentValues  = _mm_lddqu_si128((__m128i*)inputPtr);
+                    currentValues = _mm_lddqu_si128((__m128i*)inputPtr);
 
                     compareResults = _mm_cmpgt_epi8(maxValues, currentValues);
 
@@ -219,9 +222,9 @@ static inline void volk_gnsssdr_8i_index_max_16u_u_sse4_1(unsigned int* target,
                         {
                             _mm_storeu_si128((__m128i*)&currentValuesBuffer, currentValues);
 
-                            for(i = 0; i < 16; i++)
+                            for (i = 0; i < 16; i++)
                                 {
-                                    if(currentValuesBuffer[i] > max)
+                                    if (currentValuesBuffer[i] > max)
                                         {
                                             index = inputPtr - basePtr + i;
                                             max = currentValuesBuffer[i];
@@ -233,9 +236,9 @@ static inline void volk_gnsssdr_8i_index_max_16u_u_sse4_1(unsigned int* target,
                     inputPtr += 16;
                 }
 
-            for(i = 0; i<(num_points % 16); ++i)
+            for (i = 0; i < (num_points % 16); ++i)
                 {
-                    if(src0[i] > max)
+                    if (src0[i] > max)
                         {
                             index = i;
                             max = src0[i];
@@ -249,11 +252,11 @@ static inline void volk_gnsssdr_8i_index_max_16u_u_sse4_1(unsigned int* target,
 
 
 #ifdef LV_HAVE_SSE2
-#include<emmintrin.h>
+#include <emmintrin.h>
 
 static inline void volk_gnsssdr_8i_index_max_16u_u_sse2(unsigned int* target, const char* src0, unsigned int num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             const unsigned int sse_iters = num_points / 16;
             unsigned int number;
@@ -263,14 +266,15 @@ static inline void volk_gnsssdr_8i_index_max_16u_u_sse2(unsigned int* target, co
             char max = src0[0];
             unsigned int index = 0;
             unsigned short mask;
-            __VOLK_ATTR_ALIGNED(16) char currentValuesBuffer[16];
+            __VOLK_ATTR_ALIGNED(16)
+            char currentValuesBuffer[16];
             __m128i maxValues, compareResults, currentValues;
 
             maxValues = _mm_set1_epi8(max);
 
-            for(number = 0; number < sse_iters; number++)
+            for (number = 0; number < sse_iters; number++)
                 {
-                    currentValues  = _mm_loadu_si128((__m128i*)inputPtr);
+                    currentValues = _mm_loadu_si128((__m128i*)inputPtr);
                     compareResults = _mm_cmpgt_epi8(maxValues, currentValues);
                     mask = _mm_movemask_epi8(compareResults);
 
@@ -283,7 +287,7 @@ static inline void volk_gnsssdr_8i_index_max_16u_u_sse2(unsigned int* target, co
                                 {
                                     if ((mask & 1) == 1)
                                         {
-                                            if(currentValuesBuffer[i] > max)
+                                            if (currentValuesBuffer[i] > max)
                                                 {
                                                     index = inputPtr - basePtr + i;
                                                     max = currentValuesBuffer[i];
@@ -297,9 +301,9 @@ static inline void volk_gnsssdr_8i_index_max_16u_u_sse2(unsigned int* target, co
                     inputPtr += 16;
                 }
 
-            for(i = 0; i<(num_points % 16); ++i)
+            for (i = 0; i < (num_points % 16); ++i)
                 {
-                    if(src0[i] > max)
+                    if (src0[i] > max)
                         {
                             index = i;
                             max = src0[i];
@@ -316,14 +320,14 @@ static inline void volk_gnsssdr_8i_index_max_16u_u_sse2(unsigned int* target, co
 
 static inline void volk_gnsssdr_8i_index_max_16u_generic(unsigned int* target, const char* src0, unsigned int num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             char max = src0[0];
             unsigned int index = 0;
             unsigned int i;
-            for(i = 1; i < num_points; ++i)
+            for (i = 1; i < num_points; ++i)
                 {
-                    if(src0[i] > max)
+                    if (src0[i] > max)
                         {
                             index = i;
                             max = src0[i];
@@ -337,11 +341,11 @@ static inline void volk_gnsssdr_8i_index_max_16u_generic(unsigned int* target, c
 
 
 #ifdef LV_HAVE_AVX2
-#include<immintrin.h>
+#include <immintrin.h>
 
 static inline void volk_gnsssdr_8i_index_max_16u_a_avx2(unsigned int* target, const char* src0, unsigned int num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             const unsigned int avx2_iters = num_points / 32;
             unsigned int number;
@@ -351,14 +355,15 @@ static inline void volk_gnsssdr_8i_index_max_16u_a_avx2(unsigned int* target, co
             char max = src0[0];
             unsigned int index = 0;
             unsigned int mask;
-            __VOLK_ATTR_ALIGNED(32) char currentValuesBuffer[32];
+            __VOLK_ATTR_ALIGNED(32)
+            char currentValuesBuffer[32];
             __m256i maxValues, compareResults, currentValues;
 
             maxValues = _mm256_set1_epi8(max);
 
-            for(number = 0; number < avx2_iters; number++)
+            for (number = 0; number < avx2_iters; number++)
                 {
-                    currentValues  = _mm256_load_si256((__m256i*)inputPtr);
+                    currentValues = _mm256_load_si256((__m256i*)inputPtr);
                     compareResults = _mm256_cmpgt_epi8(maxValues, currentValues);
                     mask = _mm256_movemask_epi8(compareResults);
 
@@ -371,7 +376,7 @@ static inline void volk_gnsssdr_8i_index_max_16u_a_avx2(unsigned int* target, co
                                 {
                                     if ((mask & 1) == 1)
                                         {
-                                            if(currentValuesBuffer[i] > max)
+                                            if (currentValuesBuffer[i] > max)
                                                 {
                                                     index = inputPtr - basePtr + i;
                                                     max = currentValuesBuffer[i];
@@ -385,9 +390,9 @@ static inline void volk_gnsssdr_8i_index_max_16u_a_avx2(unsigned int* target, co
                     inputPtr += 32;
                 }
 
-            for(i = 0; i<(num_points % 32); ++i)
+            for (i = 0; i < (num_points % 32); ++i)
                 {
-                    if(src0[i] > max)
+                    if (src0[i] > max)
                         {
                             index = i;
                             max = src0[i];
@@ -405,7 +410,7 @@ static inline void volk_gnsssdr_8i_index_max_16u_a_avx2(unsigned int* target, co
 
 static inline void volk_gnsssdr_8i_index_max_16u_a_avx(unsigned int* target, const char* src0, unsigned int num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             const unsigned int sse_iters = num_points / 32;
             unsigned int number;
@@ -414,19 +419,20 @@ static inline void volk_gnsssdr_8i_index_max_16u_a_avx(unsigned int* target, con
             char* inputPtr = (char*)src0;
             char max = src0[0];
             unsigned int index = 0;
-            __VOLK_ATTR_ALIGNED(32) char currentValuesBuffer[32];
+            __VOLK_ATTR_ALIGNED(32)
+            char currentValuesBuffer[32];
             __m256i ones, compareResults, currentValues;
             __m128i compareResultslo, compareResultshi, maxValues, lo, hi;
 
             ones = _mm256_set1_epi8(0xFF);
             maxValues = _mm_set1_epi8(max);
 
-            for(number = 0; number < sse_iters; number++)
+            for (number = 0; number < sse_iters; number++)
                 {
-                    currentValues  = _mm256_load_si256((__m256i*)inputPtr);
+                    currentValues = _mm256_load_si256((__m256i*)inputPtr);
 
                     lo = _mm256_castsi256_si128(currentValues);
-                    hi = _mm256_extractf128_si256(currentValues,1);
+                    hi = _mm256_extractf128_si256(currentValues, 1);
 
                     compareResultslo = _mm_cmpgt_epi8(maxValues, lo);
                     compareResultshi = _mm_cmpgt_epi8(maxValues, hi);
@@ -438,9 +444,9 @@ static inline void volk_gnsssdr_8i_index_max_16u_a_avx(unsigned int* target, con
                         {
                             _mm256_store_si256((__m256i*)&currentValuesBuffer, currentValues);
 
-                            for(i = 0; i < 32; i++)
+                            for (i = 0; i < 32; i++)
                                 {
-                                    if(currentValuesBuffer[i] > max)
+                                    if (currentValuesBuffer[i] > max)
                                         {
                                             index = inputPtr - basePtr + i;
                                             max = currentValuesBuffer[i];
@@ -452,9 +458,9 @@ static inline void volk_gnsssdr_8i_index_max_16u_a_avx(unsigned int* target, con
                     inputPtr += 32;
                 }
 
-            for(i = 0; i<(num_points % 32); ++i)
+            for (i = 0; i < (num_points % 32); ++i)
                 {
-                    if(src0[i] > max)
+                    if (src0[i] > max)
                         {
                             index = i;
                             max = src0[i];
@@ -472,7 +478,7 @@ static inline void volk_gnsssdr_8i_index_max_16u_a_avx(unsigned int* target, con
 
 static inline void volk_gnsssdr_8i_index_max_16u_a_sse4_1(unsigned int* target, const char* src0, unsigned int num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             const unsigned int sse_iters = num_points / 16;
             unsigned int number;
@@ -481,14 +487,15 @@ static inline void volk_gnsssdr_8i_index_max_16u_a_sse4_1(unsigned int* target,
             char* inputPtr = (char*)src0;
             char max = src0[0];
             unsigned int index = 0;
-            __VOLK_ATTR_ALIGNED(16) char currentValuesBuffer[16];
+            __VOLK_ATTR_ALIGNED(16)
+            char currentValuesBuffer[16];
             __m128i maxValues, compareResults, currentValues;
 
             maxValues = _mm_set1_epi8(max);
 
-            for(number = 0; number < sse_iters; number++)
+            for (number = 0; number < sse_iters; number++)
                 {
-                    currentValues  = _mm_load_si128((__m128i*)inputPtr);
+                    currentValues = _mm_load_si128((__m128i*)inputPtr);
 
                     compareResults = _mm_cmpgt_epi8(maxValues, currentValues);
 
@@ -496,9 +503,9 @@ static inline void volk_gnsssdr_8i_index_max_16u_a_sse4_1(unsigned int* target,
                         {
                             _mm_store_si128((__m128i*)&currentValuesBuffer, currentValues);
 
-                            for(i = 0; i < 16; i++)
+                            for (i = 0; i < 16; i++)
                                 {
-                                    if(currentValuesBuffer[i] > max)
+                                    if (currentValuesBuffer[i] > max)
                                         {
                                             index = inputPtr - basePtr + i;
                                             max = currentValuesBuffer[i];
@@ -510,9 +517,9 @@ static inline void volk_gnsssdr_8i_index_max_16u_a_sse4_1(unsigned int* target,
                     inputPtr += 16;
                 }
 
-            for(i = 0; i<(num_points % 16); ++i)
+            for (i = 0; i < (num_points % 16); ++i)
                 {
-                    if(src0[i] > max)
+                    if (src0[i] > max)
                         {
                             index = i;
                             max = src0[i];
@@ -530,7 +537,7 @@ static inline void volk_gnsssdr_8i_index_max_16u_a_sse4_1(unsigned int* target,
 
 static inline void volk_gnsssdr_8i_index_max_16u_a_sse2(unsigned int* target, const char* src0, unsigned int num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             const unsigned int sse_iters = num_points / 16;
             unsigned int number;
@@ -540,14 +547,15 @@ static inline void volk_gnsssdr_8i_index_max_16u_a_sse2(unsigned int* target, co
             char max = src0[0];
             unsigned int index = 0;
             unsigned short mask;
-            __VOLK_ATTR_ALIGNED(16) char currentValuesBuffer[16];
+            __VOLK_ATTR_ALIGNED(16)
+            char currentValuesBuffer[16];
             __m128i maxValues, compareResults, currentValues;
 
             maxValues = _mm_set1_epi8(max);
 
-            for(number = 0; number < sse_iters; number++)
+            for (number = 0; number < sse_iters; number++)
                 {
-                    currentValues  = _mm_load_si128((__m128i*)inputPtr);
+                    currentValues = _mm_load_si128((__m128i*)inputPtr);
                     compareResults = _mm_cmpgt_epi8(maxValues, currentValues);
                     mask = _mm_movemask_epi8(compareResults);
 
@@ -560,7 +568,7 @@ static inline void volk_gnsssdr_8i_index_max_16u_a_sse2(unsigned int* target, co
                                 {
                                     if ((mask & 1) == 1)
                                         {
-                                            if(currentValuesBuffer[i] > max)
+                                            if (currentValuesBuffer[i] > max)
                                                 {
                                                     index = inputPtr - basePtr + i;
                                                     max = currentValuesBuffer[i];
@@ -574,9 +582,9 @@ static inline void volk_gnsssdr_8i_index_max_16u_a_sse2(unsigned int* target, co
                     inputPtr += 16;
                 }
 
-            for(i = 0; i<(num_points % 16); ++i)
+            for (i = 0; i < (num_points % 16); ++i)
                 {
-                    if(src0[i] > max)
+                    if (src0[i] > max)
                         {
                             index = i;
                             max = src0[i];

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_8i_max_s8i.h

@@ -63,21 +63,22 @@
 
 static inline void volk_gnsssdr_8i_max_s8i_u_avx2(char* target, const char* src0, unsigned int num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             const unsigned int avx_iters = num_points / 32;
             unsigned int number;
             unsigned int i;
             char* inputPtr = (char*)src0;
             char max = src0[0];
-            __VOLK_ATTR_ALIGNED(32) char maxValuesBuffer[32];
+            __VOLK_ATTR_ALIGNED(32)
+            char maxValuesBuffer[32];
             __m256i maxValues, compareResults, currentValues;
 
             maxValues = _mm256_set1_epi8(max);
 
-            for(number = 0; number < avx_iters; number++)
+            for (number = 0; number < avx_iters; number++)
                 {
-                    currentValues  = _mm256_loadu_si256((__m256i*)inputPtr);
+                    currentValues = _mm256_loadu_si256((__m256i*)inputPtr);
                     compareResults = _mm256_max_epi8(maxValues, currentValues);
                     maxValues = compareResults;
                     inputPtr += 32;
@@ -85,17 +86,17 @@ static inline void volk_gnsssdr_8i_max_s8i_u_avx2(char* target, const char* src0
 
             _mm256_storeu_si256((__m256i*)maxValuesBuffer, maxValues);
 
-            for(i = 0; i < 32; ++i)
+            for (i = 0; i < 32; ++i)
                 {
-                    if(maxValuesBuffer[i] > max)
+                    if (maxValuesBuffer[i] > max)
                         {
                             max = maxValuesBuffer[i];
                         }
                 }
 
-            for(i = avx_iters * 32; i < num_points; ++i)
+            for (i = avx_iters * 32; i < num_points; ++i)
                 {
-                    if(src0[i] > max)
+                    if (src0[i] > max)
                         {
                             max = src0[i];
                         }
@@ -112,21 +113,22 @@ static inline void volk_gnsssdr_8i_max_s8i_u_avx2(char* target, const char* src0
 
 static inline void volk_gnsssdr_8i_max_s8i_u_sse4_1(char* target, const char* src0, unsigned int num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             const unsigned int sse_iters = num_points / 16;
             unsigned int number;
             unsigned int i;
             char* inputPtr = (char*)src0;
             char max = src0[0];
-            __VOLK_ATTR_ALIGNED(16) char maxValuesBuffer[16];
+            __VOLK_ATTR_ALIGNED(16)
+            char maxValuesBuffer[16];
             __m128i maxValues, compareResults, currentValues;
 
             maxValues = _mm_set1_epi8(max);
 
-            for(number = 0; number < sse_iters; number++)
+            for (number = 0; number < sse_iters; number++)
                 {
-                    currentValues  = _mm_loadu_si128((__m128i*)inputPtr);
+                    currentValues = _mm_loadu_si128((__m128i*)inputPtr);
                     compareResults = _mm_cmpgt_epi8(maxValues, currentValues);
                     maxValues = _mm_blendv_epi8(currentValues, maxValues, compareResults);
                     inputPtr += 16;
@@ -134,17 +136,17 @@ static inline void volk_gnsssdr_8i_max_s8i_u_sse4_1(char* target, const char* sr
 
             _mm_storeu_si128((__m128i*)maxValuesBuffer, maxValues);
 
-            for(i = 0; i < 16; ++i)
+            for (i = 0; i < 16; ++i)
                 {
-                    if(maxValuesBuffer[i] > max)
+                    if (maxValuesBuffer[i] > max)
                         {
                             max = maxValuesBuffer[i];
                         }
                 }
 
-            for(i = sse_iters * 16; i < num_points; ++i)
+            for (i = sse_iters * 16; i < num_points; ++i)
                 {
-                    if(src0[i] > max)
+                    if (src0[i] > max)
                         {
                             max = src0[i];
                         }
@@ -157,11 +159,11 @@ static inline void volk_gnsssdr_8i_max_s8i_u_sse4_1(char* target, const char* sr
 
 
 #ifdef LV_HAVE_SSE2
-#include<emmintrin.h>
+#include <emmintrin.h>
 
 static inline void volk_gnsssdr_8i_max_s8i_u_sse2(char* target, const char* src0, unsigned int num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             const unsigned int sse_iters = num_points / 16;
             unsigned int number;
@@ -169,14 +171,15 @@ static inline void volk_gnsssdr_8i_max_s8i_u_sse2(char* target, const char* src0
             char* inputPtr = (char*)src0;
             char max = src0[0];
             unsigned short mask;
-            __VOLK_ATTR_ALIGNED(16) char currentValuesBuffer[16];
+            __VOLK_ATTR_ALIGNED(16)
+            char currentValuesBuffer[16];
             __m128i maxValues, compareResults, currentValues;
 
             maxValues = _mm_set1_epi8(max);
 
-            for(number = 0; number < sse_iters; number++)
+            for (number = 0; number < sse_iters; number++)
                 {
-                    currentValues  = _mm_loadu_si128((__m128i*)inputPtr);
+                    currentValues = _mm_loadu_si128((__m128i*)inputPtr);
                     compareResults = _mm_cmpgt_epi8(maxValues, currentValues);
                     mask = _mm_movemask_epi8(compareResults);
 
@@ -189,7 +192,7 @@ static inline void volk_gnsssdr_8i_max_s8i_u_sse2(char* target, const char* src0
                                 {
                                     if ((mask & 1) == 1)
                                         {
-                                            if(currentValuesBuffer[i] > max)
+                                            if (currentValuesBuffer[i] > max)
                                                 {
                                                     max = currentValuesBuffer[i];
                                                 }
@@ -202,9 +205,9 @@ static inline void volk_gnsssdr_8i_max_s8i_u_sse2(char* target, const char* src0
                     inputPtr += 16;
                 }
 
-            for(i = sse_iters * 16; i < num_points; ++i)
+            for (i = sse_iters * 16; i < num_points; ++i)
                 {
-                    if(src0[i] > max)
+                    if (src0[i] > max)
                         {
                             max = src0[i];
                         }
@@ -220,13 +223,13 @@ static inline void volk_gnsssdr_8i_max_s8i_u_sse2(char* target, const char* src0
 
 static inline void volk_gnsssdr_8i_max_s8i_generic(char* target, const char* src0, unsigned int num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             char max = src0[0];
             unsigned int i;
-            for(i = 1; i < num_points; ++i)
+            for (i = 1; i < num_points; ++i)
                 {
-                    if(src0[i] > max)
+                    if (src0[i] > max)
                         {
                             max = src0[i];
                         }
@@ -243,21 +246,22 @@ static inline void volk_gnsssdr_8i_max_s8i_generic(char* target, const char* src
 
 static inline void volk_gnsssdr_8i_max_s8i_a_sse4_1(char* target, const char* src0, unsigned int num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             const unsigned int sse_iters = num_points / 16;
             unsigned int number;
             unsigned int i;
             char* inputPtr = (char*)src0;
             char max = src0[0];
-            __VOLK_ATTR_ALIGNED(16) char maxValuesBuffer[16];
+            __VOLK_ATTR_ALIGNED(16)
+            char maxValuesBuffer[16];
             __m128i maxValues, compareResults, currentValues;
 
             maxValues = _mm_set1_epi8(max);
 
-            for(number = 0; number < sse_iters; number++)
+            for (number = 0; number < sse_iters; number++)
                 {
-                    currentValues  = _mm_load_si128((__m128i*)inputPtr);
+                    currentValues = _mm_load_si128((__m128i*)inputPtr);
                     compareResults = _mm_cmpgt_epi8(maxValues, currentValues);
                     maxValues = _mm_blendv_epi8(currentValues, maxValues, compareResults);
                     inputPtr += 16;
@@ -265,17 +269,17 @@ static inline void volk_gnsssdr_8i_max_s8i_a_sse4_1(char* target, const char* sr
 
             _mm_store_si128((__m128i*)maxValuesBuffer, maxValues);
 
-            for(i = 0; i < 16; ++i)
+            for (i = 0; i < 16; ++i)
                 {
-                    if(maxValuesBuffer[i] > max)
+                    if (maxValuesBuffer[i] > max)
                         {
                             max = maxValuesBuffer[i];
                         }
                 }
 
-            for(i = sse_iters * 16; i < num_points; ++i)
+            for (i = sse_iters * 16; i < num_points; ++i)
                 {
-                    if(src0[i] > max)
+                    if (src0[i] > max)
                         {
                             max = src0[i];
                         }
@@ -292,39 +296,40 @@ static inline void volk_gnsssdr_8i_max_s8i_a_sse4_1(char* target, const char* sr
 
 static inline void volk_gnsssdr_8i_max_s8i_a_avx2(char* target, const char* src0, unsigned int num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             const unsigned int avx_iters = num_points / 32;
             unsigned int number;
             unsigned int i;
             char* inputPtr = (char*)src0;
             char max = src0[0];
-            __VOLK_ATTR_ALIGNED(32) char maxValuesBuffer[32];
+            __VOLK_ATTR_ALIGNED(32)
+            char maxValuesBuffer[32];
             __m256i maxValues, compareResults, currentValues;
 
             maxValues = _mm256_set1_epi8(max);
 
-            for(number = 0; number < avx_iters; number++)
+            for (number = 0; number < avx_iters; number++)
                 {
-                    currentValues  = _mm256_load_si256((__m256i*)inputPtr);
+                    currentValues = _mm256_load_si256((__m256i*)inputPtr);
                     compareResults = _mm256_max_epi8(maxValues, currentValues);
-                    maxValues = compareResults; //_mm256_blendv_epi8(currentValues, maxValues, compareResults);
+                    maxValues = compareResults;  //_mm256_blendv_epi8(currentValues, maxValues, compareResults);
                     inputPtr += 32;
                 }
 
             _mm256_store_si256((__m256i*)maxValuesBuffer, maxValues);
 
-            for(i = 0; i < 32; ++i)
+            for (i = 0; i < 32; ++i)
                 {
-                    if(maxValuesBuffer[i] > max)
+                    if (maxValuesBuffer[i] > max)
                         {
                             max = maxValuesBuffer[i];
                         }
                 }
 
-            for(i = avx_iters * 32; i < num_points; ++i)
+            for (i = avx_iters * 32; i < num_points; ++i)
                 {
-                    if(src0[i] > max)
+                    if (src0[i] > max)
                         {
                             max = src0[i];
                         }
@@ -341,7 +346,7 @@ static inline void volk_gnsssdr_8i_max_s8i_a_avx2(char* target, const char* src0
 
 static inline void volk_gnsssdr_8i_max_s8i_a_sse2(char* target, const char* src0, unsigned int num_points)
 {
-    if(num_points > 0)
+    if (num_points > 0)
         {
             const unsigned int sse_iters = num_points / 16;
             unsigned int number;
@@ -349,14 +354,15 @@ static inline void volk_gnsssdr_8i_max_s8i_a_sse2(char* target, const char* src0
             char* inputPtr = (char*)src0;
             char max = src0[0];
             unsigned short mask;
-            __VOLK_ATTR_ALIGNED(16) char currentValuesBuffer[16];
+            __VOLK_ATTR_ALIGNED(16)
+            char currentValuesBuffer[16];
             __m128i maxValues, compareResults, currentValues;
 
             maxValues = _mm_set1_epi8(max);
 
-            for(number = 0; number < sse_iters; number++)
+            for (number = 0; number < sse_iters; number++)
                 {
-                    currentValues  = _mm_load_si128((__m128i*)inputPtr);
+                    currentValues = _mm_load_si128((__m128i*)inputPtr);
                     compareResults = _mm_cmpgt_epi8(maxValues, currentValues);
                     mask = _mm_movemask_epi8(compareResults);
 
@@ -369,7 +375,7 @@ static inline void volk_gnsssdr_8i_max_s8i_a_sse2(char* target, const char* src0
                                 {
                                     if ((mask & 1) == 1)
                                         {
-                                            if(currentValuesBuffer[i] > max)
+                                            if (currentValuesBuffer[i] > max)
                                                 {
                                                     max = currentValuesBuffer[i];
                                                 }
@@ -382,9 +388,9 @@ static inline void volk_gnsssdr_8i_max_s8i_a_sse2(char* target, const char* src0
                     inputPtr += 16;
                 }
 
-            for(i = sse_iters * 16; i < num_points; ++i)
+            for (i = sse_iters * 16; i < num_points; ++i)
                 {
-                    if(src0[i] > max)
+                    if (src0[i] > max)
                         {
                             max = src0[i];
                         }

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_8i_x2_add_8i.h

@@ -72,21 +72,21 @@ static inline void volk_gnsssdr_8i_x2_add_8i_u_sse2(char* cVector, const char* a
 
     __m128i aVal, bVal, cVal;
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             aVal = _mm_loadu_si128((__m128i*)aPtr);
             bVal = _mm_loadu_si128((__m128i*)bPtr);
 
             cVal = _mm_add_epi8(aVal, bVal);
 
-            _mm_storeu_si128((__m128i*)cPtr, cVal); // Store the results back into the C container
+            _mm_storeu_si128((__m128i*)cPtr, cVal);  // Store the results back into the C container
 
             aPtr += 16;
             bPtr += 16;
             cPtr += 16;
         }
 
-    for(i = sse_iters * 16; i < num_points; ++i)
+    for (i = sse_iters * 16; i < num_points; ++i)
         {
             *cPtr++ = (*aPtr++) + (*bPtr++);
         }
@@ -108,21 +108,21 @@ static inline void volk_gnsssdr_8i_x2_add_8i_u_avx2(char* cVector, const char* a
 
     __m256i aVal, bVal, cVal;
 
-    for(number = 0; number < avx_iters; number++)
+    for (number = 0; number < avx_iters; number++)
         {
             aVal = _mm256_loadu_si256((__m256i*)aPtr);
             bVal = _mm256_loadu_si256((__m256i*)bPtr);
 
             cVal = _mm256_add_epi8(aVal, bVal);
 
-            _mm256_storeu_si256((__m256i*)cPtr, cVal); // Store the results back into the C container
+            _mm256_storeu_si256((__m256i*)cPtr, cVal);  // Store the results back into the C container
 
             aPtr += 32;
             bPtr += 32;
             cPtr += 32;
         }
 
-    for(i = avx_iters * 32; i < num_points; ++i)
+    for (i = avx_iters * 32; i < num_points; ++i)
         {
             *cPtr++ = (*aPtr++) + (*bPtr++);
         }
@@ -139,7 +139,7 @@ static inline void volk_gnsssdr_8i_x2_add_8i_generic(char* cVector, const char*
     const char* bPtr = bVector;
     unsigned int number;
 
-    for(number = 0; number < num_points; number++)
+    for (number = 0; number < num_points; number++)
         {
             *cPtr++ = (*aPtr++) + (*bPtr++);
         }
@@ -161,21 +161,21 @@ static inline void volk_gnsssdr_8i_x2_add_8i_a_sse2(char* cVector, const char* a
 
     __m128i aVal, bVal, cVal;
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             aVal = _mm_load_si128((__m128i*)aPtr);
             bVal = _mm_load_si128((__m128i*)bPtr);
 
             cVal = _mm_add_epi8(aVal, bVal);
 
-            _mm_store_si128((__m128i*)cPtr, cVal); // Store the results back into the C container
+            _mm_store_si128((__m128i*)cPtr, cVal);  // Store the results back into the C container
 
             aPtr += 16;
             bPtr += 16;
             cPtr += 16;
         }
 
-    for(i = sse_iters * 16; i < num_points; ++i)
+    for (i = sse_iters * 16; i < num_points; ++i)
         {
             *cPtr++ = (*aPtr++) + (*bPtr++);
         }
@@ -197,21 +197,21 @@ static inline void volk_gnsssdr_8i_x2_add_8i_a_avx2(char* cVector, const char* a
 
     __m256i aVal, bVal, cVal;
 
-    for(number = 0; number < avx_iters; number++)
+    for (number = 0; number < avx_iters; number++)
         {
             aVal = _mm256_load_si256((__m256i*)aPtr);
             bVal = _mm256_load_si256((__m256i*)bPtr);
 
             cVal = _mm256_add_epi8(aVal, bVal);
 
-            _mm256_store_si256((__m256i*)cPtr, cVal); // Store the results back into the C container
+            _mm256_store_si256((__m256i*)cPtr, cVal);  // Store the results back into the C container
 
             aPtr += 32;
             bPtr += 32;
             cPtr += 32;
         }
 
-    for(i = avx_iters * 32; i < num_points; ++i)
+    for (i = avx_iters * 32; i < num_points; ++i)
         {
             *cPtr++ = (*aPtr++) + (*bPtr++);
         }

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_8ic_conjugate_8ic.h

@@ -111,10 +111,10 @@ static inline void volk_gnsssdr_8ic_conjugate_8ic_u_avx(lv_8sc_t* cVector, const
             tmp = _mm256_xor_ps(tmp, conjugator1);
             tmp128lo = _mm256_castsi256_si128(_mm256_castps_si256(tmp));
             tmp128lo = _mm_add_epi8(tmp128lo, conjugator2);
-            tmp128hi = _mm256_extractf128_si256(_mm256_castps_si256(tmp),1);
+            tmp128hi = _mm256_extractf128_si256(_mm256_castps_si256(tmp), 1);
             tmp128hi = _mm_add_epi8(tmp128hi, conjugator2);
             //tmp = _mm256_set_m128i(tmp128hi , tmp128lo); //not defined in some versions of immintrin.h
-            tmp = _mm256_castsi256_ps(_mm256_insertf128_si256(_mm256_castsi128_si256(tmp128lo),(tmp128hi),1));
+            tmp = _mm256_castsi256_ps(_mm256_insertf128_si256(_mm256_castsi128_si256(tmp128lo), (tmp128hi), 1));
             _mm256_storeu_ps((float*)c, tmp);
 
             a += 16;
@@ -155,7 +155,6 @@ static inline void volk_gnsssdr_8ic_conjugate_8ic_u_ssse3(lv_8sc_t* cVector, con
         {
             *c++ = lv_conj(*a++);
         }
-
 }
 #endif /* LV_HAVE_SSSE3 */
 
@@ -188,7 +187,6 @@ static inline void volk_gnsssdr_8ic_conjugate_8ic_u_sse3(lv_8sc_t* cVector, cons
         {
             *c++ = lv_conj(*a++);
         }
-
 }
 #endif /* LV_HAVE_SSE3 */
 
@@ -201,7 +199,7 @@ static inline void volk_gnsssdr_8ic_conjugate_8ic_generic(lv_8sc_t* cVector, con
     const lv_8sc_t* aPtr = aVector;
     unsigned int number;
 
-    for(number = 0; number < num_points; number++)
+    for (number = 0; number < num_points; number++)
         {
             *cPtr++ = lv_conj(*aPtr++);
         }
@@ -230,10 +228,10 @@ static inline void volk_gnsssdr_8ic_conjugate_8ic_a_avx(lv_8sc_t* cVector, const
             tmp = _mm256_xor_ps(tmp, conjugator1);
             tmp128lo = _mm256_castsi256_si128(_mm256_castps_si256(tmp));
             tmp128lo = _mm_add_epi8(tmp128lo, conjugator2);
-            tmp128hi = _mm256_extractf128_si256(_mm256_castps_si256(tmp),1);
+            tmp128hi = _mm256_extractf128_si256(_mm256_castps_si256(tmp), 1);
             tmp128hi = _mm_add_epi8(tmp128hi, conjugator2);
             //tmp = _mm256_set_m128i(tmp128hi , tmp128lo); //not defined in some versions of immintrin.h
-            tmp = _mm256_castsi256_ps(_mm256_insertf128_si256(_mm256_castsi128_si256(tmp128lo),(tmp128hi),1));
+            tmp = _mm256_castsi256_ps(_mm256_insertf128_si256(_mm256_castsi128_si256(tmp128lo), (tmp128hi), 1));
             _mm256_store_ps((float*)c, tmp);
 
             a += 16;
@@ -336,7 +334,6 @@ static inline void volk_gnsssdr_8ic_conjugate_8ic_a_sse3(lv_8sc_t* cVector, cons
         {
             *c++ = lv_conj(*a++);
         }
-
 }
 #endif /* LV_HAVE_SSE3 */
 

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_8ic_magnitude_squared_8i.h

@@ -78,23 +78,23 @@ static inline void volk_gnsssdr_8ic_magnitude_squared_8i_u_sse3(char* magnitudeV
     maska = _mm_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0);
     maskb = _mm_set_epi8(14, 12, 10, 8, 6, 4, 2, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             avector = _mm_lddqu_si128((__m128i*)complexVectorPtr);
-            avectorlo = _mm_unpacklo_epi8 (avector, zero);
-            avectorhi = _mm_unpackhi_epi8 (avector, zero);
-            avectorlomult = _mm_mullo_epi16 (avectorlo, avectorlo);
-            avectorhimult = _mm_mullo_epi16 (avectorhi, avectorhi);
-            aadded = _mm_hadd_epi16 (avectorlomult, avectorhimult);
+            avectorlo = _mm_unpacklo_epi8(avector, zero);
+            avectorhi = _mm_unpackhi_epi8(avector, zero);
+            avectorlomult = _mm_mullo_epi16(avectorlo, avectorlo);
+            avectorhimult = _mm_mullo_epi16(avectorhi, avectorhi);
+            aadded = _mm_hadd_epi16(avectorlomult, avectorhimult);
 
             complexVectorPtr += 16;
 
             bvector = _mm_lddqu_si128((__m128i*)complexVectorPtr);
-            bvectorlo = _mm_unpacklo_epi8 (bvector, zero);
-            bvectorhi = _mm_unpackhi_epi8 (bvector, zero);
-            bvectorlomult = _mm_mullo_epi16 (bvectorlo, bvectorlo);
-            bvectorhimult = _mm_mullo_epi16 (bvectorhi, bvectorhi);
-            badded = _mm_hadd_epi16 (bvectorlomult, bvectorhimult);
+            bvectorlo = _mm_unpacklo_epi8(bvector, zero);
+            bvectorhi = _mm_unpackhi_epi8(bvector, zero);
+            bvectorlomult = _mm_mullo_epi16(bvectorlo, bvectorlo);
+            bvectorhimult = _mm_mullo_epi16(bvectorhi, bvectorhi);
+            badded = _mm_hadd_epi16(bvectorlomult, bvectorhimult);
 
             complexVectorPtr += 16;
 
@@ -162,11 +162,11 @@ static inline void volk_gnsssdr_8ic_magnitude_squared_8i_generic(char* magnitude
     const char* complexVectorPtr = (char*)complexVector;
     char* magnitudeVectorPtr = magnitudeVector;
     unsigned int number;
-    for(number = 0; number < num_points; number++)
+    for (number = 0; number < num_points; number++)
         {
             const char real = *complexVectorPtr++;
             const char imag = *complexVectorPtr++;
-            *magnitudeVectorPtr++ = (real*real) + (imag*imag);
+            *magnitudeVectorPtr++ = (real * real) + (imag * imag);
         }
 }
 #endif /* LV_HAVE_GENERIC */
@@ -192,23 +192,23 @@ static inline void volk_gnsssdr_8ic_magnitude_squared_8i_a_sse3(char* magnitudeV
     maska = _mm_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0);
     maskb = _mm_set_epi8(14, 12, 10, 8, 6, 4, 2, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             avector = _mm_load_si128((__m128i*)complexVectorPtr);
-            avectorlo = _mm_unpacklo_epi8 (avector, zero);
-            avectorhi = _mm_unpackhi_epi8 (avector, zero);
-            avectorlomult = _mm_mullo_epi16 (avectorlo, avectorlo);
-            avectorhimult = _mm_mullo_epi16 (avectorhi, avectorhi);
-            aadded = _mm_hadd_epi16 (avectorlomult, avectorhimult);
+            avectorlo = _mm_unpacklo_epi8(avector, zero);
+            avectorhi = _mm_unpackhi_epi8(avector, zero);
+            avectorlomult = _mm_mullo_epi16(avectorlo, avectorlo);
+            avectorhimult = _mm_mullo_epi16(avectorhi, avectorhi);
+            aadded = _mm_hadd_epi16(avectorlomult, avectorhimult);
 
             complexVectorPtr += 16;
 
             bvector = _mm_load_si128((__m128i*)complexVectorPtr);
-            bvectorlo = _mm_unpacklo_epi8 (bvector, zero);
-            bvectorhi = _mm_unpackhi_epi8 (bvector, zero);
-            bvectorlomult = _mm_mullo_epi16 (bvectorlo, bvectorlo);
-            bvectorhimult = _mm_mullo_epi16 (bvectorhi, bvectorhi);
-            badded = _mm_hadd_epi16 (bvectorlomult, bvectorhimult);
+            bvectorlo = _mm_unpacklo_epi8(bvector, zero);
+            bvectorhi = _mm_unpackhi_epi8(bvector, zero);
+            bvectorlomult = _mm_mullo_epi16(bvectorlo, bvectorlo);
+            bvectorhimult = _mm_mullo_epi16(bvectorhi, bvectorhi);
+            badded = _mm_hadd_epi16(bvectorlomult, bvectorhimult);
 
             complexVectorPtr += 16;
 

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_8ic_s8ic_multiply_8ic.h

@@ -80,7 +80,7 @@ static inline void volk_gnsssdr_8ic_s8ic_multiply_8ic_u_sse3(lv_8sc_t* cVector,
     imagy = _mm_and_si128(imagy, mult1);
     realy = _mm_and_si128(y, mult1);
 
-    for(; number < sse_iters; number++)
+    for (; number < sse_iters; number++)
         {
             x = _mm_lddqu_si128((__m128i*)a);
 
@@ -111,7 +111,6 @@ static inline void volk_gnsssdr_8ic_s8ic_multiply_8ic_u_sse3(lv_8sc_t* cVector,
         {
             *c++ = (*a++) * scalar;
         }
-
 }
 #endif /* LV_HAVE_SSE3 */
 
@@ -173,7 +172,7 @@ static inline void volk_gnsssdr_8ic_s8ic_multiply_8ic_a_sse3(lv_8sc_t* cVector,
     imagy = _mm_and_si128(imagy, mult1);
     realy = _mm_and_si128(y, mult1);
 
-    for(; number < sse_iters; number++)
+    for (; number < sse_iters; number++)
         {
             x = _mm_load_si128((__m128i*)a);
 
@@ -204,7 +203,6 @@ static inline void volk_gnsssdr_8ic_s8ic_multiply_8ic_a_sse3(lv_8sc_t* cVector,
         {
             *c++ = (*a++) * scalar;
         }
-
 }
 #endif /* LV_HAVE_SSE3 */
 

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_8ic_x2_dot_prod_8ic.h

@@ -75,17 +75,17 @@ static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_generic(lv_8sc_t* result, co
      *cPtr += (*aPtr++) * (*bPtr++);
      }*/
 
-    char * res = (char*) result;
-    char * in = (char*) in_a;
-    char * tp = (char*) in_b;
-    unsigned int n_2_ccomplex_blocks = num_points/2;
+    char* res = (char*)result;
+    char* in = (char*)in_a;
+    char* tp = (char*)in_b;
+    unsigned int n_2_ccomplex_blocks = num_points / 2;
     unsigned int isodd = num_points & 1;
 
-    char sum0[2] = {0,0};
-    char sum1[2] = {0,0};
+    char sum0[2] = {0, 0};
+    char sum1[2] = {0, 0};
     unsigned int i = 0;
 
-    for(i = 0; i < n_2_ccomplex_blocks; ++i)
+    for (i = 0; i < n_2_ccomplex_blocks; ++i)
         {
             sum0[0] += in[0] * tp[0] - in[1] * tp[1];
             sum0[1] += in[0] * tp[1] + in[1] * tp[0];
@@ -100,7 +100,7 @@ static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_generic(lv_8sc_t* result, co
     res[1] = sum0[1] + sum1[1];
 
     // Cleanup if we had an odd number of points
-    for(i = 0; i < isodd; ++i)
+    for (i = 0; i < isodd; ++i)
         {
             *result += in_a[num_points - 1] * in_b[num_points - 1];
         }
@@ -115,13 +115,13 @@ static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_generic(lv_8sc_t* result, co
 static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_u_sse2(lv_8sc_t* result, const lv_8sc_t* in_a, const lv_8sc_t* in_b, unsigned int num_points)
 {
     lv_8sc_t dotProduct;
-    memset(&dotProduct, 0x0, 2*sizeof(char));
+    memset(&dotProduct, 0x0, 2 * sizeof(char));
     unsigned int number;
     unsigned int i;
     const lv_8sc_t* a = in_a;
     const lv_8sc_t* b = in_b;
 
-    const unsigned int sse_iters = num_points/8;
+    const unsigned int sse_iters = num_points / 8;
 
     if (sse_iters > 0)
         {
@@ -131,7 +131,7 @@ static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_u_sse2(lv_8sc_t* result, con
             realcacc = _mm_setzero_si128();
             imagcacc = _mm_setzero_si128();
 
-            for(number = 0; number < sse_iters; number++)
+            for (number = 0; number < sse_iters; number++)
                 {
                     x = _mm_loadu_si128((__m128i*)a);
                     y = _mm_loadu_si128((__m128i*)b);
@@ -165,9 +165,10 @@ static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_u_sse2(lv_8sc_t* result, con
 
             totalc = _mm_or_si128(realcacc, imagcacc);
 
-            __VOLK_ATTR_ALIGNED(16) lv_8sc_t dotProductVector[8];
+            __VOLK_ATTR_ALIGNED(16)
+            lv_8sc_t dotProductVector[8];
 
-            _mm_storeu_si128((__m128i*)dotProductVector, totalc); // Store the results back into the dot product vector
+            _mm_storeu_si128((__m128i*)dotProductVector, totalc);  // Store the results back into the dot product vector
 
             for (i = 0; i < 8; ++i)
                 {
@@ -192,13 +193,13 @@ static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_u_sse2(lv_8sc_t* result, con
 static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_u_sse4_1(lv_8sc_t* result, const lv_8sc_t* in_a, const lv_8sc_t* in_b, unsigned int num_points)
 {
     lv_8sc_t dotProduct;
-    memset(&dotProduct, 0x0, 2*sizeof(char));
+    memset(&dotProduct, 0x0, 2 * sizeof(char));
     unsigned int number;
     unsigned int i;
     const lv_8sc_t* a = in_a;
     const lv_8sc_t* b = in_b;
 
-    const unsigned int sse_iters = num_points/8;
+    const unsigned int sse_iters = num_points / 8;
 
     if (sse_iters > 0)
         {
@@ -208,7 +209,7 @@ static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_u_sse4_1(lv_8sc_t* result, c
             realcacc = _mm_setzero_si128();
             imagcacc = _mm_setzero_si128();
 
-            for(number = 0; number < sse_iters; number++)
+            for (number = 0; number < sse_iters; number++)
                 {
                     x = _mm_lddqu_si128((__m128i*)a);
                     y = _mm_lddqu_si128((__m128i*)b);
@@ -236,13 +237,14 @@ static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_u_sse4_1(lv_8sc_t* result, c
                     b += 8;
                 }
 
-            imagcacc = _mm_slli_si128 (imagcacc, 1);
+            imagcacc = _mm_slli_si128(imagcacc, 1);
 
-            totalc = _mm_blendv_epi8 (imagcacc, realcacc, mult1);
+            totalc = _mm_blendv_epi8(imagcacc, realcacc, mult1);
 
-            __VOLK_ATTR_ALIGNED(16) lv_8sc_t dotProductVector[8];
+            __VOLK_ATTR_ALIGNED(16)
+            lv_8sc_t dotProductVector[8];
 
-            _mm_storeu_si128((__m128i*)dotProductVector, totalc); // Store the results back into the dot product vector
+            _mm_storeu_si128((__m128i*)dotProductVector, totalc);  // Store the results back into the dot product vector
 
             for (i = 0; i < 8; ++i)
                 {
@@ -267,13 +269,13 @@ static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_u_sse4_1(lv_8sc_t* result, c
 static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_a_sse2(lv_8sc_t* result, const lv_8sc_t* in_a, const lv_8sc_t* in_b, unsigned int num_points)
 {
     lv_8sc_t dotProduct;
-    memset(&dotProduct, 0x0, 2*sizeof(char));
+    memset(&dotProduct, 0x0, 2 * sizeof(char));
     unsigned int number;
     unsigned int i;
     const lv_8sc_t* a = in_a;
     const lv_8sc_t* b = in_b;
 
-    const unsigned int sse_iters = num_points/8;
+    const unsigned int sse_iters = num_points / 8;
 
     if (sse_iters > 0)
         {
@@ -283,7 +285,7 @@ static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_a_sse2(lv_8sc_t* result, con
             realcacc = _mm_setzero_si128();
             imagcacc = _mm_setzero_si128();
 
-            for(number = 0; number < sse_iters; number++)
+            for (number = 0; number < sse_iters; number++)
                 {
                     x = _mm_load_si128((__m128i*)a);
                     y = _mm_load_si128((__m128i*)b);
@@ -317,9 +319,10 @@ static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_a_sse2(lv_8sc_t* result, con
 
             totalc = _mm_or_si128(realcacc, imagcacc);
 
-            __VOLK_ATTR_ALIGNED(16) lv_8sc_t dotProductVector[8];
+            __VOLK_ATTR_ALIGNED(16)
+            lv_8sc_t dotProductVector[8];
 
-            _mm_store_si128((__m128i*)dotProductVector, totalc); // Store the results back into the dot product vector
+            _mm_store_si128((__m128i*)dotProductVector, totalc);  // Store the results back into the dot product vector
 
             for (i = 0; i < 8; ++i)
                 {
@@ -343,7 +346,7 @@ static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_a_sse2(lv_8sc_t* result, con
 static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_a_sse4_1(lv_8sc_t* result, const lv_8sc_t* in_a, const lv_8sc_t* in_b, unsigned int num_points)
 {
     lv_8sc_t dotProduct;
-    memset(&dotProduct, 0x0, 2*sizeof(char));
+    memset(&dotProduct, 0x0, 2 * sizeof(char));
     unsigned int number;
     unsigned int i;
     const lv_8sc_t* a = in_a;
@@ -359,7 +362,7 @@ static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_a_sse4_1(lv_8sc_t* result, c
             realcacc = _mm_setzero_si128();
             imagcacc = _mm_setzero_si128();
 
-            for(number = 0; number < sse_iters; number++)
+            for (number = 0; number < sse_iters; number++)
                 {
                     x = _mm_load_si128((__m128i*)a);
                     y = _mm_load_si128((__m128i*)b);
@@ -387,13 +390,14 @@ static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_a_sse4_1(lv_8sc_t* result, c
                     b += 8;
                 }
 
-            imagcacc = _mm_slli_si128 (imagcacc, 1);
+            imagcacc = _mm_slli_si128(imagcacc, 1);
 
-            totalc = _mm_blendv_epi8 (imagcacc, realcacc, mult1);
+            totalc = _mm_blendv_epi8(imagcacc, realcacc, mult1);
 
-            __VOLK_ATTR_ALIGNED(16) lv_8sc_t dotProductVector[8];
+            __VOLK_ATTR_ALIGNED(16)
+            lv_8sc_t dotProductVector[8];
 
-            _mm_store_si128((__m128i*)dotProductVector, totalc); // Store the results back into the dot product vector
+            _mm_store_si128((__m128i*)dotProductVector, totalc);  // Store the results back into the dot product vector
 
             for (i = 0; i < 8; ++i)
                 {
@@ -438,22 +442,23 @@ static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_u_orc(lv_8sc_t* result, cons
 static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_neon(lv_8sc_t* result, const lv_8sc_t* in_a, const lv_8sc_t* in_b, unsigned int num_points)
 {
     lv_8sc_t dotProduct;
-    dotProduct = lv_cmake(0,0);
-    *result = lv_cmake(0,0);
+    dotProduct = lv_cmake(0, 0);
+    *result = lv_cmake(0, 0);
 
     const lv_8sc_t* a = in_a;
     const lv_8sc_t* b = in_b;
     // for 2-lane vectors, 1st lane holds the real part,
     // 2nd lane holds the imaginary part
     int8x8x2_t a_val, b_val, c_val, accumulator, tmp_real, tmp_imag;
-    __VOLK_ATTR_ALIGNED(16) lv_8sc_t accum_result[8] = { lv_cmake(0,0) };
+    __VOLK_ATTR_ALIGNED(16)
+    lv_8sc_t accum_result[8] = {lv_cmake(0, 0)};
     accumulator.val[0] = vdup_n_s8(0);
     accumulator.val[1] = vdup_n_s8(0);
     unsigned int number;
 
     const unsigned int neon_iters = num_points / 8;
 
-    for(number = 0; number < neon_iters; ++number)
+    for (number = 0; number < neon_iters; ++number)
         {
             a_val = vld2_s8((const int8_t*)a);
             b_val = vld2_s8((const int8_t*)b);
@@ -478,7 +483,7 @@ static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_neon(lv_8sc_t* result, const
             b += 8;
         }
     vst2_s8((int8_t*)accum_result, accumulator);
-    for(number = 0; number < 8; ++number)
+    for (number = 0; number < 8; ++number)
         {
             *result += accum_result[number];
         }
@@ -490,6 +495,6 @@ static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_neon(lv_8sc_t* result, const
 
     *result += dotProduct;
 }
-#endif  /* LV_HAVE_NEON */
+#endif /* LV_HAVE_NEON */
 
 #endif /*INCLUDED_volk_gnsssdr_8ic_x2_dot_prod_8ic_H*/

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_8ic_x2_multiply_8ic.h

@@ -75,7 +75,7 @@ static inline void volk_gnsssdr_8ic_x2_multiply_8ic_u_sse2(lv_8sc_t* cVector, co
 
     mult1 = _mm_set_epi8(0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF);
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             x = _mm_loadu_si128((__m128i*)a);
             y = _mm_loadu_si128((__m128i*)b);
@@ -133,7 +133,7 @@ static inline void volk_gnsssdr_8ic_x2_multiply_8ic_u_sse4_1(lv_8sc_t* cVector,
     _mm_setzero_si128();
     mult1 = _mm_set_epi8(0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF);
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             x = _mm_lddqu_si128((__m128i*)a);
             y = _mm_lddqu_si128((__m128i*)b);
@@ -181,7 +181,7 @@ static inline void volk_gnsssdr_8ic_x2_multiply_8ic_generic(lv_8sc_t* cVector, c
     const lv_8sc_t* bPtr = bVector;
     unsigned int number;
 
-    for(number = 0; number < num_points; number++)
+    for (number = 0; number < num_points; number++)
         {
             *cPtr++ = (*aPtr++) * (*bPtr++);
         }
@@ -204,7 +204,7 @@ static inline void volk_gnsssdr_8ic_x2_multiply_8ic_a_sse2(lv_8sc_t* cVector, co
 
     mult1 = _mm_set_epi8(0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF);
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             x = _mm_load_si128((__m128i*)a);
             y = _mm_load_si128((__m128i*)b);
@@ -228,7 +228,7 @@ static inline void volk_gnsssdr_8ic_x2_multiply_8ic_a_sse2(lv_8sc_t* cVector, co
             imagc = _mm_and_si128(imagc, mult1);
             imagc = _mm_slli_si128(imagc, 1);
 
-            totalc = _mm_or_si128 (realc, imagc);
+            totalc = _mm_or_si128(realc, imagc);
 
             _mm_store_si128((__m128i*)c, totalc);
 
@@ -262,7 +262,7 @@ static inline void volk_gnsssdr_8ic_x2_multiply_8ic_a_sse4_1(lv_8sc_t* cVector,
     _mm_setzero_si128();
     mult1 = _mm_set_epi8(0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF);
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             x = _mm_load_si128((__m128i*)a);
             y = _mm_load_si128((__m128i*)b);

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_8u_x2_multiply_8u.h

@@ -72,7 +72,7 @@ static inline void volk_gnsssdr_8u_x2_multiply_8u_u_avx2(unsigned char* cChar, c
     const unsigned char* a = aChar;
     const unsigned char* b = bChar;
 
-    for(number = 0; number < avx2_iters; number++)
+    for (number = 0; number < avx2_iters; number++)
         {
             x = _mm256_loadu_si256((__m256i*)a);
             y = _mm256_loadu_si256((__m256i*)b);
@@ -101,7 +101,7 @@ static inline void volk_gnsssdr_8u_x2_multiply_8u_u_avx2(unsigned char* cChar, c
             c += 32;
         }
 
-    for (i = avx2_iters * 32; i < num_points ; ++i)
+    for (i = avx2_iters * 32; i < num_points; ++i)
         {
             *c++ = (*a++) * (*b++);
         }
@@ -123,7 +123,7 @@ static inline void volk_gnsssdr_8u_x2_multiply_8u_u_sse3(unsigned char* cChar, c
     const unsigned char* a = aChar;
     const unsigned char* b = bChar;
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             x = _mm_lddqu_si128((__m128i*)a);
             y = _mm_lddqu_si128((__m128i*)b);
@@ -152,7 +152,7 @@ static inline void volk_gnsssdr_8u_x2_multiply_8u_u_sse3(unsigned char* cChar, c
             c += 16;
         }
 
-    for (i = sse_iters * 16; i < num_points ; ++i)
+    for (i = sse_iters * 16; i < num_points; ++i)
         {
             *c++ = (*a++) * (*b++);
         }
@@ -168,7 +168,7 @@ static inline void volk_gnsssdr_8u_x2_multiply_8u_generic(unsigned char* cChar,
     const unsigned char* bPtr = bChar;
     unsigned int number;
 
-    for(number = 0; number < num_points; number++)
+    for (number = 0; number < num_points; number++)
         {
             *cPtr++ = (*aPtr++) * (*bPtr++);
         }
@@ -189,7 +189,7 @@ static inline void volk_gnsssdr_8u_x2_multiply_8u_a_sse3(unsigned char* cChar, c
     const unsigned char* a = aChar;
     const unsigned char* b = bChar;
 
-    for(number = 0; number < sse_iters; number++)
+    for (number = 0; number < sse_iters; number++)
         {
             x = _mm_load_si128((__m128i*)a);
             y = _mm_load_si128((__m128i*)b);
@@ -240,7 +240,7 @@ static inline void volk_gnsssdr_8u_x2_multiply_8u_a_avx2(unsigned char* cChar, c
     const unsigned char* a = aChar;
     const unsigned char* b = bChar;
 
-    for(number = 0; number < avx2_iters; number++)
+    for (number = 0; number < avx2_iters; number++)
         {
             x = _mm256_load_si256((__m256i*)a);
             y = _mm256_load_si256((__m256i*)b);
@@ -269,7 +269,7 @@ static inline void volk_gnsssdr_8u_x2_multiply_8u_a_avx2(unsigned char* cChar, c
             c += 32;
         }
 
-    for (i = avx2_iters * 32; i < num_points ; ++i)
+    for (i = avx2_iters * 32; i < num_points; ++i)
         {
             *c++ = (*a++) * (*b++);
         }

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_s32f_sincos_32fc.h

@@ -71,9 +71,9 @@
 #include <emmintrin.h>
 /* Adapted from http://gruntthepeon.free.fr/ssemath/sse_mathfun.h, original code from Julien Pommier  */
 /* Based on algorithms from the cephes library http://www.netlib.org/cephes/   */
-static inline void volk_gnsssdr_s32f_sincos_32fc_a_sse2(lv_32fc_t* out, const float phase_inc, float* phase, unsigned int num_points)
+static inline void volk_gnsssdr_s32f_sincos_32fc_a_sse2(lv_32fc_t *out, const float phase_inc, float *phase, unsigned int num_points)
 {
-    lv_32fc_t* bPtr = out;
+    lv_32fc_t *bPtr = out;
 
     const unsigned int sse_iters = num_points / 4;
     unsigned int number = 0;
@@ -84,44 +84,44 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_a_sse2(lv_32fc_t* out, const fl
     __m128i emm0, emm2, emm4;
 
     /* declare some SSE constants */
-    static const int _ps_inv_sign_mask[4] = { ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000 };
-    static const int _ps_sign_mask[4] = { (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000 };
+    static const int _ps_inv_sign_mask[4] = {~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000};
+    static const int _ps_sign_mask[4] = {(int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000};
 
-    static const float _ps_cephes_FOPI[4] = { 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516 };
-    static const int _pi32_1[4]  = { 1, 1, 1, 1 };
-    static const int _pi32_inv1[4]  = { ~1, ~1, ~1, ~1 };
-    static const int _pi32_2[4]  = { 2, 2, 2, 2};
-    static const int _pi32_4[4]  = { 4, 4, 4, 4};
+    static const float _ps_cephes_FOPI[4] = {1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516};
+    static const int _pi32_1[4] = {1, 1, 1, 1};
+    static const int _pi32_inv1[4] = {~1, ~1, ~1, ~1};
+    static const int _pi32_2[4] = {2, 2, 2, 2};
+    static const int _pi32_4[4] = {4, 4, 4, 4};
 
-    static const float _ps_minus_cephes_DP1[4] = { -0.78515625, -0.78515625, -0.78515625, -0.78515625 };
-    static const float _ps_minus_cephes_DP2[4] = { -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4 };
-    static const float _ps_minus_cephes_DP3[4] = { -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8 };
-    static const float _ps_coscof_p0[4] = { 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005 };
-    static const float _ps_coscof_p1[4] = { -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003 };
-    static const float _ps_coscof_p2[4] = { 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002 };
-    static const float _ps_sincof_p0[4] = { -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4 };
-    static const float _ps_sincof_p1[4] = { 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3 };
-    static const float _ps_sincof_p2[4] = { -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1 };
-    static const float _ps_0p5[4] = { 0.5f, 0.5f, 0.5f, 0.5f };
-    static const float _ps_1[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
+    static const float _ps_minus_cephes_DP1[4] = {-0.78515625, -0.78515625, -0.78515625, -0.78515625};
+    static const float _ps_minus_cephes_DP2[4] = {-2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4};
+    static const float _ps_minus_cephes_DP3[4] = {-3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8};
+    static const float _ps_coscof_p0[4] = {2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005};
+    static const float _ps_coscof_p1[4] = {-1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003};
+    static const float _ps_coscof_p2[4] = {4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002};
+    static const float _ps_sincof_p0[4] = {-1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4};
+    static const float _ps_sincof_p1[4] = {8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3};
+    static const float _ps_sincof_p2[4] = {-1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1};
+    static const float _ps_0p5[4] = {0.5f, 0.5f, 0.5f, 0.5f};
+    static const float _ps_1[4] = {1.0f, 1.0f, 1.0f, 1.0f};
 
-    float four_phases[4] = { _phase, _phase + phase_inc, _phase + 2 * phase_inc, _phase + 3 * phase_inc };
-    float four_phases_inc[4] = { 4 * phase_inc, 4 * phase_inc, 4 * phase_inc, 4 * phase_inc };
+    float four_phases[4] = {_phase, _phase + phase_inc, _phase + 2 * phase_inc, _phase + 3 * phase_inc};
+    float four_phases_inc[4] = {4 * phase_inc, 4 * phase_inc, 4 * phase_inc, 4 * phase_inc};
     four_phases_reg = _mm_load_ps(four_phases);
     const __m128 four_phases_inc_reg = _mm_load_ps(four_phases_inc);
 
-    for(;number < sse_iters; number++)
+    for (; number < sse_iters; number++)
         {
             x = four_phases_reg;
 
             sign_bit_sin = x;
             /* take the absolute value */
-            x = _mm_and_ps(x, *(__m128*)_ps_inv_sign_mask);
+            x = _mm_and_ps(x, *(__m128 *)_ps_inv_sign_mask);
             /* extract the sign bit (upper one) */
-            sign_bit_sin = _mm_and_ps(sign_bit_sin, *(__m128*)_ps_sign_mask);
+            sign_bit_sin = _mm_and_ps(sign_bit_sin, *(__m128 *)_ps_sign_mask);
 
             /* scale by 4/Pi */
-            y = _mm_mul_ps(x, *(__m128*)_ps_cephes_FOPI);
+            y = _mm_mul_ps(x, *(__m128 *)_ps_cephes_FOPI);
 
             /* store the integer part of y in emm2 */
             emm2 = _mm_cvttps_epi32(y);
@@ -145,9 +145,9 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_a_sse2(lv_32fc_t* out, const fl
 
             /* The magic pass: "Extended precision modular arithmetic”
                x = ((x - y * DP1) - y * DP2) - y * DP3; */
-            xmm1 = *(__m128*)_ps_minus_cephes_DP1;
-            xmm2 = *(__m128*)_ps_minus_cephes_DP2;
-            xmm3 = *(__m128*)_ps_minus_cephes_DP3;
+            xmm1 = *(__m128 *)_ps_minus_cephes_DP1;
+            xmm2 = *(__m128 *)_ps_minus_cephes_DP2;
+            xmm3 = *(__m128 *)_ps_minus_cephes_DP3;
             xmm1 = _mm_mul_ps(y, xmm1);
             xmm2 = _mm_mul_ps(y, xmm2);
             xmm3 = _mm_mul_ps(y, xmm3);
@@ -163,25 +163,25 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_a_sse2(lv_32fc_t* out, const fl
             sign_bit_sin = _mm_xor_ps(sign_bit_sin, swap_sign_bit_sin);
 
             /* Evaluate the first polynom  (0 <= x <= Pi/4) */
-            __m128 z = _mm_mul_ps(x,x);
-            y = *(__m128*)_ps_coscof_p0;
+            __m128 z = _mm_mul_ps(x, x);
+            y = *(__m128 *)_ps_coscof_p0;
 
             y = _mm_mul_ps(y, z);
-            y = _mm_add_ps(y, *(__m128*)_ps_coscof_p1);
+            y = _mm_add_ps(y, *(__m128 *)_ps_coscof_p1);
             y = _mm_mul_ps(y, z);
-            y = _mm_add_ps(y, *(__m128*)_ps_coscof_p2);
+            y = _mm_add_ps(y, *(__m128 *)_ps_coscof_p2);
             y = _mm_mul_ps(y, z);
             y = _mm_mul_ps(y, z);
-            __m128 tmp = _mm_mul_ps(z, *(__m128*)_ps_0p5);
+            __m128 tmp = _mm_mul_ps(z, *(__m128 *)_ps_0p5);
             y = _mm_sub_ps(y, tmp);
-            y = _mm_add_ps(y, *(__m128*)_ps_1);
+            y = _mm_add_ps(y, *(__m128 *)_ps_1);
 
             /* Evaluate the second polynom  (Pi/4 <= x <= 0) */
-            __m128 y2 = *(__m128*)_ps_sincof_p0;
+            __m128 y2 = *(__m128 *)_ps_sincof_p0;
             y2 = _mm_mul_ps(y2, z);
-            y2 = _mm_add_ps(y2, *(__m128*)_ps_sincof_p1);
+            y2 = _mm_add_ps(y2, *(__m128 *)_ps_sincof_p1);
             y2 = _mm_mul_ps(y2, z);
-            y2 = _mm_add_ps(y2, *(__m128*)_ps_sincof_p2);
+            y2 = _mm_add_ps(y2, *(__m128 *)_ps_sincof_p2);
             y2 = _mm_mul_ps(y2, z);
             y2 = _mm_mul_ps(y2, x);
             y2 = _mm_add_ps(y2, x);
@@ -190,11 +190,11 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_a_sse2(lv_32fc_t* out, const fl
             xmm3 = poly_mask;
             __m128 ysin2 = _mm_and_ps(xmm3, y2);
             __m128 ysin1 = _mm_andnot_ps(xmm3, y);
-            y2 = _mm_sub_ps(y2,ysin2);
+            y2 = _mm_sub_ps(y2, ysin2);
             y = _mm_sub_ps(y, ysin1);
 
-            xmm1 = _mm_add_ps(ysin1,ysin2);
-            xmm2 = _mm_add_ps(y,y2);
+            xmm1 = _mm_add_ps(ysin1, ysin2);
+            xmm2 = _mm_add_ps(y, y2);
 
             /* update the sign */
             sine = _mm_xor_ps(xmm1, sign_bit_sin);
@@ -202,19 +202,19 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_a_sse2(lv_32fc_t* out, const fl
 
             /* write the output */
             aux = _mm_unpacklo_ps(cosine, sine);
-            _mm_store_ps((float*)bPtr, aux);
+            _mm_store_ps((float *)bPtr, aux);
             bPtr += 2;
             aux = _mm_unpackhi_ps(cosine, sine);
-            _mm_store_ps((float*)bPtr, aux);
+            _mm_store_ps((float *)bPtr, aux);
             bPtr += 2;
 
             four_phases_reg = _mm_add_ps(four_phases_reg, four_phases_inc_reg);
         }
 
     _phase = _phase + phase_inc * (sse_iters * 4);
-    for(number = sse_iters * 4; number < num_points; number++)
+    for (number = sse_iters * 4; number < num_points; number++)
         {
-            *bPtr++ = lv_cmake((float)cosf((_phase)), (float)sinf((_phase)) );
+            *bPtr++ = lv_cmake((float)cosf((_phase)), (float)sinf((_phase)));
             _phase += phase_inc;
         }
     (*phase) = _phase;
@@ -227,9 +227,9 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_a_sse2(lv_32fc_t* out, const fl
 #include <emmintrin.h>
 /* Adapted from http://gruntthepeon.free.fr/ssemath/sse_mathfun.h, original code from Julien Pommier  */
 /* Based on algorithms from the cephes library http://www.netlib.org/cephes/   */
-static inline void volk_gnsssdr_s32f_sincos_32fc_u_sse2(lv_32fc_t* out, const float phase_inc, float* phase, unsigned int num_points)
+static inline void volk_gnsssdr_s32f_sincos_32fc_u_sse2(lv_32fc_t *out, const float phase_inc, float *phase, unsigned int num_points)
 {
-    lv_32fc_t* bPtr = out;
+    lv_32fc_t *bPtr = out;
 
     const unsigned int sse_iters = num_points / 4;
     unsigned int number = 0;
@@ -241,44 +241,64 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_u_sse2(lv_32fc_t* out, const fl
     __m128i emm0, emm2, emm4;
 
     /* declare some SSE constants */
-    __VOLK_ATTR_ALIGNED(16) static const int _ps_inv_sign_mask[4] = { ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000 };
-    __VOLK_ATTR_ALIGNED(16) static const int _ps_sign_mask[4] = { (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000 };
+    __VOLK_ATTR_ALIGNED(16)
+    static const int _ps_inv_sign_mask[4] = {~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000};
+    __VOLK_ATTR_ALIGNED(16)
+    static const int _ps_sign_mask[4] = {(int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000};
 
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_cephes_FOPI[4] = { 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516 };
-    __VOLK_ATTR_ALIGNED(16) static const int _pi32_1[4]  = { 1, 1, 1, 1 };
-    __VOLK_ATTR_ALIGNED(16) static const int _pi32_inv1[4]  = { ~1, ~1, ~1, ~1 };
-    __VOLK_ATTR_ALIGNED(16) static const int _pi32_2[4]  = { 2, 2, 2, 2};
-    __VOLK_ATTR_ALIGNED(16) static const int _pi32_4[4]  = { 4, 4, 4, 4};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_cephes_FOPI[4] = {1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516};
+    __VOLK_ATTR_ALIGNED(16)
+    static const int _pi32_1[4] = {1, 1, 1, 1};
+    __VOLK_ATTR_ALIGNED(16)
+    static const int _pi32_inv1[4] = {~1, ~1, ~1, ~1};
+    __VOLK_ATTR_ALIGNED(16)
+    static const int _pi32_2[4] = {2, 2, 2, 2};
+    __VOLK_ATTR_ALIGNED(16)
+    static const int _pi32_4[4] = {4, 4, 4, 4};
 
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_minus_cephes_DP1[4] = { -0.78515625, -0.78515625, -0.78515625, -0.78515625 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_minus_cephes_DP2[4] = { -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_minus_cephes_DP3[4] = { -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_coscof_p0[4] = { 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_coscof_p1[4] = { -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_coscof_p2[4] = { 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_sincof_p0[4] = { -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_sincof_p1[4] = { 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_sincof_p2[4] = { -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1 };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_0p5[4] = { 0.5f, 0.5f, 0.5f, 0.5f };
-    __VOLK_ATTR_ALIGNED(16) static const float _ps_1[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_minus_cephes_DP1[4] = {-0.78515625, -0.78515625, -0.78515625, -0.78515625};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_minus_cephes_DP2[4] = {-2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_minus_cephes_DP3[4] = {-3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_coscof_p0[4] = {2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_coscof_p1[4] = {-1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_coscof_p2[4] = {4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_sincof_p0[4] = {-1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_sincof_p1[4] = {8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_sincof_p2[4] = {-1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_0p5[4] = {0.5f, 0.5f, 0.5f, 0.5f};
+    __VOLK_ATTR_ALIGNED(16)
+    static const float _ps_1[4] = {1.0f, 1.0f, 1.0f, 1.0f};
 
-    __VOLK_ATTR_ALIGNED(16) float four_phases[4] = { _phase, _phase + phase_inc, _phase + 2 * phase_inc, _phase + 3 * phase_inc };
-    __VOLK_ATTR_ALIGNED(16) float four_phases_inc[4] = { 4 * phase_inc, 4 * phase_inc, 4 * phase_inc, 4 * phase_inc };
+    __VOLK_ATTR_ALIGNED(16)
+    float four_phases[4] = {_phase, _phase + phase_inc, _phase + 2 * phase_inc, _phase + 3 * phase_inc};
+    __VOLK_ATTR_ALIGNED(16)
+    float four_phases_inc[4] = {4 * phase_inc, 4 * phase_inc, 4 * phase_inc, 4 * phase_inc};
     four_phases_reg = _mm_load_ps(four_phases);
     const __m128 four_phases_inc_reg = _mm_load_ps(four_phases_inc);
 
-    for(;number < sse_iters; number++)
+    for (; number < sse_iters; number++)
         {
             x = four_phases_reg;
 
             sign_bit_sin = x;
             /* take the absolute value */
-            x = _mm_and_ps(x, *(__m128*)_ps_inv_sign_mask);
+            x = _mm_and_ps(x, *(__m128 *)_ps_inv_sign_mask);
             /* extract the sign bit (upper one) */
-            sign_bit_sin = _mm_and_ps(sign_bit_sin, *(__m128*)_ps_sign_mask);
+            sign_bit_sin = _mm_and_ps(sign_bit_sin, *(__m128 *)_ps_sign_mask);
 
             /* scale by 4/Pi */
-            y = _mm_mul_ps(x, *(__m128*)_ps_cephes_FOPI);
+            y = _mm_mul_ps(x, *(__m128 *)_ps_cephes_FOPI);
 
             /* store the integer part of y in emm2 */
             emm2 = _mm_cvttps_epi32(y);
@@ -302,9 +322,9 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_u_sse2(lv_32fc_t* out, const fl
 
             /* The magic pass: "Extended precision modular arithmetic”
                x = ((x - y * DP1) - y * DP2) - y * DP3; */
-            xmm1 = *(__m128*)_ps_minus_cephes_DP1;
-            xmm2 = *(__m128*)_ps_minus_cephes_DP2;
-            xmm3 = *(__m128*)_ps_minus_cephes_DP3;
+            xmm1 = *(__m128 *)_ps_minus_cephes_DP1;
+            xmm2 = *(__m128 *)_ps_minus_cephes_DP2;
+            xmm3 = *(__m128 *)_ps_minus_cephes_DP3;
             xmm1 = _mm_mul_ps(y, xmm1);
             xmm2 = _mm_mul_ps(y, xmm2);
             xmm3 = _mm_mul_ps(y, xmm3);
@@ -320,25 +340,25 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_u_sse2(lv_32fc_t* out, const fl
             sign_bit_sin = _mm_xor_ps(sign_bit_sin, swap_sign_bit_sin);
 
             /* Evaluate the first polynom  (0 <= x <= Pi/4) */
-            __m128 z = _mm_mul_ps(x,x);
-            y = *(__m128*)_ps_coscof_p0;
+            __m128 z = _mm_mul_ps(x, x);
+            y = *(__m128 *)_ps_coscof_p0;
 
             y = _mm_mul_ps(y, z);
-            y = _mm_add_ps(y, *(__m128*)_ps_coscof_p1);
+            y = _mm_add_ps(y, *(__m128 *)_ps_coscof_p1);
             y = _mm_mul_ps(y, z);
-            y = _mm_add_ps(y, *(__m128*)_ps_coscof_p2);
+            y = _mm_add_ps(y, *(__m128 *)_ps_coscof_p2);
             y = _mm_mul_ps(y, z);
             y = _mm_mul_ps(y, z);
-            __m128 tmp = _mm_mul_ps(z, *(__m128*)_ps_0p5);
+            __m128 tmp = _mm_mul_ps(z, *(__m128 *)_ps_0p5);
             y = _mm_sub_ps(y, tmp);
-            y = _mm_add_ps(y, *(__m128*)_ps_1);
+            y = _mm_add_ps(y, *(__m128 *)_ps_1);
 
             /* Evaluate the second polynom  (Pi/4 <= x <= 0) */
-            __m128 y2 = *(__m128*)_ps_sincof_p0;
+            __m128 y2 = *(__m128 *)_ps_sincof_p0;
             y2 = _mm_mul_ps(y2, z);
-            y2 = _mm_add_ps(y2, *(__m128*)_ps_sincof_p1);
+            y2 = _mm_add_ps(y2, *(__m128 *)_ps_sincof_p1);
             y2 = _mm_mul_ps(y2, z);
-            y2 = _mm_add_ps(y2, *(__m128*)_ps_sincof_p2);
+            y2 = _mm_add_ps(y2, *(__m128 *)_ps_sincof_p2);
             y2 = _mm_mul_ps(y2, z);
             y2 = _mm_mul_ps(y2, x);
             y2 = _mm_add_ps(y2, x);
@@ -347,11 +367,11 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_u_sse2(lv_32fc_t* out, const fl
             xmm3 = poly_mask;
             __m128 ysin2 = _mm_and_ps(xmm3, y2);
             __m128 ysin1 = _mm_andnot_ps(xmm3, y);
-            y2 = _mm_sub_ps(y2,ysin2);
+            y2 = _mm_sub_ps(y2, ysin2);
             y = _mm_sub_ps(y, ysin1);
 
-            xmm1 = _mm_add_ps(ysin1,ysin2);
-            xmm2 = _mm_add_ps(y,y2);
+            xmm1 = _mm_add_ps(ysin1, ysin2);
+            xmm2 = _mm_add_ps(y, y2);
 
             /* update the sign */
             sine = _mm_xor_ps(xmm1, sign_bit_sin);
@@ -359,19 +379,19 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_u_sse2(lv_32fc_t* out, const fl
 
             /* write the output */
             aux = _mm_unpacklo_ps(cosine, sine);
-            _mm_storeu_ps((float*)bPtr, aux);
+            _mm_storeu_ps((float *)bPtr, aux);
             bPtr += 2;
             aux = _mm_unpackhi_ps(cosine, sine);
-            _mm_storeu_ps((float*)bPtr, aux);
+            _mm_storeu_ps((float *)bPtr, aux);
             bPtr += 2;
 
             four_phases_reg = _mm_add_ps(four_phases_reg, four_phases_inc_reg);
         }
 
     _phase = _phase + phase_inc * (sse_iters * 4);
-    for(number = sse_iters * 4; number < num_points; number++)
+    for (number = sse_iters * 4; number < num_points; number++)
         {
-            *bPtr++ = lv_cmake((float)cosf(_phase), (float)sinf(_phase) );
+            *bPtr++ = lv_cmake((float)cosf(_phase), (float)sinf(_phase));
             _phase += phase_inc;
         }
     (*phase) = _phase;
@@ -382,13 +402,13 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_u_sse2(lv_32fc_t* out, const fl
 
 #ifdef LV_HAVE_GENERIC
 
-static inline void volk_gnsssdr_s32f_sincos_32fc_generic(lv_32fc_t* out, const float phase_inc, float* phase, unsigned int num_points)
+static inline void volk_gnsssdr_s32f_sincos_32fc_generic(lv_32fc_t *out, const float phase_inc, float *phase, unsigned int num_points)
 {
     float _phase = (*phase);
     unsigned int i;
-    for(i = 0; i < num_points; i++)
+    for (i = 0; i < num_points; i++)
         {
-            *out++ = lv_cmake((float)cosf(_phase), (float)sinf(_phase) );
+            *out++ = lv_cmake((float)cosf(_phase), (float)sinf(_phase));
             _phase += phase_inc;
         }
     (*phase) = _phase;
@@ -400,7 +420,7 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_generic(lv_32fc_t* out, const f
 #ifdef LV_HAVE_GENERIC
 #include <volk_gnsssdr/volk_gnsssdr_sine_table.h>
 #include <stdint.h>
-static inline void volk_gnsssdr_s32f_sincos_32fc_generic_fxpt(lv_32fc_t* out, const float phase_inc, float* phase, unsigned int num_points)
+static inline void volk_gnsssdr_s32f_sincos_32fc_generic_fxpt(lv_32fc_t *out, const float phase_inc, float *phase, unsigned int num_points)
 {
     float _in, s, c;
     unsigned int i;
@@ -413,12 +433,12 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_generic_fxpt(lv_32fc_t* out, co
     const int32_t diffbits = bitlength - Nbits;
     uint32_t ux;
     float _phase = (*phase);
-    for(i = 0; i < num_points; i++)
+    for (i = 0; i < num_points; i++)
         {
             _in = _phase;
             d = (int32_t)floor(_in / TWO_PI + 0.5);
             _in -= d * TWO_PI;
-            x = (int32_t) ((float)_in * TWO_TO_THE_31_DIV_PI);
+            x = (int32_t)((float)_in * TWO_TO_THE_31_DIV_PI);
 
             ux = x;
             sin_index = ux >> diffbits;
@@ -428,7 +448,7 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_generic_fxpt(lv_32fc_t* out, co
             cos_index = ux >> diffbits;
             c = sine_table_10bits[cos_index][0] * (ux >> 1) + sine_table_10bits[cos_index][1];
 
-            *out++ = lv_cmake((float)c, (float)s );
+            *out++ = lv_cmake((float)c, (float)s);
             _phase += phase_inc;
         }
     (*phase) = _phase;
@@ -441,9 +461,9 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_generic_fxpt(lv_32fc_t* out, co
 #include <immintrin.h>
 /* Based on algorithms from the cephes library http://www.netlib.org/cephes/
  * Adapted to AVX2 by Carles Fernandez, based on original SSE2 code by Julien Pommier*/
-static inline void volk_gnsssdr_s32f_sincos_32fc_a_avx2(lv_32fc_t* out, const float phase_inc, float* phase, unsigned int num_points)
+static inline void volk_gnsssdr_s32f_sincos_32fc_a_avx2(lv_32fc_t *out, const float phase_inc, float *phase, unsigned int num_points)
 {
-    lv_32fc_t* bPtr = out;
+    lv_32fc_t *bPtr = out;
 
     const unsigned int avx_iters = num_points / 8;
     unsigned int number = 0;
@@ -456,44 +476,64 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_a_avx2(lv_32fc_t* out, const fl
     __m128 aux, c1, s1;
 
     /* declare some AXX2 constants */
-    __VOLK_ATTR_ALIGNED(32) static const int _ps_inv_sign_mask[8] = { ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000 };
-    __VOLK_ATTR_ALIGNED(32) static const int _ps_sign_mask[8] = { (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000 };
+    __VOLK_ATTR_ALIGNED(32)
+    static const int _ps_inv_sign_mask[8] = {~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000};
+    __VOLK_ATTR_ALIGNED(32)
+    static const int _ps_sign_mask[8] = {(int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000};
 
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_cephes_FOPI[8] = { 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516 };
-    __VOLK_ATTR_ALIGNED(32) static const int _pi32_1[8]  = { 1, 1, 1, 1, 1, 1, 1, 1 };
-    __VOLK_ATTR_ALIGNED(32) static const int _pi32_inv1[8]  = { ~1, ~1, ~1, ~1, ~1, ~1, ~1, ~1 };
-    __VOLK_ATTR_ALIGNED(32) static const int _pi32_2[8]  = { 2, 2, 2, 2, 2, 2, 2, 2 };
-    __VOLK_ATTR_ALIGNED(32) static const int _pi32_4[8]  = { 4, 4, 4, 4, 4, 4, 4, 4 };
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_cephes_FOPI[8] = {1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516};
+    __VOLK_ATTR_ALIGNED(32)
+    static const int _pi32_1[8] = {1, 1, 1, 1, 1, 1, 1, 1};
+    __VOLK_ATTR_ALIGNED(32)
+    static const int _pi32_inv1[8] = {~1, ~1, ~1, ~1, ~1, ~1, ~1, ~1};
+    __VOLK_ATTR_ALIGNED(32)
+    static const int _pi32_2[8] = {2, 2, 2, 2, 2, 2, 2, 2};
+    __VOLK_ATTR_ALIGNED(32)
+    static const int _pi32_4[8] = {4, 4, 4, 4, 4, 4, 4, 4};
 
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_minus_cephes_DP1[8] = { -0.78515625, -0.78515625, -0.78515625, -0.78515625, -0.78515625, -0.78515625, -0.78515625, -0.78515625 };
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_minus_cephes_DP2[8] = { -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4 };
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_minus_cephes_DP3[8] = { -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8 };
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_coscof_p0[8] = { 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005 };
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_coscof_p1[8] = { -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003 };
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_coscof_p2[8] = { 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002 };
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_sincof_p0[8] = { -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4 };
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_sincof_p1[8] = { 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3 };
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_sincof_p2[8] = { -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1 };
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_0p5[8] = { 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f };
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_1[8] = { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f };
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_minus_cephes_DP1[8] = {-0.78515625, -0.78515625, -0.78515625, -0.78515625, -0.78515625, -0.78515625, -0.78515625, -0.78515625};
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_minus_cephes_DP2[8] = {-2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4};
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_minus_cephes_DP3[8] = {-3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8};
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_coscof_p0[8] = {2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005};
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_coscof_p1[8] = {-1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003};
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_coscof_p2[8] = {4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002};
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_sincof_p0[8] = {-1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4};
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_sincof_p1[8] = {8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3};
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_sincof_p2[8] = {-1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1};
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_0p5[8] = {0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f};
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_1[8] = {1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f};
 
-    __VOLK_ATTR_ALIGNED(32) float eight_phases[8] = { _phase, _phase + phase_inc, _phase + 2 * phase_inc, _phase + 3 * phase_inc, _phase + 4 * phase_inc, _phase + 5 * phase_inc, _phase + 6 * phase_inc, _phase + 7 * phase_inc };
-    __VOLK_ATTR_ALIGNED(32) float eight_phases_inc[8] = { 8 * phase_inc, 8 * phase_inc, 8 * phase_inc, 8 * phase_inc, 8 * phase_inc, 8 * phase_inc, 8 * phase_inc, 8 * phase_inc };
+    __VOLK_ATTR_ALIGNED(32)
+    float eight_phases[8] = {_phase, _phase + phase_inc, _phase + 2 * phase_inc, _phase + 3 * phase_inc, _phase + 4 * phase_inc, _phase + 5 * phase_inc, _phase + 6 * phase_inc, _phase + 7 * phase_inc};
+    __VOLK_ATTR_ALIGNED(32)
+    float eight_phases_inc[8] = {8 * phase_inc, 8 * phase_inc, 8 * phase_inc, 8 * phase_inc, 8 * phase_inc, 8 * phase_inc, 8 * phase_inc, 8 * phase_inc};
     eight_phases_reg = _mm256_load_ps(eight_phases);
     const __m256 eight_phases_inc_reg = _mm256_load_ps(eight_phases_inc);
 
-    for(;number < avx_iters; number++)
+    for (; number < avx_iters; number++)
         {
             x = eight_phases_reg;
 
             sign_bit_sin = x;
             /* take the absolute value */
-            x = _mm256_and_ps(x, *(__m256*)_ps_inv_sign_mask);
+            x = _mm256_and_ps(x, *(__m256 *)_ps_inv_sign_mask);
             /* extract the sign bit (upper one) */
-            sign_bit_sin = _mm256_and_ps(sign_bit_sin, *(__m256*)_ps_sign_mask);
+            sign_bit_sin = _mm256_and_ps(sign_bit_sin, *(__m256 *)_ps_sign_mask);
 
             /* scale by 4/Pi */
-            y = _mm256_mul_ps(x, *(__m256*)_ps_cephes_FOPI);
+            y = _mm256_mul_ps(x, *(__m256 *)_ps_cephes_FOPI);
 
             /* store the integer part of y in emm2 */
             emm2 = _mm256_cvttps_epi32(y);
@@ -517,9 +557,9 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_a_avx2(lv_32fc_t* out, const fl
 
             /* The magic pass: "Extended precision modular arithmetic”
                x = ((x - y * DP1) - y * DP2) - y * DP3; */
-            xmm1 = *(__m256*)_ps_minus_cephes_DP1;
-            xmm2 = *(__m256*)_ps_minus_cephes_DP2;
-            xmm3 = *(__m256*)_ps_minus_cephes_DP3;
+            xmm1 = *(__m256 *)_ps_minus_cephes_DP1;
+            xmm2 = *(__m256 *)_ps_minus_cephes_DP2;
+            xmm3 = *(__m256 *)_ps_minus_cephes_DP3;
             xmm1 = _mm256_mul_ps(y, xmm1);
             xmm2 = _mm256_mul_ps(y, xmm2);
             xmm3 = _mm256_mul_ps(y, xmm3);
@@ -536,24 +576,24 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_a_avx2(lv_32fc_t* out, const fl
 
             /* Evaluate the first polynom  (0 <= x <= Pi/4) */
             __m256 z = _mm256_mul_ps(x, x);
-            y = *(__m256*)_ps_coscof_p0;
+            y = *(__m256 *)_ps_coscof_p0;
 
             y = _mm256_mul_ps(y, z);
-            y = _mm256_add_ps(y, *(__m256*)_ps_coscof_p1);
+            y = _mm256_add_ps(y, *(__m256 *)_ps_coscof_p1);
             y = _mm256_mul_ps(y, z);
-            y = _mm256_add_ps(y, *(__m256*)_ps_coscof_p2);
+            y = _mm256_add_ps(y, *(__m256 *)_ps_coscof_p2);
             y = _mm256_mul_ps(y, z);
             y = _mm256_mul_ps(y, z);
-            __m256 tmp = _mm256_mul_ps(z, *(__m256*)_ps_0p5);
+            __m256 tmp = _mm256_mul_ps(z, *(__m256 *)_ps_0p5);
             y = _mm256_sub_ps(y, tmp);
-            y = _mm256_add_ps(y, *(__m256*)_ps_1);
+            y = _mm256_add_ps(y, *(__m256 *)_ps_1);
 
             /* Evaluate the second polynom  (Pi/4 <= x <= 0) */
-            __m256 y2 = *(__m256*)_ps_sincof_p0;
+            __m256 y2 = *(__m256 *)_ps_sincof_p0;
             y2 = _mm256_mul_ps(y2, z);
-            y2 = _mm256_add_ps(y2, *(__m256*)_ps_sincof_p1);
+            y2 = _mm256_add_ps(y2, *(__m256 *)_ps_sincof_p1);
             y2 = _mm256_mul_ps(y2, z);
-            y2 = _mm256_add_ps(y2, *(__m256*)_ps_sincof_p2);
+            y2 = _mm256_add_ps(y2, *(__m256 *)_ps_sincof_p2);
             y2 = _mm256_mul_ps(y2, z);
             y2 = _mm256_mul_ps(y2, x);
             y2 = _mm256_add_ps(y2, x);
@@ -576,27 +616,27 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_a_avx2(lv_32fc_t* out, const fl
             s1 = _mm256_extractf128_ps(sine, 0);
             c1 = _mm256_extractf128_ps(cosine, 0);
             aux = _mm_unpacklo_ps(c1, s1);
-            _mm_store_ps((float*)bPtr, aux);
+            _mm_store_ps((float *)bPtr, aux);
             bPtr += 2;
             aux = _mm_unpackhi_ps(c1, s1);
-            _mm_store_ps((float*)bPtr, aux);
+            _mm_store_ps((float *)bPtr, aux);
             bPtr += 2;
             s1 = _mm256_extractf128_ps(sine, 1);
             c1 = _mm256_extractf128_ps(cosine, 1);
             aux = _mm_unpacklo_ps(c1, s1);
-            _mm_store_ps((float*)bPtr, aux);
+            _mm_store_ps((float *)bPtr, aux);
             bPtr += 2;
             aux = _mm_unpackhi_ps(c1, s1);
-            _mm_store_ps((float*)bPtr, aux);
+            _mm_store_ps((float *)bPtr, aux);
             bPtr += 2;
 
             eight_phases_reg = _mm256_add_ps(eight_phases_reg, eight_phases_inc_reg);
         }
     _mm256_zeroupper();
     _phase = _phase + phase_inc * (avx_iters * 8);
-    for(number = avx_iters * 8; number < num_points; number++)
+    for (number = avx_iters * 8; number < num_points; number++)
         {
-            out[number] = lv_cmake((float)cosf(_phase), (float)sinf(_phase) );
+            out[number] = lv_cmake((float)cosf(_phase), (float)sinf(_phase));
             _phase += phase_inc;
         }
     (*phase) = _phase;
@@ -609,9 +649,9 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_a_avx2(lv_32fc_t* out, const fl
 #include <immintrin.h>
 /* Based on algorithms from the cephes library http://www.netlib.org/cephes/
  * Adapted to AVX2 by Carles Fernandez, based on original SSE2 code by Julien Pommier*/
-static inline void volk_gnsssdr_s32f_sincos_32fc_u_avx2(lv_32fc_t* out, const float phase_inc, float* phase, unsigned int num_points)
+static inline void volk_gnsssdr_s32f_sincos_32fc_u_avx2(lv_32fc_t *out, const float phase_inc, float *phase, unsigned int num_points)
 {
-    lv_32fc_t* bPtr = out;
+    lv_32fc_t *bPtr = out;
 
     const unsigned int avx_iters = num_points / 8;
     unsigned int number = 0;
@@ -624,44 +664,64 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_u_avx2(lv_32fc_t* out, const fl
     __m128 aux, c1, s1;
 
     /* declare some AXX2 constants */
-    __VOLK_ATTR_ALIGNED(32) static const int _ps_inv_sign_mask[8] = { ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000 };
-    __VOLK_ATTR_ALIGNED(32) static const int _ps_sign_mask[8] = { (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000 };
+    __VOLK_ATTR_ALIGNED(32)
+    static const int _ps_inv_sign_mask[8] = {~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000, ~0x80000000};
+    __VOLK_ATTR_ALIGNED(32)
+    static const int _ps_sign_mask[8] = {(int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000, (int)0x80000000};
 
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_cephes_FOPI[8] = { 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516 };
-    __VOLK_ATTR_ALIGNED(32) static const int _pi32_1[8]  = { 1, 1, 1, 1, 1, 1, 1, 1 };
-    __VOLK_ATTR_ALIGNED(32) static const int _pi32_inv1[8]  = { ~1, ~1, ~1, ~1, ~1, ~1, ~1, ~1 };
-    __VOLK_ATTR_ALIGNED(32) static const int _pi32_2[8]  = { 2, 2, 2, 2, 2, 2, 2, 2 };
-    __VOLK_ATTR_ALIGNED(32) static const int _pi32_4[8]  = { 4, 4, 4, 4, 4, 4, 4, 4 };
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_cephes_FOPI[8] = {1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516};
+    __VOLK_ATTR_ALIGNED(32)
+    static const int _pi32_1[8] = {1, 1, 1, 1, 1, 1, 1, 1};
+    __VOLK_ATTR_ALIGNED(32)
+    static const int _pi32_inv1[8] = {~1, ~1, ~1, ~1, ~1, ~1, ~1, ~1};
+    __VOLK_ATTR_ALIGNED(32)
+    static const int _pi32_2[8] = {2, 2, 2, 2, 2, 2, 2, 2};
+    __VOLK_ATTR_ALIGNED(32)
+    static const int _pi32_4[8] = {4, 4, 4, 4, 4, 4, 4, 4};
 
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_minus_cephes_DP1[8] = { -0.78515625, -0.78515625, -0.78515625, -0.78515625, -0.78515625, -0.78515625, -0.78515625, -0.78515625 };
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_minus_cephes_DP2[8] = { -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4 };
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_minus_cephes_DP3[8] = { -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8 };
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_coscof_p0[8] = { 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005 };
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_coscof_p1[8] = { -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003 };
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_coscof_p2[8] = { 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002 };
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_sincof_p0[8] = { -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4 };
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_sincof_p1[8] = { 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3 };
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_sincof_p2[8] = { -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1 };
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_0p5[8] = { 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f };
-    __VOLK_ATTR_ALIGNED(32) static const float _ps_1[8] = { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f };
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_minus_cephes_DP1[8] = {-0.78515625, -0.78515625, -0.78515625, -0.78515625, -0.78515625, -0.78515625, -0.78515625, -0.78515625};
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_minus_cephes_DP2[8] = {-2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4, -2.4187564849853515625e-4};
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_minus_cephes_DP3[8] = {-3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8, -3.77489497744594108e-8};
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_coscof_p0[8] = {2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005};
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_coscof_p1[8] = {-1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003};
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_coscof_p2[8] = {4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002};
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_sincof_p0[8] = {-1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4};
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_sincof_p1[8] = {8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3};
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_sincof_p2[8] = {-1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1};
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_0p5[8] = {0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f};
+    __VOLK_ATTR_ALIGNED(32)
+    static const float _ps_1[8] = {1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f};
 
-    __VOLK_ATTR_ALIGNED(32) float eight_phases[8] = { _phase, _phase + phase_inc, _phase + 2 * phase_inc, _phase + 3 * phase_inc, _phase + 4 * phase_inc, _phase + 5 * phase_inc, _phase + 6 * phase_inc, _phase + 7 * phase_inc };
-    __VOLK_ATTR_ALIGNED(32) float eight_phases_inc[8] = { 8 * phase_inc, 8 * phase_inc, 8 * phase_inc, 8 * phase_inc, 8 * phase_inc, 8 * phase_inc, 8 * phase_inc, 8 * phase_inc };
+    __VOLK_ATTR_ALIGNED(32)
+    float eight_phases[8] = {_phase, _phase + phase_inc, _phase + 2 * phase_inc, _phase + 3 * phase_inc, _phase + 4 * phase_inc, _phase + 5 * phase_inc, _phase + 6 * phase_inc, _phase + 7 * phase_inc};
+    __VOLK_ATTR_ALIGNED(32)
+    float eight_phases_inc[8] = {8 * phase_inc, 8 * phase_inc, 8 * phase_inc, 8 * phase_inc, 8 * phase_inc, 8 * phase_inc, 8 * phase_inc, 8 * phase_inc};
     eight_phases_reg = _mm256_load_ps(eight_phases);
     const __m256 eight_phases_inc_reg = _mm256_load_ps(eight_phases_inc);
 
-    for(;number < avx_iters; number++)
+    for (; number < avx_iters; number++)
         {
             x = eight_phases_reg;
 
             sign_bit_sin = x;
             /* take the absolute value */
-            x = _mm256_and_ps(x, *(__m256*)_ps_inv_sign_mask);
+            x = _mm256_and_ps(x, *(__m256 *)_ps_inv_sign_mask);
             /* extract the sign bit (upper one) */
-            sign_bit_sin = _mm256_and_ps(sign_bit_sin, *(__m256*)_ps_sign_mask);
+            sign_bit_sin = _mm256_and_ps(sign_bit_sin, *(__m256 *)_ps_sign_mask);
 
             /* scale by 4/Pi */
-            y = _mm256_mul_ps(x, *(__m256*)_ps_cephes_FOPI);
+            y = _mm256_mul_ps(x, *(__m256 *)_ps_cephes_FOPI);
 
             /* store the integer part of y in emm2 */
             emm2 = _mm256_cvttps_epi32(y);
@@ -685,9 +745,9 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_u_avx2(lv_32fc_t* out, const fl
 
             /* The magic pass: "Extended precision modular arithmetic”
                x = ((x - y * DP1) - y * DP2) - y * DP3; */
-            xmm1 = *(__m256*)_ps_minus_cephes_DP1;
-            xmm2 = *(__m256*)_ps_minus_cephes_DP2;
-            xmm3 = *(__m256*)_ps_minus_cephes_DP3;
+            xmm1 = *(__m256 *)_ps_minus_cephes_DP1;
+            xmm2 = *(__m256 *)_ps_minus_cephes_DP2;
+            xmm3 = *(__m256 *)_ps_minus_cephes_DP3;
             xmm1 = _mm256_mul_ps(y, xmm1);
             xmm2 = _mm256_mul_ps(y, xmm2);
             xmm3 = _mm256_mul_ps(y, xmm3);
@@ -704,24 +764,24 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_u_avx2(lv_32fc_t* out, const fl
 
             /* Evaluate the first polynom  (0 <= x <= Pi/4) */
             __m256 z = _mm256_mul_ps(x, x);
-            y = *(__m256*)_ps_coscof_p0;
+            y = *(__m256 *)_ps_coscof_p0;
 
             y = _mm256_mul_ps(y, z);
-            y = _mm256_add_ps(y, *(__m256*)_ps_coscof_p1);
+            y = _mm256_add_ps(y, *(__m256 *)_ps_coscof_p1);
             y = _mm256_mul_ps(y, z);
-            y = _mm256_add_ps(y, *(__m256*)_ps_coscof_p2);
+            y = _mm256_add_ps(y, *(__m256 *)_ps_coscof_p2);
             y = _mm256_mul_ps(y, z);
             y = _mm256_mul_ps(y, z);
-            __m256 tmp = _mm256_mul_ps(z, *(__m256*)_ps_0p5);
+            __m256 tmp = _mm256_mul_ps(z, *(__m256 *)_ps_0p5);
             y = _mm256_sub_ps(y, tmp);
-            y = _mm256_add_ps(y, *(__m256*)_ps_1);
+            y = _mm256_add_ps(y, *(__m256 *)_ps_1);
 
             /* Evaluate the second polynom  (Pi/4 <= x <= 0) */
-            __m256 y2 = *(__m256*)_ps_sincof_p0;
+            __m256 y2 = *(__m256 *)_ps_sincof_p0;
             y2 = _mm256_mul_ps(y2, z);
-            y2 = _mm256_add_ps(y2, *(__m256*)_ps_sincof_p1);
+            y2 = _mm256_add_ps(y2, *(__m256 *)_ps_sincof_p1);
             y2 = _mm256_mul_ps(y2, z);
-            y2 = _mm256_add_ps(y2, *(__m256*)_ps_sincof_p2);
+            y2 = _mm256_add_ps(y2, *(__m256 *)_ps_sincof_p2);
             y2 = _mm256_mul_ps(y2, z);
             y2 = _mm256_mul_ps(y2, x);
             y2 = _mm256_add_ps(y2, x);
@@ -744,27 +804,27 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_u_avx2(lv_32fc_t* out, const fl
             s1 = _mm256_extractf128_ps(sine, 0);
             c1 = _mm256_extractf128_ps(cosine, 0);
             aux = _mm_unpacklo_ps(c1, s1);
-            _mm_storeu_ps((float*)bPtr, aux);
+            _mm_storeu_ps((float *)bPtr, aux);
             bPtr += 2;
             aux = _mm_unpackhi_ps(c1, s1);
-            _mm_storeu_ps((float*)bPtr, aux);
+            _mm_storeu_ps((float *)bPtr, aux);
             bPtr += 2;
             s1 = _mm256_extractf128_ps(sine, 1);
             c1 = _mm256_extractf128_ps(cosine, 1);
             aux = _mm_unpacklo_ps(c1, s1);
-            _mm_storeu_ps((float*)bPtr, aux);
+            _mm_storeu_ps((float *)bPtr, aux);
             bPtr += 2;
             aux = _mm_unpackhi_ps(c1, s1);
-            _mm_storeu_ps((float*)bPtr, aux);
+            _mm_storeu_ps((float *)bPtr, aux);
             bPtr += 2;
 
             eight_phases_reg = _mm256_add_ps(eight_phases_reg, eight_phases_inc_reg);
         }
     _mm256_zeroupper();
     _phase = _phase + phase_inc * (avx_iters * 8);
-    for(number = avx_iters * 8; number < num_points; number++)
+    for (number = avx_iters * 8; number < num_points; number++)
         {
-            out[number] = lv_cmake((float)cosf(_phase), (float)sinf(_phase) );
+            out[number] = lv_cmake((float)cosf(_phase), (float)sinf(_phase));
             _phase += phase_inc;
         }
     (*phase) = _phase;
@@ -777,15 +837,17 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_u_avx2(lv_32fc_t* out, const fl
 #include <arm_neon.h>
 /* Adapted from http://gruntthepeon.free.fr/ssemath/neon_mathfun.h, original code from Julien Pommier  */
 /* Based on algorithms from the cephes library http://www.netlib.org/cephes/   */
-static inline void volk_gnsssdr_s32f_sincos_32fc_neon(lv_32fc_t* out, const float phase_inc, float* phase, unsigned int num_points)
+static inline void volk_gnsssdr_s32f_sincos_32fc_neon(lv_32fc_t *out, const float phase_inc, float *phase, unsigned int num_points)
 {
-    lv_32fc_t* bPtr = out;
+    lv_32fc_t *bPtr = out;
     const unsigned int neon_iters = num_points / 4;
     float _phase = (*phase);
 
-    __VOLK_ATTR_ALIGNED(16) float32_t four_phases[4] = {  _phase, _phase + phase_inc, _phase + 2 * phase_inc, _phase + 3 * phase_inc };
+    __VOLK_ATTR_ALIGNED(16)
+    float32_t four_phases[4] = {_phase, _phase + phase_inc, _phase + 2 * phase_inc, _phase + 3 * phase_inc};
     float four_inc = 4 * phase_inc;
-    __VOLK_ATTR_ALIGNED(16) float32_t four_phases_inc[4] = { four_inc, four_inc, four_inc, four_inc };
+    __VOLK_ATTR_ALIGNED(16)
+    float32_t four_phases_inc[4] = {four_inc, four_inc, four_inc, four_inc};
 
     float32x4_t four_phases_reg = vld1q_f32(four_phases);
     float32x4_t four_phases_inc_reg = vld1q_f32(four_phases_inc);
@@ -808,7 +870,7 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_neon(lv_32fc_t* out, const floa
 
     uint32x4_t emm2, poly_mask, sign_mask_sin, sign_mask_cos;
 
-    for(;number < neon_iters; number++)
+    for (; number < neon_iters; number++)
         {
             x = four_phases_reg;
 
@@ -847,7 +909,7 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_neon(lv_32fc_t* out, const floa
 
             /* Evaluate the first polynom  (0 <= x <= Pi/4) in y1,
                     and the second polynom      (Pi/4 <= x <= 0) in y2 */
-            z = vmulq_f32(x,x);
+            z = vmulq_f32(x, x);
 
             y1 = vmulq_n_f32(z, c_coscof_p0);
             y2 = vmulq_n_f32(z, c_sincof_p0);
@@ -871,16 +933,16 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_neon(lv_32fc_t* out, const floa
             result.val[1] = vbslq_f32(sign_mask_sin, vnegq_f32(ys), ys);
             result.val[0] = vbslq_f32(sign_mask_cos, yc, vnegq_f32(yc));
 
-            vst2q_f32((float32_t*)bPtr, result);
+            vst2q_f32((float32_t *)bPtr, result);
             bPtr += 4;
 
             four_phases_reg = vaddq_f32(four_phases_reg, four_phases_inc_reg);
         }
 
     _phase = _phase + phase_inc * (neon_iters * 4);
-    for(number = neon_iters * 4; number < num_points; number++)
+    for (number = neon_iters * 4; number < num_points; number++)
         {
-            *bPtr++ = lv_cmake((float)cosf(_phase), (float)sinf(_phase) );
+            *bPtr++ = lv_cmake((float)cosf(_phase), (float)sinf(_phase));
             _phase += phase_inc;
         }
     (*phase) = _phase;

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_s32f_sincospuppet_32fc.h

@@ -49,7 +49,7 @@ static inline void volk_gnsssdr_s32f_sincospuppet_32fc_generic(lv_32fc_t* out, c
     volk_gnsssdr_s32f_sincos_32fc_generic(out, phase_inc, phase, num_points);
 }
 
-#endif   /* LV_HAVE_GENERIC  */
+#endif /* LV_HAVE_GENERIC  */
 
 
 #ifdef LV_HAVE_GENERIC
@@ -60,7 +60,7 @@ static inline void volk_gnsssdr_s32f_sincospuppet_32fc_generic_fxpt(lv_32fc_t* o
     volk_gnsssdr_s32f_sincos_32fc_generic_fxpt(out, phase_inc, phase, num_points);
 }
 
-#endif   /* LV_HAVE_GENERIC  */
+#endif /* LV_HAVE_GENERIC  */
 
 
 #ifdef LV_HAVE_SSE2
@@ -70,7 +70,7 @@ static inline void volk_gnsssdr_s32f_sincospuppet_32fc_a_sse2(lv_32fc_t* out, co
     phase[0] = 3;
     volk_gnsssdr_s32f_sincos_32fc_a_sse2(out, phase_inc, phase, num_points);
 }
-#endif  /* LV_HAVE_SSE2  */
+#endif /* LV_HAVE_SSE2  */
 
 
 #ifdef LV_HAVE_SSE2
@@ -80,7 +80,7 @@ static inline void volk_gnsssdr_s32f_sincospuppet_32fc_u_sse2(lv_32fc_t* out, co
     phase[0] = 3;
     volk_gnsssdr_s32f_sincos_32fc_u_sse2(out, phase_inc, phase, num_points);
 }
-#endif  /* LV_HAVE_SSE2  */
+#endif /* LV_HAVE_SSE2  */
 
 
 #ifdef LV_HAVE_AVX2
@@ -90,7 +90,7 @@ static inline void volk_gnsssdr_s32f_sincospuppet_32fc_a_avx2(lv_32fc_t* out, co
     phase[0] = 3;
     volk_gnsssdr_s32f_sincos_32fc_a_avx2(out, phase_inc, phase, num_points);
 }
-#endif  /* LV_HAVE_AVX2  */
+#endif /* LV_HAVE_AVX2  */
 
 
 #ifdef LV_HAVE_AVX2
@@ -100,7 +100,7 @@ static inline void volk_gnsssdr_s32f_sincospuppet_32fc_u_avx2(lv_32fc_t* out, co
     phase[0] = 3;
     volk_gnsssdr_s32f_sincos_32fc_u_avx2(out, phase_inc, phase, num_points);
 }
-#endif  /* LV_HAVE_AVX2  */
+#endif /* LV_HAVE_AVX2  */
 
 
 #ifdef LV_HAVE_NEON
@@ -110,6 +110,6 @@ static inline void volk_gnsssdr_s32f_sincospuppet_32fc_neon(lv_32fc_t* out, cons
     phase[0] = 3;
     volk_gnsssdr_s32f_sincos_32fc_neon(out, phase_inc, phase, num_points);
 }
-#endif  /* LV_HAVE_NEON  */
+#endif /* LV_HAVE_NEON  */
 
-#endif  /* INCLUDED_volk_gnsssdr_s32f_sincospuppet_32fc_H */
+#endif /* INCLUDED_volk_gnsssdr_s32f_sincospuppet_32fc_H */

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/kernel_tests.h

@@ -38,32 +38,31 @@
 
 // for puppets we need to get all the func_variants for the puppet and just
 // keep track of the actual function name to write to results
-#define VOLK_INIT_PUPP(func, puppet_master_func, test_params)\
-    volk_gnsssdr_test_case_t(func##_get_func_desc(), (void(*)())func##_manual, std::string(#func),\
-    std::string(#puppet_master_func), test_params)
+#define VOLK_INIT_PUPP(func, puppet_master_func, test_params)                                       \
+    volk_gnsssdr_test_case_t(func##_get_func_desc(), (void (*)())func##_manual, std::string(#func), \
+        std::string(#puppet_master_func), test_params)
 
-#define VOLK_INIT_TEST(func, test_params)\
-    volk_gnsssdr_test_case_t(func##_get_func_desc(), (void(*)())func##_manual, std::string(#func),\
-    test_params)
+#define VOLK_INIT_TEST(func, test_params)                                                           \
+    volk_gnsssdr_test_case_t(func##_get_func_desc(), (void (*)())func##_manual, std::string(#func), \
+        test_params)
 
 #define QA(test) test_cases.push_back(test);
 
 std::vector<volk_gnsssdr_test_case_t> init_test_list(volk_gnsssdr_test_params_t test_params)
 {
-
     // Some kernels need a lower tolerance
     volk_gnsssdr_test_params_t test_params_inacc = volk_gnsssdr_test_params_t(1e-3, test_params.scalar(),
-            test_params.vlen(), test_params.iter(), test_params.benchmark_mode(), test_params.kernel_regex());
+        test_params.vlen(), test_params.iter(), test_params.benchmark_mode(), test_params.kernel_regex());
     volk_gnsssdr_test_params_t test_params_int1 = volk_gnsssdr_test_params_t(1, test_params.scalar(),
-            test_params.vlen(), test_params.iter(), test_params.benchmark_mode(), test_params.kernel_regex());
+        test_params.vlen(), test_params.iter(), test_params.benchmark_mode(), test_params.kernel_regex());
     // some others need more iterations *****  ADDED BY GNSS-SDR
     volk_gnsssdr_test_params_t test_params_more_iters = volk_gnsssdr_test_params_t(test_params.tol(), test_params.scalar(),
-                test_params.vlen(), 100000, test_params.benchmark_mode(), test_params.kernel_regex());
+        test_params.vlen(), 100000, test_params.benchmark_mode(), test_params.kernel_regex());
     // ... or more tolerance *****  ADDED BY GNSS-SDR
     volk_gnsssdr_test_params_t test_params_int16 = volk_gnsssdr_test_params_t(16, test_params.scalar(),
-                test_params.vlen(), test_params.iter(), test_params.benchmark_mode(), test_params.kernel_regex());
+        test_params.vlen(), test_params.iter(), test_params.benchmark_mode(), test_params.kernel_regex());
     volk_gnsssdr_test_params_t test_params_inacc2 = volk_gnsssdr_test_params_t(2e-1, test_params.scalar(),
-                test_params.vlen(), test_params.iter(), test_params.benchmark_mode(), test_params.kernel_regex());
+        test_params.vlen(), test_params.iter(), test_params.benchmark_mode(), test_params.kernel_regex());
 
     std::vector<volk_gnsssdr_test_case_t> test_cases;
 
@@ -98,8 +97,7 @@ std::vector<volk_gnsssdr_test_case_t> init_test_list(volk_gnsssdr_test_params_t
     QA(VOLK_INIT_PUPP(volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic, volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn, test_params_int16))
     QA(VOLK_INIT_PUPP(volk_gnsssdr_16ic_16i_rotator_dotprodxnpuppet_16ic, volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn, test_params_int16))
     QA(VOLK_INIT_PUPP(volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc, volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn, test_params_int1))
-    QA(VOLK_INIT_PUPP(volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc, volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn, test_params_int1))
-    ;
+    QA(VOLK_INIT_PUPP(volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc, volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn, test_params_int1));
 
     return test_cases;
 }

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/qa_utils.h

@@ -25,17 +25,18 @@
 
 #include "volk_gnsssdr/volk_gnsssdr_complex.h"  // for lv_32fc_t
 #include "volk_gnsssdr/volk_gnsssdr.h"          // for volk_gnsssdr_func_desc_t
-#include <cstdbool>       // for bool, false
-#include <cstdlib>        // for NULL
-#include <map>            // for map
-#include <string>         // for string, basic_string
-#include <vector>         // for vector
+#include <cstdbool>                             // for bool, false
+#include <cstdlib>                              // for NULL
+#include <map>                                  // for map
+#include <string>                               // for string, basic_string
+#include <vector>                               // for vector
 
 
 /************************************************
  * VOLK QA type definitions                     *
  ************************************************/
-struct volk_gnsssdr_type_t {
+struct volk_gnsssdr_type_t
+{
     bool is_float;
     bool is_scalar;
     bool is_signed;
@@ -44,80 +45,78 @@ struct volk_gnsssdr_type_t {
     std::string str;
 };
 
-class volk_gnsssdr_test_time_t {
-    public:
-        std::string name;
-        double time;
-        std::string units;
-        bool pass;
+class volk_gnsssdr_test_time_t
+{
+public:
+    std::string name;
+    double time;
+    std::string units;
+    bool pass;
 };
 
-class volk_gnsssdr_test_results_t {
-    public:
-        std::string name;
-        std::string config_name;
-        unsigned int vlen;
-        unsigned int iter;
-        std::map<std::string, volk_gnsssdr_test_time_t> results;
-        std::string best_arch_a;
-        std::string best_arch_u;
+class volk_gnsssdr_test_results_t
+{
+public:
+    std::string name;
+    std::string config_name;
+    unsigned int vlen;
+    unsigned int iter;
+    std::map<std::string, volk_gnsssdr_test_time_t> results;
+    std::string best_arch_a;
+    std::string best_arch_u;
 };
 
-class volk_gnsssdr_test_params_t {
-    private:
-        float _tol;
-        lv_32fc_t _scalar;
-        unsigned int _vlen;
-        unsigned int _iter;
-        bool _benchmark_mode;
-        std::string _kernel_regex;
-    public:
-        // ctor
-        volk_gnsssdr_test_params_t(float tol, lv_32fc_t scalar, unsigned int vlen, unsigned int iter,
-                           bool benchmark_mode, std::string kernel_regex) :
-            _tol(tol), _scalar(scalar), _vlen(vlen), _iter(iter),
-            _benchmark_mode(benchmark_mode), _kernel_regex(kernel_regex) {};
-        // setters
-        void set_tol(float tol) {_tol=tol;};
-        void set_scalar(lv_32fc_t scalar) {_scalar=scalar;};
-        void set_vlen(unsigned int vlen) {_vlen=vlen;};
-        void set_iter(unsigned int iter) {_iter=iter;};
-        void set_benchmark(bool benchmark) {_benchmark_mode=benchmark;};
-        void set_regex(std::string regex) {_kernel_regex=regex;};
-        // getters
-        float tol() {return _tol;};
-        lv_32fc_t scalar() {return _scalar;};
-        unsigned int vlen() {return _vlen;};
-        unsigned int iter() {return _iter;};
-        bool benchmark_mode() {return _benchmark_mode;};
-        std::string kernel_regex() {return _kernel_regex;};
+class volk_gnsssdr_test_params_t
+{
+private:
+    float _tol;
+    lv_32fc_t _scalar;
+    unsigned int _vlen;
+    unsigned int _iter;
+    bool _benchmark_mode;
+    std::string _kernel_regex;
+
+public:
+    // ctor
+    volk_gnsssdr_test_params_t(float tol, lv_32fc_t scalar, unsigned int vlen, unsigned int iter,
+        bool benchmark_mode, std::string kernel_regex) : _tol(tol), _scalar(scalar), _vlen(vlen), _iter(iter), _benchmark_mode(benchmark_mode), _kernel_regex(kernel_regex){};
+    // setters
+    void set_tol(float tol) { _tol = tol; };
+    void set_scalar(lv_32fc_t scalar) { _scalar = scalar; };
+    void set_vlen(unsigned int vlen) { _vlen = vlen; };
+    void set_iter(unsigned int iter) { _iter = iter; };
+    void set_benchmark(bool benchmark) { _benchmark_mode = benchmark; };
+    void set_regex(std::string regex) { _kernel_regex = regex; };
+    // getters
+    float tol() { return _tol; };
+    lv_32fc_t scalar() { return _scalar; };
+    unsigned int vlen() { return _vlen; };
+    unsigned int iter() { return _iter; };
+    bool benchmark_mode() { return _benchmark_mode; };
+    std::string kernel_regex() { return _kernel_regex; };
 };
 
-class volk_gnsssdr_test_case_t {
-    private:
-        volk_gnsssdr_func_desc_t _desc;
-        void(*_kernel_ptr)();
-        std::string _name;
-        volk_gnsssdr_test_params_t _test_parameters;
-        std::string _puppet_master_name;
-    public:
-        volk_gnsssdr_func_desc_t desc() {return _desc;};
-        void (*kernel_ptr()) () {return _kernel_ptr;};
-        std::string name() {return _name;};
-        std::string puppet_master_name() {return _puppet_master_name;};
-        volk_gnsssdr_test_params_t test_parameters() {return _test_parameters;};
-        // normal ctor
-        volk_gnsssdr_test_case_t(volk_gnsssdr_func_desc_t desc, void(*kernel_ptr)(), std::string name,
-            volk_gnsssdr_test_params_t test_parameters) :
-            _desc(desc), _kernel_ptr(kernel_ptr), _name(name), _test_parameters(test_parameters),
-            _puppet_master_name("NULL")
-            {};
-        // ctor for puppets
-        volk_gnsssdr_test_case_t(volk_gnsssdr_func_desc_t desc, void(*kernel_ptr)(), std::string name,
-            std::string puppet_master_name, volk_gnsssdr_test_params_t test_parameters) :
-            _desc(desc), _kernel_ptr(kernel_ptr), _name(name), _test_parameters(test_parameters),
-            _puppet_master_name(puppet_master_name)
-            {};
+class volk_gnsssdr_test_case_t
+{
+private:
+    volk_gnsssdr_func_desc_t _desc;
+    void (*_kernel_ptr)();
+    std::string _name;
+    volk_gnsssdr_test_params_t _test_parameters;
+    std::string _puppet_master_name;
+
+public:
+    volk_gnsssdr_func_desc_t desc() { return _desc; };
+    void (*kernel_ptr())() { return _kernel_ptr; };
+    std::string name() { return _name; };
+    std::string puppet_master_name() { return _puppet_master_name; };
+    volk_gnsssdr_test_params_t test_parameters() { return _test_parameters; };
+    // normal ctor
+    volk_gnsssdr_test_case_t(volk_gnsssdr_func_desc_t desc, void (*kernel_ptr)(), std::string name,
+        volk_gnsssdr_test_params_t test_parameters) : _desc(desc), _kernel_ptr(kernel_ptr), _name(name), _test_parameters(test_parameters), _puppet_master_name("NULL"){};
+    // ctor for puppets
+    volk_gnsssdr_test_case_t(volk_gnsssdr_func_desc_t desc, void (*kernel_ptr)(), std::string name,
+        std::string puppet_master_name, volk_gnsssdr_test_params_t test_parameters) : _desc(desc), _kernel_ptr(kernel_ptr), _name(name), _test_parameters(test_parameters), _puppet_master_name(puppet_master_name){};
 };
 
 /************************************************
@@ -130,58 +129,57 @@ void random_floats(float *buf, unsigned n);
 
 bool run_volk_gnsssdr_tests(
     volk_gnsssdr_func_desc_t,
-    void(*)(),
+    void (*)(),
     std::string,
     volk_gnsssdr_test_params_t,
     std::vector<volk_gnsssdr_test_results_t> *results = NULL,
-    std::string puppet_master_name = "NULL"
-    );
+    std::string puppet_master_name = "NULL");
 
 bool run_volk_gnsssdr_tests(
-        volk_gnsssdr_func_desc_t,
-        void(*)(),
-        std::string,
-        float,
-        lv_32fc_t,
-        unsigned int,
-        unsigned int,
-        std::vector<volk_gnsssdr_test_results_t> *results = NULL,
-        std::string puppet_master_name = "NULL",
-        bool benchmark_mode = false
-);
+    volk_gnsssdr_func_desc_t,
+    void (*)(),
+    std::string,
+    float,
+    lv_32fc_t,
+    unsigned int,
+    unsigned int,
+    std::vector<volk_gnsssdr_test_results_t> *results = NULL,
+    std::string puppet_master_name = "NULL",
+    bool benchmark_mode = false);
 
 
-#define VOLK_RUN_TESTS(func, tol, scalar, len, iter) \
-    BOOST_AUTO_TEST_CASE(func##_test) { \
-        BOOST_CHECK_EQUAL(run_volk_gnsssdr_tests( \
-            func##_get_func_desc(), (void (*)())func##_manual, \
-            std::string(#func), tol, scalar, len, iter, 0, "NULL"), \
-          0); \
+#define VOLK_RUN_TESTS(func, tol, scalar, len, iter)                                  \
+    BOOST_AUTO_TEST_CASE(func##_test)                                                 \
+    {                                                                                 \
+        BOOST_CHECK_EQUAL(run_volk_gnsssdr_tests(                                     \
+                              func##_get_func_desc(), (void (*)())func##_manual,      \
+                              std::string(#func), tol, scalar, len, iter, 0, "NULL"), \
+            0);                                                                       \
     }
 #define VOLK_PROFILE(func, test_params, results) run_volk_gnsssdr_tests(func##_get_func_desc(), (void (*)())func##_manual, std::string(#func), test_params, results, "NULL")
 #define VOLK_PUPPET_PROFILE(func, puppet_master_func, test_params, results) run_volk_gnsssdr_tests(func##_get_func_desc(), (void (*)())func##_manual, std::string(#func), test_params, results, std::string(#puppet_master_func))
-typedef void (*volk_gnsssdr_fn_1arg)(void *, unsigned int, const char*); //one input, operate in place
-typedef void (*volk_gnsssdr_fn_2arg)(void *, void *, unsigned int, const char*);
-typedef void (*volk_gnsssdr_fn_3arg)(void *, void *, void *, unsigned int, const char*);
-typedef void (*volk_gnsssdr_fn_4arg)(void *, void *, void *, void *, unsigned int, const char*);
-typedef void (*volk_gnsssdr_fn_1arg_s32f)(void *, float, unsigned int, const char*); //one input vector, one scalar float input
-typedef void (*volk_gnsssdr_fn_2arg_s32f)(void *, void *, float, unsigned int, const char*);
-typedef void (*volk_gnsssdr_fn_3arg_s32f)(void *, void *, void *, float, unsigned int, const char*);
-typedef void (*volk_gnsssdr_fn_1arg_s32fc)(void *, lv_32fc_t, unsigned int, const char*); //one input vector, one scalar float input
-typedef void (*volk_gnsssdr_fn_2arg_s32fc)(void *, void *, lv_32fc_t, unsigned int, const char*);
-typedef void (*volk_gnsssdr_fn_3arg_s32fc)(void *, void *, void *, lv_32fc_t, unsigned int, const char*);
+typedef void (*volk_gnsssdr_fn_1arg)(void *, unsigned int, const char *);  //one input, operate in place
+typedef void (*volk_gnsssdr_fn_2arg)(void *, void *, unsigned int, const char *);
+typedef void (*volk_gnsssdr_fn_3arg)(void *, void *, void *, unsigned int, const char *);
+typedef void (*volk_gnsssdr_fn_4arg)(void *, void *, void *, void *, unsigned int, const char *);
+typedef void (*volk_gnsssdr_fn_1arg_s32f)(void *, float, unsigned int, const char *);  //one input vector, one scalar float input
+typedef void (*volk_gnsssdr_fn_2arg_s32f)(void *, void *, float, unsigned int, const char *);
+typedef void (*volk_gnsssdr_fn_3arg_s32f)(void *, void *, void *, float, unsigned int, const char *);
+typedef void (*volk_gnsssdr_fn_1arg_s32fc)(void *, lv_32fc_t, unsigned int, const char *);  //one input vector, one scalar float input
+typedef void (*volk_gnsssdr_fn_2arg_s32fc)(void *, void *, lv_32fc_t, unsigned int, const char *);
+typedef void (*volk_gnsssdr_fn_3arg_s32fc)(void *, void *, void *, lv_32fc_t, unsigned int, const char *);
 
 //ADDED BY GNSS-SDR. START
-typedef void (*volk_gnsssdr_fn_1arg_s8i)(void *, char, unsigned int, const char*); //one input vector, one scalar char input
-typedef void (*volk_gnsssdr_fn_2arg_s8i)(void *, void *, char, unsigned int, const char*);
-typedef void (*volk_gnsssdr_fn_3arg_s8i)(void *, void *, void *, char, unsigned int, const char*);
-typedef void (*volk_gnsssdr_fn_1arg_s8ic)(void *, lv_8sc_t, unsigned int, const char*); //one input vector, one scalar lv_8sc_t vector input
-typedef void (*volk_gnsssdr_fn_2arg_s8ic)(void *, void *, lv_8sc_t, unsigned int, const char*);
-typedef void (*volk_gnsssdr_fn_3arg_s8ic)(void *, void *, void *, lv_8sc_t, unsigned int, const char*);
-typedef void (*volk_gnsssdr_fn_1arg_s16ic)(void *, lv_16sc_t, unsigned int, const char*); //one input vector, one scalar lv_16sc_t vector input
-typedef void (*volk_gnsssdr_fn_2arg_s16ic)(void *, void *, lv_16sc_t, unsigned int, const char*);
-typedef void (*volk_gnsssdr_fn_3arg_s16ic)(void *, void *, void *, lv_16sc_t, unsigned int, const char*);
+typedef void (*volk_gnsssdr_fn_1arg_s8i)(void *, char, unsigned int, const char *);  //one input vector, one scalar char input
+typedef void (*volk_gnsssdr_fn_2arg_s8i)(void *, void *, char, unsigned int, const char *);
+typedef void (*volk_gnsssdr_fn_3arg_s8i)(void *, void *, void *, char, unsigned int, const char *);
+typedef void (*volk_gnsssdr_fn_1arg_s8ic)(void *, lv_8sc_t, unsigned int, const char *);  //one input vector, one scalar lv_8sc_t vector input
+typedef void (*volk_gnsssdr_fn_2arg_s8ic)(void *, void *, lv_8sc_t, unsigned int, const char *);
+typedef void (*volk_gnsssdr_fn_3arg_s8ic)(void *, void *, void *, lv_8sc_t, unsigned int, const char *);
+typedef void (*volk_gnsssdr_fn_1arg_s16ic)(void *, lv_16sc_t, unsigned int, const char *);  //one input vector, one scalar lv_16sc_t vector input
+typedef void (*volk_gnsssdr_fn_2arg_s16ic)(void *, void *, lv_16sc_t, unsigned int, const char *);
+typedef void (*volk_gnsssdr_fn_3arg_s16ic)(void *, void *, void *, lv_16sc_t, unsigned int, const char *);
 //ADDED BY GNSS-SDR. END
 
 
-#endif // GNSS_SDR_VOLK_QA_UTILS_H
+#endif  // GNSS_SDR_VOLK_QA_UTILS_H

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/testqa.cc

@@ -18,16 +18,16 @@
  */
 
 
-#include "kernel_tests.h"       // for init_test_list
-#include "qa_utils.h"           // for volk_gnsssdr_test_case_t, volk_gnsssdr_test_results_t
+#include "kernel_tests.h"                       // for init_test_list
+#include "qa_utils.h"                           // for volk_gnsssdr_test_case_t, volk_gnsssdr_test_results_t
 #include "volk_gnsssdr/volk_gnsssdr_complex.h"  // for lv_32fc_t
-#include <cstdbool>             // for bool, false, true
-#include <iostream>             // for operator<<, basic_ostream, endl, char...
-#include <fstream>              // IWYU pragma: keep
-#include <map>                  // for map, map<>::iterator, _Rb_tree_iterator
-#include <string>               // for string, operator<<
-#include <utility>              // for pair
-#include <vector>               // for vector
+#include <cstdbool>                             // for bool, false, true
+#include <iostream>                             // for operator<<, basic_ostream, endl, char...
+#include <fstream>                              // IWYU pragma: keep
+#include <map>                                  // for map, map<>::iterator, _Rb_tree_iterator
+#include <string>                               // for string, operator<<
+#include <utility>                              // for pair
+#include <vector>                               // for vector
 
 void print_qa_xml(std::vector<volk_gnsssdr_test_results_t> results, unsigned int nfails);
 
@@ -49,38 +49,44 @@ int main()
     std::vector<std::string> qa_failures;
     std::vector<volk_gnsssdr_test_results_t> results;
     // Test every kernel reporting failures when they occur
-    for(unsigned int ii = 0; ii < test_cases.size(); ++ii) {
-        bool qa_result = false;
-        volk_gnsssdr_test_case_t test_case = test_cases[ii];
-        try {
-            qa_result = run_volk_gnsssdr_tests(test_case.desc(), test_case.kernel_ptr(), test_case.name(),
-                test_case.test_parameters(), &results, test_case.puppet_master_name());
-        }
-        catch(...) {
-            // TODO: what exceptions might we need to catch and how do we handle them?
-            std::cerr << "Exception found on kernel: " << test_case.name() << std::endl;
-            qa_result = false;
-        }
+    for (unsigned int ii = 0; ii < test_cases.size(); ++ii)
+        {
+            bool qa_result = false;
+            volk_gnsssdr_test_case_t test_case = test_cases[ii];
+            try
+                {
+                    qa_result = run_volk_gnsssdr_tests(test_case.desc(), test_case.kernel_ptr(), test_case.name(),
+                        test_case.test_parameters(), &results, test_case.puppet_master_name());
+                }
+            catch (...)
+                {
+                    // TODO: what exceptions might we need to catch and how do we handle them?
+                    std::cerr << "Exception found on kernel: " << test_case.name() << std::endl;
+                    qa_result = false;
+                }
 
-        if(qa_result) {
-            std::cerr << "Failure on " << test_case.name() << std::endl;
-            qa_failures.push_back(test_case.name());
+            if (qa_result)
+                {
+                    std::cerr << "Failure on " << test_case.name() << std::endl;
+                    qa_failures.push_back(test_case.name());
+                }
         }
-    }
 
     // Generate XML results
     print_qa_xml(results, qa_failures.size());
 
     // Summarize QA results
     std::cerr << "Kernel QA finished: " << qa_failures.size() << " failures out of "
-        << test_cases.size() << " tests." << std::endl;
-    if(qa_failures.size() > 0) {
-        std::cerr << "The following kernels failed QA:" << std::endl;
-        for(unsigned int ii = 0; ii < qa_failures.size(); ++ii) {
-            std::cerr << "    " << qa_failures[ii] << std::endl;
+              << test_cases.size() << " tests." << std::endl;
+    if (qa_failures.size() > 0)
+        {
+            std::cerr << "The following kernels failed QA:" << std::endl;
+            for (unsigned int ii = 0; ii < qa_failures.size(); ++ii)
+                {
+                    std::cerr << "    " << qa_failures[ii] << std::endl;
+                }
+            qa_ret_val = 1;
         }
-        qa_ret_val = 1;
-    }
 
     return qa_ret_val;
 }
@@ -95,34 +101,34 @@ void print_qa_xml(std::vector<volk_gnsssdr_test_results_t> results, unsigned int
     qa_file.open(".unittest/kernels.xml");
 
     qa_file << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl;
-    qa_file << "<testsuites name=\"kernels\" " <<
-        "tests=\"" << results.size() << "\" " <<
-        "failures=\"" << nfails << "\" id=\"1\">" << std::endl;
+    qa_file << "<testsuites name=\"kernels\" "
+            << "tests=\"" << results.size() << "\" "
+            << "failures=\"" << nfails << "\" id=\"1\">" << std::endl;
 
     // Results are in a vector by kernel. Each element has a result
     // map containing time and arch name with test result
-    for(unsigned int ii=0; ii < results.size(); ++ii) {
-        volk_gnsssdr_test_results_t result = results[ii];
-        qa_file << "  <testsuite name=\"" << result.name << "\">" << std::endl;
+    for (unsigned int ii = 0; ii < results.size(); ++ii)
+        {
+            volk_gnsssdr_test_results_t result = results[ii];
+            qa_file << "  <testsuite name=\"" << result.name << "\">" << std::endl;
 
-        std::map<std::string, volk_gnsssdr_test_time_t>::iterator kernel_time_pair;
-        for(kernel_time_pair = result.results.begin(); kernel_time_pair != result.results.end(); ++kernel_time_pair) {
-            volk_gnsssdr_test_time_t test_time = kernel_time_pair->second;
-            qa_file << "    <testcase name=\"" << test_time.name << "\" " <<
-                "classname=\"" << result.name << "\" " <<
-                "time=\"" << test_time.time << "\">" << std::endl;
-            if(!test_time.pass)
-                qa_file << "      <failure " <<
-                    "message=\"fail on arch " <<  test_time.name << "\">" <<
-                    "</failure>" << std::endl;
-            qa_file << "    </testcase>" << std::endl;
+            std::map<std::string, volk_gnsssdr_test_time_t>::iterator kernel_time_pair;
+            for (kernel_time_pair = result.results.begin(); kernel_time_pair != result.results.end(); ++kernel_time_pair)
+                {
+                    volk_gnsssdr_test_time_t test_time = kernel_time_pair->second;
+                    qa_file << "    <testcase name=\"" << test_time.name << "\" "
+                            << "classname=\"" << result.name << "\" "
+                            << "time=\"" << test_time.time << "\">" << std::endl;
+                    if (!test_time.pass)
+                        qa_file << "      <failure "
+                                << "message=\"fail on arch " << test_time.name << "\">"
+                                << "</failure>" << std::endl;
+                    qa_file << "    </testcase>" << std::endl;
+                }
+            qa_file << "  </testsuite>" << std::endl;
         }
-        qa_file << "  </testsuite>" << std::endl;
-    }
 
 
     qa_file << "</testsuites>" << std::endl;
     qa_file.close();
-
 }
-

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/volk_gnsssdr_malloc.c

@@ -43,15 +43,16 @@ void *volk_gnsssdr_malloc(size_t size, size_t alignment)
         return malloc(size);
 
     int err = posix_memalign(&ptr, alignment, size);
-    if(err == 0)
+    if (err == 0)
         {
             return ptr;
         }
     else
         {
             fprintf(stderr,
-                    "VOLK_GNSSSDR: Error allocating memory "
-                    "(posix_memalign: error %d: %s)\n", err, strerror(err));
+                "VOLK_GNSSSDR: Error allocating memory "
+                "(posix_memalign: error %d: %s)\n",
+                err, strerror(err));
             return NULL;
         }
 }
@@ -68,7 +69,7 @@ void volk_gnsssdr_free(void *ptr)
 void *volk_gnsssdr_malloc(size_t size, size_t alignment)
 {
     void *ptr = _aligned_malloc(size, alignment);
-    if(ptr == NULL)
+    if (ptr == NULL)
         {
             fprintf(stderr, "VOLK_GNSSSDR: Error allocating memory (_aligned_malloc)\n");
         }
@@ -81,7 +82,7 @@ void volk_gnsssdr_free(void *ptr)
 }
 
 // No standard handlers; we'll do it ourselves.
-#else // _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600 || HAVE_POSIX_MEMALIGN
+#else  // _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600 || HAVE_POSIX_MEMALIGN
 
 struct block_info
 {
@@ -102,7 +103,7 @@ volk_gnsssdr_malloc(size_t size, size_t alignment)
     real = malloc(size + (2 * alignment - 1));
 
     /* Get pointer to the various zones */
-    user = (void *)((((uintptr_t) real) + sizeof(struct block_info) + alignment - 1) & ~(alignment - 1));
+    user = (void *)((((uintptr_t)real) + sizeof(struct block_info) + alignment - 1) & ~(alignment - 1));
     info = (struct block_info *)(((uintptr_t)user) - sizeof(struct block_info));
 
     /* Store the info for the free */
@@ -112,8 +113,7 @@ volk_gnsssdr_malloc(size_t size, size_t alignment)
     return user;
 }
 
-void
-volk_gnsssdr_free(void *ptr)
+void volk_gnsssdr_free(void *ptr)
 {
     struct block_info *info;
 
@@ -124,6 +124,6 @@ volk_gnsssdr_free(void *ptr)
     free(info->real);
 }
 
-#endif // _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600 || HAVE_POSIX_MEMALIGN
+#endif  // _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600 || HAVE_POSIX_MEMALIGN
 
 //#endif // _ISOC11_SOURCE

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/volk_gnsssdr_prefs.c

@@ -26,16 +26,17 @@ void volk_gnsssdr_get_config_path(char *path)
 {
     if (!path) return;
     const char *suffix = "/.volk_gnsssdr/volk_gnsssdr_config";
-    const char *suffix2 = "/volk_gnsssdr/volk_gnsssdr_config"; //non-hidden
+    const char *suffix2 = "/volk_gnsssdr/volk_gnsssdr_config";  // non-hidden
     char *home = NULL;
 
     //allows config redirection via env variable
     home = getenv("VOLK_CONFIGPATH");
-    if(home!=NULL){
-        strncpy(path,home,512);
-        strcat(path,suffix2);
-        return;
-    }
+    if (home != NULL)
+        {
+            strncpy(path, home, 512);
+            strcat(path, suffix2);
+            return;
+        }
 
     if (home == NULL) home = getenv("HOME");
     if (home == NULL) home = getenv("APPDATA");
@@ -57,16 +58,16 @@ size_t volk_gnsssdr_load_preferences(volk_gnsssdr_arch_pref_t **prefs_res)
 
     //get the config path
     volk_gnsssdr_get_config_path(path);
-    if (!path[0]) return n_arch_prefs; //no prefs found
+    if (!path[0]) return n_arch_prefs;  //no prefs found
     config_file = fopen(path, "r");
-    if(!config_file) return n_arch_prefs; //no prefs found
+    if (!config_file) return n_arch_prefs;  //no prefs found
 
     //reset the file pointer and write the prefs into volk_gnsssdr_arch_prefs
-    while(fgets(line, sizeof(line), config_file) != NULL)
+    while (fgets(line, sizeof(line), config_file) != NULL)
         {
-            prefs = (volk_gnsssdr_arch_pref_t *) realloc(prefs, (n_arch_prefs+1) * sizeof(*prefs));
+            prefs = (volk_gnsssdr_arch_pref_t *)realloc(prefs, (n_arch_prefs + 1) * sizeof(*prefs));
             volk_gnsssdr_arch_pref_t *p = prefs + n_arch_prefs;
-            if(sscanf(line, "%s %s %s", p->name, p->impl_a, p->impl_u) == 3 && !strncmp(p->name, "volk_gnsssdr_", 5))
+            if (sscanf(line, "%s %s %s", p->name, p->impl_a, p->impl_u) == 3 && !strncmp(p->name, "volk_gnsssdr_", 5))
                 {
                     n_arch_prefs++;
                 }

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/volk_gnsssdr_rank_archs.c

@@ -29,7 +29,7 @@
 inline unsigned __popcnt(unsigned num)
 {
     unsigned pop = 0;
-    while(num)
+    while (num)
         {
             if (num & 0x1) pop++;
             num >>= 1;
@@ -39,15 +39,15 @@ inline unsigned __popcnt(unsigned num)
 #endif
 
 int volk_gnsssdr_get_index(
-        const char *impl_names[], //list of implementations by name
-        const size_t n_impls,     //number of implementations available
-        const char *impl_name     //the implementation name to find
-        )
+    const char *impl_names[],  //list of implementations by name
+    const size_t n_impls,      //number of implementations available
+    const char *impl_name      //the implementation name to find
+)
 {
     unsigned int i;
     for (i = 0; i < n_impls; i++)
         {
-            if(!strncmp(impl_names[i], impl_name, 20))
+            if (!strncmp(impl_names[i], impl_name, 20))
                 {
                     return i;
                 }
@@ -55,24 +55,24 @@ int volk_gnsssdr_get_index(
     //TODO return -1;
     //something terrible should happen here
     fprintf(stderr, "VOLK_GNSSSDR warning: no arch found, returning generic impl\n");
-    return volk_gnsssdr_get_index(impl_names, n_impls, "generic"); //but we'll fake it for now
+    return volk_gnsssdr_get_index(impl_names, n_impls, "generic");  //but we'll fake it for now
 }
 
 
 int volk_gnsssdr_rank_archs(
-        const char *kern_name,    //name of the kernel to rank
-        const char *impl_names[], //list of implementations by name
-        const int* impl_deps,     //requirement mask per implementation
-        const bool* alignment,    //alignment status of each implementation
-        size_t n_impls,            //number of implementations available
-        const bool align          //if false, filter aligned implementations
+    const char *kern_name,     //name of the kernel to rank
+    const char *impl_names[],  //list of implementations by name
+    const int *impl_deps,      //requirement mask per implementation
+    const bool *alignment,     //alignment status of each implementation
+    size_t n_impls,            //number of implementations available
+    const bool align           //if false, filter aligned implementations
 )
 {
     size_t i;
     static volk_gnsssdr_arch_pref_t *volk_gnsssdr_arch_prefs;
     static size_t n_arch_prefs = 0;
     static int prefs_loaded = 0;
-    if(!prefs_loaded)
+    if (!prefs_loaded)
         {
             n_arch_prefs = volk_gnsssdr_load_preferences(&volk_gnsssdr_arch_prefs);
             prefs_loaded = 1;
@@ -81,17 +81,17 @@ int volk_gnsssdr_rank_archs(
     // If we've defined VOLK_GENERIC to be anything, always return the
     // 'generic' kernel. Used in GR's QA code.
     char *gen_env = getenv("VOLK_GENERIC");
-    if(gen_env)
+    if (gen_env)
         {
             return volk_gnsssdr_get_index(impl_names, n_impls, "generic");
         }
 
     //now look for the function name in the prefs list
-    for(i = 0; i < n_arch_prefs; i++)
+    for (i = 0; i < n_arch_prefs; i++)
         {
-            if(!strncmp(kern_name, volk_gnsssdr_arch_prefs[i].name, sizeof(volk_gnsssdr_arch_prefs[i].name))) //found it
+            if (!strncmp(kern_name, volk_gnsssdr_arch_prefs[i].name, sizeof(volk_gnsssdr_arch_prefs[i].name)))  //found it
                 {
-                    const char *impl_name = align? volk_gnsssdr_arch_prefs[i].impl_a : volk_gnsssdr_arch_prefs[i].impl_u;
+                    const char *impl_name = align ? volk_gnsssdr_arch_prefs[i].impl_a : volk_gnsssdr_arch_prefs[i].impl_u;
                     return volk_gnsssdr_get_index(impl_names, n_impls, impl_name);
                 }
         }
@@ -101,7 +101,7 @@ int volk_gnsssdr_rank_archs(
     size_t best_index_u = 0;
     int best_value_a = -1;
     int best_value_u = -1;
-    for(i = 0; i < n_impls; i++)
+    for (i = 0; i < n_impls; i++)
         {
             const signed val = __popcnt(impl_deps[i]);
             if (alignment[i] && val > best_value_a)

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/volk_gnsssdr_rank_archs.h

@@ -23,23 +23,24 @@
 #include <stdbool.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-int volk_gnsssdr_get_index(
-    const char *impl_names[], //list of implementations by name
-    const size_t n_impls,     //number of implementations available
-    const char *impl_name     //the implementation name to find
-);
+    int volk_gnsssdr_get_index(
+        const char *impl_names[],  //list of implementations by name
+        const size_t n_impls,      //number of implementations available
+        const char *impl_name      //the implementation name to find
+    );
 
-int volk_gnsssdr_rank_archs(
-    const char *kern_name,    //name of the kernel to rank
-    const char *impl_names[], //list of implementations by name
-    const int* impl_deps,     //requirement mask per implementation
-    const bool* alignment,    //alignment status of each implementation
-    size_t n_impls,            //number of implementations available
-    const bool align          //if false, filter aligned implementations
-);
+    int volk_gnsssdr_rank_archs(
+        const char *kern_name,     //name of the kernel to rank
+        const char *impl_names[],  //list of implementations by name
+        const int *impl_deps,      //requirement mask per implementation
+        const bool *alignment,     //alignment status of each implementation
+        size_t n_impls,            //number of implementations available
+        const bool align           //if false, filter aligned implementations
+    );
 
 #ifdef __cplusplus
 }

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/tmpl/volk_gnsssdr.tmpl.c

@@ -31,80 +31,90 @@ static intptr_t __alignment_mask = 0;
 
 struct volk_gnsssdr_machine *get_machine(void)
 {
-  extern struct volk_gnsssdr_machine *volk_gnsssdr_machines[];
-  extern unsigned int n_volk_gnsssdr_machines;
-  static struct volk_gnsssdr_machine *machine = NULL;
+    extern struct volk_gnsssdr_machine *volk_gnsssdr_machines[];
+    extern unsigned int n_volk_gnsssdr_machines;
+    static struct volk_gnsssdr_machine *machine = NULL;
 
-  if(machine != NULL)
-    return machine;
-  else {
-    unsigned int max_score = 0;
-    unsigned int i;
-    struct volk_gnsssdr_machine *max_machine = NULL;
-    for(i=0; i<n_volk_gnsssdr_machines; i++) {
-      if(!(volk_gnsssdr_machines[i]->caps & (~volk_gnsssdr_get_lvarch()))) {
-        if(volk_gnsssdr_machines[i]->caps > max_score) {
-          max_score = volk_gnsssdr_machines[i]->caps;
-          max_machine = volk_gnsssdr_machines[i];
+    if (machine != NULL)
+        return machine;
+    else
+        {
+            unsigned int max_score = 0;
+            unsigned int i;
+            struct volk_gnsssdr_machine *max_machine = NULL;
+            for (i = 0; i < n_volk_gnsssdr_machines; i++)
+                {
+                    if (!(volk_gnsssdr_machines[i]->caps & (~volk_gnsssdr_get_lvarch())))
+                        {
+                            if (volk_gnsssdr_machines[i]->caps > max_score)
+                                {
+                                    max_score = volk_gnsssdr_machines[i]->caps;
+                                    max_machine = volk_gnsssdr_machines[i];
+                                }
+                        }
+                }
+            machine = max_machine;
+            //printf("Using Volk machine: %s\n", machine->name);
+            __alignment = machine->alignment;
+            __alignment_mask = (intptr_t)(__alignment - 1);
+            return machine;
         }
-      }
-    }
-    machine = max_machine;
-    //printf("Using Volk machine: %s\n", machine->name);
-    __alignment = machine->alignment;
-    __alignment_mask = (intptr_t)(__alignment-1);
-    return machine;
-  }
 }
 
 void volk_gnsssdr_list_machines(void)
 {
-  extern struct volk_gnsssdr_machine *volk_gnsssdr_machines[];
-  extern unsigned int n_volk_gnsssdr_machines;
+    extern struct volk_gnsssdr_machine *volk_gnsssdr_machines[];
+    extern unsigned int n_volk_gnsssdr_machines;
 
-  unsigned int i;
-  for(i=0; i<n_volk_gnsssdr_machines; i++) {
-    if(!(volk_gnsssdr_machines[i]->caps & (~volk_gnsssdr_get_lvarch()))) {
-        printf("%s;", volk_gnsssdr_machines[i]->name);
-    }
-  }
-  printf("\n");
+    unsigned int i;
+    for (i = 0; i < n_volk_gnsssdr_machines; i++)
+        {
+            if (!(volk_gnsssdr_machines[i]->caps & (~volk_gnsssdr_get_lvarch())))
+                {
+                    printf("%s;", volk_gnsssdr_machines[i]->name);
+                }
+        }
+    printf("\n");
 }
 
-const char* volk_gnsssdr_get_machine(void)
+const char *volk_gnsssdr_get_machine(void)
 {
-  extern struct volk_gnsssdr_machine *volk_gnsssdr_machines[];
-  extern unsigned int n_volk_gnsssdr_machines;
-  static struct volk_gnsssdr_machine *machine = NULL;
+    extern struct volk_gnsssdr_machine *volk_gnsssdr_machines[];
+    extern unsigned int n_volk_gnsssdr_machines;
+    static struct volk_gnsssdr_machine *machine = NULL;
 
-  if(machine != NULL)
-    return machine->name;
-  else {
-    unsigned int max_score = 0;
-    unsigned int i;
-    struct volk_gnsssdr_machine *max_machine = NULL;
-    for(i=0; i<n_volk_gnsssdr_machines; i++) {
-      if(!(volk_gnsssdr_machines[i]->caps & (~volk_gnsssdr_get_lvarch()))) {
-        if(volk_gnsssdr_machines[i]->caps > max_score) {
-          max_score = volk_gnsssdr_machines[i]->caps;
-          max_machine = volk_gnsssdr_machines[i];
+    if (machine != NULL)
+        return machine->name;
+    else
+        {
+            unsigned int max_score = 0;
+            unsigned int i;
+            struct volk_gnsssdr_machine *max_machine = NULL;
+            for (i = 0; i < n_volk_gnsssdr_machines; i++)
+                {
+                    if (!(volk_gnsssdr_machines[i]->caps & (~volk_gnsssdr_get_lvarch())))
+                        {
+                            if (volk_gnsssdr_machines[i]->caps > max_score)
+                                {
+                                    max_score = volk_gnsssdr_machines[i]->caps;
+                                    max_machine = volk_gnsssdr_machines[i];
+                                }
+                        }
+                }
+            machine = max_machine;
+            return machine->name;
         }
-      }
-    }
-    machine = max_machine;
-    return machine->name;
-  }
 }
 
 size_t volk_gnsssdr_get_alignment(void)
 {
-    get_machine(); //ensures alignment is set
+    get_machine();  //ensures alignment is set
     return __alignment;
 }
 
 bool volk_gnsssdr_is_aligned(const void *ptr)
 {
-    return ((intptr_t)(ptr) & __alignment_mask) == 0;
+    return ((intptr_t)(ptr)&__alignment_mask) == 0;
 }
 
 #define LV_HAVE_GENERIC
@@ -113,13 +123,12 @@ bool volk_gnsssdr_is_aligned(const void *ptr)
 %for kern in kernels:
 
 %if kern.has_dispatcher:
-#include <volk_gnsssdr/${kern.name}.h> //pulls in the dispatcher
+#include <volk_gnsssdr/${kern.name}.h>  //pulls in the dispatcher
 %endif
 
 static inline void __${kern.name}_d(${kern.arglist_full})
 {
-    %if kern.has_dispatcher:
-    ${kern.name}_dispatcher(${kern.arglist_names});
+    % if kern.has_dispatcher : ${kern.name} _dispatcher(${kern.arglist_names});
     return;
     %endif
 
@@ -131,41 +140,41 @@ static inline void __${kern.name}_d(${kern.arglist_full})
     %endfor
         0<% end_open_parens = ')'*num_open_parens %>${end_open_parens}
     )){
-        ${kern.name}_a(${kern.arglist_names});
+        ${kern.name} _a(${kern.arglist_names});
     }
     else{
-        ${kern.name}_u(${kern.arglist_names});
+        ${kern.name} _u(${kern.arglist_names});
     }
 }
 
 static inline void __init_${kern.name}(void)
 {
-    const char *name = get_machine()->${kern.name}_name;
-    const char **impl_names = get_machine()->${kern.name}_impl_names;
-    const int *impl_deps = get_machine()->${kern.name}_impl_deps;
-    const bool *alignment = get_machine()->${kern.name}_impl_alignment;
-    const size_t n_impls = get_machine()->${kern.name}_n_impls;
-    const size_t index_a = volk_gnsssdr_rank_archs(name, impl_names, impl_deps, alignment, n_impls, true/*aligned*/);
-    const size_t index_u = volk_gnsssdr_rank_archs(name, impl_names, impl_deps, alignment, n_impls, false/*unaligned*/);
-    ${kern.name}_a = get_machine()->${kern.name}_impls[index_a];
-    ${kern.name}_u = get_machine()->${kern.name}_impls[index_u];
+    const char *name = get_machine()->${kern.name} _name;
+    const char **impl_names = get_machine()->${kern.name} _impl_names;
+    const int *impl_deps = get_machine()->${kern.name} _impl_deps;
+    const bool *alignment = get_machine()->${kern.name} _impl_alignment;
+    const size_t n_impls = get_machine()->${kern.name} _n_impls;
+    const size_t index_a = volk_gnsssdr_rank_archs(name, impl_names, impl_deps, alignment, n_impls, true /*aligned*/);
+    const size_t index_u = volk_gnsssdr_rank_archs(name, impl_names, impl_deps, alignment, n_impls, false /*unaligned*/);
+    ${kern.name} _a = get_machine()->${kern.name} _impls[index_a];
+    ${kern.name} _u = get_machine()->${kern.name} _impls[index_u];
 
-    assert(${kern.name}_a);
-    assert(${kern.name}_u);
+    assert(${kern.name} _a);
+    assert(${kern.name} _u);
 
-    ${kern.name} = &__${kern.name}_d;
+    ${kern.name} = &__${kern.name} _d;
 }
 
-static inline void __${kern.name}_a(${kern.arglist_full})
+static inline void __${kern.name} _a(${kern.arglist_full})
 {
     __init_${kern.name}();
-    ${kern.name}_a(${kern.arglist_names});
+    ${kern.name} _a(${kern.arglist_names});
 }
 
-static inline void __${kern.name}_u(${kern.arglist_full})
+static inline void __${kern.name} _u(${kern.arglist_full})
 {
     __init_${kern.name}();
-    ${kern.name}_u(${kern.arglist_names});
+    ${kern.name} _u(${kern.arglist_names});
 }
 
 static inline void __${kern.name}(${kern.arglist_full})
@@ -174,34 +183,32 @@ static inline void __${kern.name}(${kern.arglist_full})
     ${kern.name}(${kern.arglist_names});
 }
 
-${kern.pname} ${kern.name}_a = &__${kern.name}_a;
-${kern.pname} ${kern.name}_u = &__${kern.name}_u;
-${kern.pname} ${kern.name}   = &__${kern.name};
+${kern.pname} ${kern.name} _a = &__${kern.name} _a;
+${kern.pname} ${kern.name} _u = &__${kern.name} _u;
+${kern.pname} ${kern.name} = &__${kern.name};
 
-void ${kern.name}_manual(${kern.arglist_full}, const char* impl_name)
+void ${kern.name} _manual(${kern.arglist_full}, const char *impl_name)
 {
     const int index = volk_gnsssdr_get_index(
-        get_machine()->${kern.name}_impl_names,
-        get_machine()->${kern.name}_n_impls,
-        impl_name
-    );
-    get_machine()->${kern.name}_impls[index](
-        ${kern.arglist_names}
-    );
+        get_machine()->${kern.name} _impl_names,
+        get_machine()->${kern.name} _n_impls,
+        impl_name);
+    get_machine()->${kern.name} _impls[index](
+        ${kern.arglist_names});
 }
 
-volk_gnsssdr_func_desc_t ${kern.name}_get_func_desc(void) {
-    const char **impl_names = get_machine()->${kern.name}_impl_names;
-    const int *impl_deps = get_machine()->${kern.name}_impl_deps;
-    const bool *alignment = get_machine()->${kern.name}_impl_alignment;
-    const size_t n_impls = get_machine()->${kern.name}_n_impls;
+volk_gnsssdr_func_desc_t ${kern.name} _get_func_desc(void)
+{
+    const char **impl_names = get_machine()->${kern.name} _impl_names;
+    const int *impl_deps = get_machine()->${kern.name} _impl_deps;
+    const bool *alignment = get_machine()->${kern.name} _impl_alignment;
+    const size_t n_impls = get_machine()->${kern.name} _n_impls;
     volk_gnsssdr_func_desc_t desc = {
         impl_names,
         impl_deps,
         alignment,
-        n_impls
-    };
+        n_impls};
     return desc;
 }
 
-%endfor
+% endfor

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/tmpl/volk_gnsssdr.tmpl.h

@@ -42,7 +42,7 @@ typedef struct volk_gnsssdr_func_desc
 VOLK_API void volk_gnsssdr_list_machines(void);
 
 //! Returns the name of the machine this instance will use
-VOLK_API const char* volk_gnsssdr_get_machine(void);
+VOLK_API const char *volk_gnsssdr_get_machine(void);
 
 //! Get the machine alignment in bytes
 VOLK_API size_t volk_gnsssdr_get_alignment(void);
@@ -74,19 +74,19 @@ VOLK_API bool volk_gnsssdr_is_aligned(const void *ptr);
 extern VOLK_API ${kern.pname} ${kern.name};
 
 //! A function pointer to the fastest aligned implementation
-extern VOLK_API ${kern.pname} ${kern.name}_a;
+extern VOLK_API ${kern.pname} ${kern.name} _a;
 
 //! A function pointer to the fastest unaligned implementation
-extern VOLK_API ${kern.pname} ${kern.name}_u;
+extern VOLK_API ${kern.pname} ${kern.name} _u;
 
 //! Call into a specific implementation given by name
-extern VOLK_API void ${kern.name}_manual(${kern.arglist_full}, const char* impl_name);
+extern VOLK_API void ${kern.name} _manual(${kern.arglist_full}, const char *impl_name);
 
 //! Get description parameters for this kernel
-extern VOLK_API volk_gnsssdr_func_desc_t ${kern.name}_get_func_desc(void);
-%endfor
+extern VOLK_API volk_gnsssdr_func_desc_t ${kern.name} _get_func_desc(void);
+% endfor
 
-__VOLK_DECL_END
+        __VOLK_DECL_END
 
 
 #endif /*INCLUDED_VOLK_GNSSSDR_RUNTIME*/

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/tmpl/volk_gnsssdr_config_fixed.tmpl.h

@@ -21,7 +21,8 @@
 
 %for i, arch in enumerate(archs):
 //#ifndef LV_${arch.name.upper()}
-#define LV_${arch.name.upper()} ${i}
+#define LV_$ \
+    {arch.name.upper()} $ { i }
 //#endif
 %endfor
 

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/tmpl/volk_gnsssdr_cpu.tmpl.c

@@ -24,50 +24,54 @@
 struct VOLK_CPU volk_gnsssdr_cpu;
 
 #if defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_X64)
-    #define VOLK_CPU_x86
+#define VOLK_CPU_x86
 #endif
 
 #if defined(VOLK_CPU_x86)
 
 //implement get cpuid for gcc compilers using a system or local copy of cpuid.h
 #if defined(__GNUC__)
-    #include <cpuid.h>
-    #define cpuid_x86(op, r) __get_cpuid(op, (unsigned int *)r+0, (unsigned int *)r+1, (unsigned int *)r+2, (unsigned int *)r+3)
-    #define cpuid_x86_count(op, count, regs) __cpuid_count(op, count, *((unsigned int*)regs), *((unsigned int*)regs+1), *((unsigned int*)regs+2), *((unsigned int*)regs+3))
+#include <cpuid.h>
+#define cpuid_x86(op, r) __get_cpuid(op, (unsigned int *)r + 0, (unsigned int *)r + 1, (unsigned int *)r + 2, (unsigned int *)r + 3)
+#define cpuid_x86_count(op, count, regs) __cpuid_count(op, count, *((unsigned int *)regs), *((unsigned int *)regs + 1), *((unsigned int *)regs + 2), *((unsigned int *)regs + 3))
 
-    /* Return Intel AVX extended CPU capabilities register.
+/* Return Intel AVX extended CPU capabilities register.
      * This function will bomb on non-AVX-capable machines, so
      * check for AVX capability before executing.
      */
-    #if ((__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 2) || (__clang_major__ >= 3)) && defined(HAVE_XGETBV)
-    static inline unsigned long long _xgetbv(unsigned int index){
-        unsigned int eax, edx;
-        __VOLK_ASM __VOLK_VOLATILE ("xgetbv" : "=a"(eax), "=d"(edx) : "c"(index));
-        return ((unsigned long long)edx << 32) | eax;
-    }
-    #define __xgetbv() _xgetbv(0)
-    #else
-    #define __xgetbv() 0
-    #endif
+#if ((__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 2) || (__clang_major__ >= 3)) && defined(HAVE_XGETBV)
+static inline unsigned long long _xgetbv(unsigned int index)
+{
+    unsigned int eax, edx;
+    __VOLK_ASM __VOLK_VOLATILE("xgetbv"
+                               : "=a"(eax), "=d"(edx)
+                               : "c"(index));
+    return ((unsigned long long)edx << 32) | eax;
+}
+#define __xgetbv() _xgetbv(0)
+#else
+#define __xgetbv() 0
+#endif
 
 //implement get cpuid for MSVC compilers using __cpuid intrinsic
 #elif defined(_MSC_VER) && defined(HAVE_INTRIN_H)
-    #include <intrin.h>
-    #define cpuid_x86(op, r) __cpuid(((int*)r), op)
+#include <intrin.h>
+#define cpuid_x86(op, r) __cpuid(((int *)r), op)
 
-    #if defined(_XCR_XFEATURE_ENABLED_MASK)
-    #define __xgetbv() _xgetbv(_XCR_XFEATURE_ENABLED_MASK)
-    #else
-    #define __xgetbv() 0
-    #endif
+#if defined(_XCR_XFEATURE_ENABLED_MASK)
+#define __xgetbv() _xgetbv(_XCR_XFEATURE_ENABLED_MASK)
+#else
+#define __xgetbv() 0
+#endif
 
 #else
-    #error "A get cpuid for volk_gnsssdr is not available on this compiler..."
-#endif //defined(__GNUC__)
+#error "A get cpuid for volk_gnsssdr is not available on this compiler..."
+#endif  //defined(__GNUC__)
 
-#endif //defined(VOLK_CPU_x86)
+#endif  //defined(VOLK_CPU_x86)
 
-static inline unsigned int cpuid_count_x86_bit(unsigned int level, unsigned int count, unsigned int reg, unsigned int bit) {
+static inline unsigned int cpuid_count_x86_bit(unsigned int level, unsigned int count, unsigned int reg, unsigned int bit)
+{
 #if defined(VOLK_CPU_x86)
     unsigned int regs[4] = {0};
     cpuid_x86_count(level, count, regs);
@@ -77,10 +81,11 @@ static inline unsigned int cpuid_count_x86_bit(unsigned int level, unsigned int
 #endif
 }
 
-static inline unsigned int cpuid_x86_bit(unsigned int reg, unsigned int op, unsigned int bit) {
+static inline unsigned int cpuid_x86_bit(unsigned int reg, unsigned int op, unsigned int bit)
+{
 #if defined(VOLK_CPU_x86)
     unsigned int regs[4];
-    memset(regs, 0, sizeof(unsigned int)*4);
+    memset(regs, 0, sizeof(unsigned int) * 4);
     cpuid_x86(op, regs);
     return regs[reg] >> bit & 0x01;
 #else
@@ -88,10 +93,11 @@ static inline unsigned int cpuid_x86_bit(unsigned int reg, unsigned int op, unsi
 #endif
 }
 
-static inline unsigned int check_extended_cpuid(unsigned int val) {
+static inline unsigned int check_extended_cpuid(unsigned int val)
+{
 #if defined(VOLK_CPU_x86)
     unsigned int regs[4];
-    memset(regs, 0, sizeof(unsigned int)*4);
+    memset(regs, 0, sizeof(unsigned int) * 4);
     cpuid_x86(0x80000000, regs);
     return regs[0] >= val;
 #else
@@ -99,7 +105,8 @@ static inline unsigned int check_extended_cpuid(unsigned int val) {
 #endif
 }
 
-static inline unsigned int get_avx_enabled(void) {
+static inline unsigned int get_avx_enabled(void)
+{
 #if defined(VOLK_CPU_x86)
     return __xgetbv() & 0x6;
 #else
@@ -107,7 +114,8 @@ static inline unsigned int get_avx_enabled(void) {
 #endif
 }
 
-static inline unsigned int get_avx2_enabled(void) {
+static inline unsigned int get_avx2_enabled(void)
+{
 #if defined(VOLK_CPU_x86)
     return __xgetbv() & 0x6;
 #else
@@ -117,28 +125,30 @@ static inline unsigned int get_avx2_enabled(void) {
 
 //neon detection is linux specific
 #if defined(__arm__) && defined(__linux__)
-    #include <asm/hwcap.h>
-    #include <linux/auxvec.h>
-    #include <stdio.h>
-    #define VOLK_CPU_ARM
+#include <asm/hwcap.h>
+#include <linux/auxvec.h>
+#include <stdio.h>
+#define VOLK_CPU_ARM
 #endif
 
-static int has_neon(void){
+static int has_neon(void)
+{
 #if defined(VOLK_CPU_ARM)
     FILE *auxvec_f;
     unsigned long auxvec[2];
     unsigned int found_neon = 0;
     auxvec_f = fopen("/proc/self/auxv", "rb");
-    if(!auxvec_f) return 0;
+    if (!auxvec_f) return 0;
 
     size_t r = 1;
     //so auxv is basically 32b of ID and 32b of value
     //so it goes like this
-    while(!found_neon && r) {
-      r = fread(auxvec, sizeof(unsigned long), 2, auxvec_f);
-      if((auxvec[0] == AT_HWCAP) && (auxvec[1] & HWCAP_NEON))
-        found_neon = 1;
-    }
+    while (!found_neon && r)
+        {
+            r = fread(auxvec, sizeof(unsigned long), 2, auxvec_f);
+            if ((auxvec[0] == AT_HWCAP) && (auxvec[1] & HWCAP_NEON))
+                found_neon = 1;
+        }
 
     fclose(auxvec_f);
     return found_neon;
@@ -148,50 +158,59 @@ static int has_neon(void){
 }
 
 %for arch in archs:
-static int i_can_has_${arch.name} (void) {
+static int i_can_has_${arch.name} (void)
+{
     %for check, params in arch.checks:
     if (${check}(<% joined_params = ', '.join(params)%>${joined_params}) == 0) return 0;
-    %endfor
-    return 1;
+    % endfor return 1;
 }
-%endfor
+% endfor
 
 #if defined(HAVE_FENV_H)
-    #if defined(FE_TONEAREST)
-        #include <fenv.h>
-        static inline void set_float_rounding(void){
-            fesetround(FE_TONEAREST);
-        }
-    #else
-        static inline void set_float_rounding(void){
-            //do nothing
-        }
-    #endif
-#elif defined(_MSC_VER)
-    #include <float.h>
-    static inline void set_float_rounding(void){
-        unsigned int cwrd;
-        _controlfp_s(&cwrd, 0, 0);
-        _controlfp_s(&cwrd, _RC_NEAR, _MCW_RC);
-    }
+#if defined(FE_TONEAREST)
+#include <fenv.h>
+    static inline void
+    set_float_rounding(void)
+{
+    fesetround(FE_TONEAREST);
+}
 #else
-    static inline void set_float_rounding(void){
-        //do nothing
-    }
+    static inline void
+    set_float_rounding(void)
+{
+    //do nothing
+}
+#endif
+#elif defined(_MSC_VER)
+#include <float.h>
+    static inline void
+    set_float_rounding(void)
+{
+    unsigned int cwrd;
+    _controlfp_s(&cwrd, 0, 0);
+    _controlfp_s(&cwrd, _RC_NEAR, _MCW_RC);
+}
+#else
+    static inline void
+    set_float_rounding(void)
+{
+    //do nothing
+}
 #endif
 
-void volk_gnsssdr_cpu_init() {
+void volk_gnsssdr_cpu_init()
+{
     %for arch in archs:
     volk_gnsssdr_cpu.has_${arch.name} = &i_can_has_${arch.name};
-    %endfor
-    set_float_rounding();
+    % endfor
+        set_float_rounding();
 }
 
-unsigned int volk_gnsssdr_get_lvarch() {
+unsigned int volk_gnsssdr_get_lvarch()
+{
     unsigned int retval = 0;
     volk_gnsssdr_cpu_init();
     %for arch in archs:
     retval += volk_gnsssdr_cpu.has_${arch.name}() << LV_${arch.name.upper()};
-    %endfor
-    return retval;
+    % endfor return retval;
 }

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/tmpl/volk_gnsssdr_cpu.tmpl.h

@@ -23,16 +23,17 @@
 
 __VOLK_DECL_BEGIN
 
-struct VOLK_CPU {
+struct VOLK_CPU
+{
     %for arch in archs:
     int (*has_${arch.name}) ();
-    %endfor
+    % endfor
 };
 
 extern struct VOLK_CPU volk_gnsssdr_cpu;
 
-void volk_gnsssdr_cpu_init ();
-unsigned int volk_gnsssdr_get_lvarch ();
+void volk_gnsssdr_cpu_init();
+unsigned int volk_gnsssdr_get_lvarch();
 
 __VOLK_DECL_END
 

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/tmpl/volk_gnsssdr_machine_xxx.tmpl.c

@@ -20,7 +20,11 @@
 <% arch_names = this_machine.arch_names %>
 
 %for arch in this_machine.archs:
-#define LV_HAVE_${arch.name.upper()} 1
+#define LV_HAVE_$         \
+    {                     \
+        arch.name.upper() \
+    }                     \
+    1
 %endfor
 
 #include <volk_gnsssdr/volk_gnsssdr_common.h>
@@ -35,7 +39,9 @@
 #include <volk_gnsssdr/${kern.name}.h>
 %endfor
 
-struct volk_gnsssdr_machine volk_gnsssdr_machine_${this_machine.name} = {
+struct volk_gnsssdr_machine volk_gnsssdr_machine_$
+{
+    this_machine.name} = {
 <% make_arch_have_list = (' | '.join(['(1 << LV_%s)'%a.name.upper() for a in this_machine.archs])) %>    ${make_arch_have_list},
 <% this_machine_name = "\""+this_machine.name+"\"" %>    ${this_machine_name},
     ${this_machine.alignment},

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/tmpl/volk_gnsssdr_machines.tmpl.c

@@ -22,10 +22,10 @@
 
 struct volk_gnsssdr_machine *volk_gnsssdr_machines[] = {
 %for machine in machines:
-#ifdef LV_MACHINE_${machine.name.upper()}
+#ifdef LV_MACHINE_${machine.name.upper() }
 &volk_gnsssdr_machine_${machine.name},
 #endif
 %endfor
 };
 
-unsigned int n_volk_gnsssdr_machines = sizeof(volk_gnsssdr_machines)/sizeof(*volk_gnsssdr_machines);
+unsigned int n_volk_gnsssdr_machines = sizeof(volk_gnsssdr_machines) / sizeof(*volk_gnsssdr_machines);

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/tmpl/volk_gnsssdr_machines.tmpl.h

@@ -27,26 +27,30 @@
 
 __VOLK_DECL_BEGIN
 
-struct volk_gnsssdr_machine {
-    const unsigned int caps; //capabilities (i.e., archs compiled into this machine, in the volk_gnsssdr_get_lvarch format)
+struct volk_gnsssdr_machine
+{
+    const unsigned int caps;  //capabilities (i.e., archs compiled into this machine, in the volk_gnsssdr_get_lvarch format)
     const char *name;
-    const size_t alignment; //the maximum byte alignment required for functions in this library
+    const size_t alignment;  //the maximum byte alignment required for functions in this library
     %for kern in kernels:
     const char *${kern.name}_name;
-    const char *${kern.name}_impl_names[<%len_archs=len(archs)%>${len_archs}];
-    const int ${kern.name}_impl_deps[${len_archs}];
-    const bool ${kern.name}_impl_alignment[${len_archs}];
-    const ${kern.pname} ${kern.name}_impls[${len_archs}];
-    const size_t ${kern.name}_n_impls;
-    %endfor
+    const char *${kern.name} _impl_names[<% len_archs = len(archs) %> ${len_archs}];
+    const int ${kern.name} _impl_deps[${len_archs}];
+    const bool ${kern.name} _impl_alignment[${len_archs}];
+    const ${kern.pname} ${kern.name} _impls[${len_archs}];
+    const size_t ${kern.name} _n_impls;
+    % endfor
 };
 
 %for machine in machines:
-#ifdef LV_MACHINE_${machine.name.upper()}
-extern struct volk_gnsssdr_machine volk_gnsssdr_machine_${machine.name};
+#ifdef LV_MACHINE_${machine.name.upper() }
+extern struct volk_gnsssdr_machine volk_gnsssdr_machine_$
+{
+    machine.name
+};
 #endif
-%endfor
+% endfor
 
-__VOLK_DECL_END
+        __VOLK_DECL_END
 
-#endif //INCLUDED_LIBVOLK_GNSSSDR_MACHINES_H
+#endif  //INCLUDED_LIBVOLK_GNSSSDR_MACHINES_H

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/tmpl/volk_gnsssdr_typedefs.tmpl.h

@@ -24,6 +24,6 @@
 
 %for kern in kernels:
 typedef void (*${kern.pname})(${kern.arglist_types});
-%endfor
+% endfor
 
 #endif /*INCLUDED_VOLK_GNSSSDR_TYPEDEFS*/