From d72e56a9566c7fc36d6a019c33e2e3b117925f3d Mon Sep 17 00:00:00 2001 From: Sachin Pisal Date: Tue, 14 Jan 2025 15:18:55 -0800 Subject: [PATCH] Formatting Signed-off-by: Sachin Pisal --- runtime/cudaq/dynamics/helpers.cpp | 198 +++++++++++++++------------- runtime/cudaq/helpers.h | 56 ++++---- unittests/dynamics/test_helpers.cpp | 193 +++++++++++++-------------- 3 files changed, 227 insertions(+), 220 deletions(-) diff --git a/runtime/cudaq/dynamics/helpers.cpp b/runtime/cudaq/dynamics/helpers.cpp index ad86a2c26b..e6c50d14a0 100644 --- a/runtime/cudaq/dynamics/helpers.cpp +++ b/runtime/cudaq/dynamics/helpers.cpp @@ -7,129 +7,141 @@ ******************************************************************************/ #include "cudaq/helpers.h" -#include #include +#include namespace cudaq { // Aggregate parameters from multiple mappings. -std::map OperatorHelpers::aggregate_parameters(const std::vector> ¶meter_mappings) { - std::map parameter_descriptions; - - for (const auto &descriptions : parameter_mappings) { - for (const auto &[key, new_desc] : descriptions) { - if (!parameter_descriptions[key].empty() && !new_desc.empty()) { - parameter_descriptions[key] += "\n---\n" + new_desc; - } else { - parameter_descriptions[key] = new_desc; - } - } +std::map OperatorHelpers::aggregate_parameters( + const std::vector> ¶meter_mappings) { + std::map parameter_descriptions; + + for (const auto &descriptions : parameter_mappings) { + for (const auto &[key, new_desc] : descriptions) { + if (!parameter_descriptions[key].empty() && !new_desc.empty()) { + parameter_descriptions[key] += "\n---\n" + new_desc; + } else { + parameter_descriptions[key] = new_desc; + } } + } - return parameter_descriptions; + return parameter_descriptions; } // Extract documentation for a specific parameter from docstring. -std::string OperatorHelpers::parameter_docs(const std::string ¶m_name, const std::string &docs) { - if (param_name.empty() || docs.empty()) { - return ""; - } - - try { - std::regex keyword_pattern(R"(^\s*(Arguments|Args):\s*$)", std::regex::multiline); - std::regex param_pattern(R"(^\s*)" + param_name + R"(\s*(\(.*\))?:\s*(.*)$)", std::regex::multiline); - - std::smatch match; - std::sregex_iterator it(docs.begin(), docs.end(), keyword_pattern); - std::sregex_iterator end; - - if (it != end) { - std::string params_section = docs.substr(it->position() + it->length()); - if(std::regex_search(params_section, match, param_pattern)) { - std::string param_docs = match.str(2); - return std::regex_replace(param_docs, std::regex(R"(\s+)"), " "); - } - } - } catch (...) { - return ""; +std::string OperatorHelpers::parameter_docs(const std::string ¶m_name, + const std::string &docs) { + if (param_name.empty() || docs.empty()) { + return ""; + } + + try { + std::regex keyword_pattern(R"(^\s*(Arguments|Args):\s*$)", + std::regex::multiline); + std::regex param_pattern(R"(^\s*)" + param_name + + R"(\s*(\(.*\))?:\s*(.*)$)", + std::regex::multiline); + + std::smatch match; + std::sregex_iterator it(docs.begin(), docs.end(), keyword_pattern); + std::sregex_iterator end; + + if (it != end) { + std::string params_section = docs.substr(it->position() + it->length()); + if (std::regex_search(params_section, match, param_pattern)) { + std::string param_docs = match.str(2); + return std::regex_replace(param_docs, std::regex(R"(\s+)"), " "); + } } - + } catch (...) { return ""; + } + + return ""; } // Extract positional arguments and keyword-only arguments. -std::pair, std::map> OperatorHelpers::args_from_kwargs(const std::map &kwargs, - const std::vector &required_args, const std::vector &kwonly_args) { - std::vector extracted_args; - std::map kwonly_dict; - - for (const auto &arg : required_args) { - if (kwargs.count(arg)) { - extracted_args.push_back(kwargs.at(arg)); - } else { - throw std::invalid_argument("Missing required argument: " + arg); - } +std::pair, std::map> +OperatorHelpers::args_from_kwargs( + const std::map &kwargs, + const std::vector &required_args, + const std::vector &kwonly_args) { + std::vector extracted_args; + std::map kwonly_dict; + + for (const auto &arg : required_args) { + if (kwargs.count(arg)) { + extracted_args.push_back(kwargs.at(arg)); + } else { + throw std::invalid_argument("Missing required argument: " + arg); } + } - for (const auto &arg : kwonly_args) { - if (kwargs.count(arg)) { - kwonly_dict[arg] = kwargs.at(arg); - } + for (const auto &arg : kwonly_args) { + if (kwargs.count(arg)) { + kwonly_dict[arg] = kwargs.at(arg); } + } - return {extracted_args, kwonly_dict}; + return {extracted_args, kwonly_dict}; } // Generate all possible quantum states for given degrees and dimensions -std::vector OperatorHelpers::generate_all_states(const std::vector °rees, const std::map &dimensions) { - if (degrees.empty()) { - return {}; - } - - std::vector> states; - for (int state = 0; state < dimensions.at(degrees[0]); state++) { - states.push_back({std::to_string(state)}); +std::vector +OperatorHelpers::generate_all_states(const std::vector °rees, + const std::map &dimensions) { + if (degrees.empty()) { + return {}; + } + + std::vector> states; + for (int state = 0; state < dimensions.at(degrees[0]); state++) { + states.push_back({std::to_string(state)}); + } + + for (size_t i = 1; i < degrees.size(); i++) { + std::vector> new_states; + for (const auto ¤t : states) { + for (int state = 0; state < dimensions.at(degrees[i]); state++) { + auto new_entry = current; + new_entry.push_back(std::to_string(state)); + new_states.push_back(new_entry); + } } - - for (size_t i = 1; i < degrees.size(); i++) { - std::vector> new_states; - for (const auto ¤t : states) { - for (int state = 0; state < dimensions.at(degrees[i]); state++) { - auto new_entry = current; - new_entry.push_back(std::to_string(state)); - new_states.push_back(new_entry); - } - } - states = new_states; - } - - std::vector result; - for (const auto &state : states) { - std::ostringstream joined; - for (const auto &s : state) { - joined << s; - } - result.push_back(joined.str()); + states = new_states; + } + + std::vector result; + for (const auto &state : states) { + std::ostringstream joined; + for (const auto &s : state) { + joined << s; } - return result; + result.push_back(joined.str()); + } + return result; } // Permute a given eigen matrix -void OperatorHelpers::permute_matrix(Eigen::MatrixXcd &matrix, const std::vector &permutation) { - Eigen::MatrixXcd permuted_matrix(matrix.rows(), matrix.cols()); +void OperatorHelpers::permute_matrix(Eigen::MatrixXcd &matrix, + const std::vector &permutation) { + Eigen::MatrixXcd permuted_matrix(matrix.rows(), matrix.cols()); - for (size_t i = 0; i < permutation.size(); i++) { - for (size_t j = 0; j < permutation.size(); j++) { - permuted_matrix(i, j) = matrix(permutation[i], permutation[j]); - } + for (size_t i = 0; i < permutation.size(); i++) { + for (size_t j = 0; j < permutation.size(); j++) { + permuted_matrix(i, j) = matrix(permutation[i], permutation[j]); } + } - matrix = permuted_matrix; + matrix = permuted_matrix; } // Canonicalize degrees by sorting in descending order -std::vector OperatorHelpers::canonicalize_degrees(const std::vector °rees) { - std::vector sorted_degrees = degrees; - std::sort(sorted_degrees.rbegin(), sorted_degrees.rend()); - return sorted_degrees; +std::vector +OperatorHelpers::canonicalize_degrees(const std::vector °rees) { + std::vector sorted_degrees = degrees; + std::sort(sorted_degrees.rbegin(), sorted_degrees.rend()); + return sorted_degrees; } -} \ No newline at end of file +} // namespace cudaq \ No newline at end of file diff --git a/runtime/cudaq/helpers.h b/runtime/cudaq/helpers.h index 488ff3bf0c..52bb131d0c 100644 --- a/runtime/cudaq/helpers.h +++ b/runtime/cudaq/helpers.h @@ -8,35 +8,43 @@ #pragma once -#include -#include -#include +#include #include #include -#include +#include #include -#include +#include +#include +#include namespace cudaq { class OperatorHelpers { public: - // Aggregate parameters from multiple mappings. - static std::map aggregate_parameters(const std::vector> ¶meter_mappings); - - // Extract documentation for a specific parameter from docstring. - static std::string parameter_docs(const std::string ¶m_name, const std::string &docs); - - // Extract positional arguments and keyword-only arguments. - static std::pair, std::map> args_from_kwargs(const std::map &kwargs, - const std::vector &required_args, const std::vector &kwonly_args); - - // Generate all possible quantum states for given degrees and dimensions. - static std::vector generate_all_states(const std::vector °rees, const std::map &dimensions); - - // Permute a given Eigen matrix. - static void permute_matrix(Eigen::MatrixXcd &matrix, const std::vector &permutation); - - // Canonicalize degrees by sorting in descending order. - static std::vector canonicalize_degrees(const std::vector °rees); + // Aggregate parameters from multiple mappings. + static std::map + aggregate_parameters(const std::vector> + ¶meter_mappings); + + // Extract documentation for a specific parameter from docstring. + static std::string parameter_docs(const std::string ¶m_name, + const std::string &docs); + + // Extract positional arguments and keyword-only arguments. + static std::pair, std::map> + args_from_kwargs(const std::map &kwargs, + const std::vector &required_args, + const std::vector &kwonly_args); + + // Generate all possible quantum states for given degrees and dimensions. + static std::vector + generate_all_states(const std::vector °rees, + const std::map &dimensions); + + // Permute a given Eigen matrix. + static void permute_matrix(Eigen::MatrixXcd &matrix, + const std::vector &permutation); + + // Canonicalize degrees by sorting in descending order. + static std::vector canonicalize_degrees(const std::vector °rees); }; -} \ No newline at end of file +} // namespace cudaq \ No newline at end of file diff --git a/unittests/dynamics/test_helpers.cpp b/unittests/dynamics/test_helpers.cpp index 9e471a29bd..aa14cb5c10 100644 --- a/unittests/dynamics/test_helpers.cpp +++ b/unittests/dynamics/test_helpers.cpp @@ -13,177 +13,164 @@ using namespace cudaq; TEST(OperatorHelpersTest, AggregateParameters_MultipleMappings) { - std::vector> mappings = { - {{"alpha", "Parameter A"}, {"beta", "Parameter B"}}, {{"alpha", "Updated Parameter A"}, {"gamma", "New Parameter"}} - }; + std::vector> mappings = { + {{"alpha", "Parameter A"}, {"beta", "Parameter B"}}, + {{"alpha", "Updated Parameter A"}, {"gamma", "New Parameter"}}}; - auto result = OperatorHelpers::aggregate_parameters(mappings); + auto result = OperatorHelpers::aggregate_parameters(mappings); - EXPECT_EQ(result["alpha"], "Parameter A\n---\nUpdated Parameter A"); - EXPECT_EQ(result["beta"], "Parameter B"); - EXPECT_EQ(result["gamma"], "New Parameter"); + EXPECT_EQ(result["alpha"], "Parameter A\n---\nUpdated Parameter A"); + EXPECT_EQ(result["beta"], "Parameter B"); + EXPECT_EQ(result["gamma"], "New Parameter"); } TEST(OperatorHelpersTest, AggregateParameters_EmptyMappings) { - std::vector> mappings; - auto result = OperatorHelpers::aggregate_parameters(mappings); + std::vector> mappings; + auto result = OperatorHelpers::aggregate_parameters(mappings); - EXPECT_TRUE(result.empty()); + EXPECT_TRUE(result.empty()); } TEST(OperatorHelpersTest, ParameterDocs_ValidExtraction) { - std::string docstring = - "Description of function.\n" - "Arguments:\n" - " alpha (float): The first parameter.\n" - " beta (int): The second parameter."; + std::string docstring = "Description of function.\n" + "Arguments:\n" + " alpha (float): The first parameter.\n" + " beta (int): The second parameter."; - auto result = OperatorHelpers::parameter_docs("alpha", docstring); - EXPECT_EQ(result, "The first parameter."); + auto result = OperatorHelpers::parameter_docs("alpha", docstring); + EXPECT_EQ(result, "The first parameter."); - result = OperatorHelpers::parameter_docs("beta", docstring); - EXPECT_EQ(result, "The second parameter."); + result = OperatorHelpers::parameter_docs("beta", docstring); + EXPECT_EQ(result, "The second parameter."); } TEST(OperatorHelpersTest, ParameterDocs_InvalidParam) { - std::string docstring = - "Description of function.\n" - "Arguments:\n" - " alpha (float): The first parameter.\n" - " beta (int): The second parameter."; + std::string docstring = "Description of function.\n" + "Arguments:\n" + " alpha (float): The first parameter.\n" + " beta (int): The second parameter."; - auto result = OperatorHelpers::parameter_docs("gamma", docstring); - EXPECT_EQ(result, ""); + auto result = OperatorHelpers::parameter_docs("gamma", docstring); + EXPECT_EQ(result, ""); } TEST(OperatorHelpersTest, ParameterDocs_EmptyDocString) { - std::string docstring = ""; - auto result = OperatorHelpers::parameter_docs("alpha", docstring); - EXPECT_EQ(result, ""); + std::string docstring = ""; + auto result = OperatorHelpers::parameter_docs("alpha", docstring); + EXPECT_EQ(result, ""); } TEST(OperatorHelpersTest, GenerateAllStates_TwoQubits) { - std::vector degrees = {0, 1}; - std::map dimensions = {{0, 2}, {1, 2}}; + std::vector degrees = {0, 1}; + std::map dimensions = {{0, 2}, {1, 2}}; - auto states = OperatorHelpers::generate_all_states(degrees, dimensions); - std::vector expected_states = {"00", "01", "10", "11"}; + auto states = OperatorHelpers::generate_all_states(degrees, dimensions); + std::vector expected_states = {"00", "01", "10", "11"}; - EXPECT_EQ(states, expected_states); + EXPECT_EQ(states, expected_states); } TEST(OperatorHelpersTest, GenerateAllStates_ThreeQubits) { - std::vector degrees = {0, 1, 2}; - std::map dimensions = {{0, 2}, {1, 2}, {2, 2}}; + std::vector degrees = {0, 1, 2}; + std::map dimensions = {{0, 2}, {1, 2}, {2, 2}}; - auto states = OperatorHelpers::generate_all_states(degrees, dimensions); - std::vector expected_states = {"000", "001", "010", "011", "100", "101", "110", "111"}; + auto states = OperatorHelpers::generate_all_states(degrees, dimensions); + std::vector expected_states = {"000", "001", "010", "011", + "100", "101", "110", "111"}; - EXPECT_EQ(states, expected_states); + EXPECT_EQ(states, expected_states); } TEST(OperatorHelpersTest, GenerateAllStates_EmptyDegrees) { - std::vector degrees; - std::map dimensions; + std::vector degrees; + std::map dimensions; - auto states = OperatorHelpers::generate_all_states(degrees, dimensions); - EXPECT_TRUE(states.empty()); + auto states = OperatorHelpers::generate_all_states(degrees, dimensions); + EXPECT_TRUE(states.empty()); } TEST(OperatorHelpersTest, GenerateAllStates_MissingDegreesInMap) { - std::vector degrees = {0, 1, 2}; - std::map dimensions = {{0, 2}, {1, 2}}; + std::vector degrees = {0, 1, 2}; + std::map dimensions = {{0, 2}, {1, 2}}; - EXPECT_THROW(OperatorHelpers::generate_all_states(degrees, dimensions), std::out_of_range); + EXPECT_THROW(OperatorHelpers::generate_all_states(degrees, dimensions), + std::out_of_range); } TEST(OperatorHelpersTest, PermuteMatrix_SingleSwap) { - Eigen::MatrixXcd matrix(2, 2); - matrix << 1, 2, - 3, 4; + Eigen::MatrixXcd matrix(2, 2); + matrix << 1, 2, 3, 4; - // Swap rows and columns - std::vector permutation = {1, 0}; + // Swap rows and columns + std::vector permutation = {1, 0}; - OperatorHelpers::permute_matrix(matrix, permutation); + OperatorHelpers::permute_matrix(matrix, permutation); - Eigen::MatrixXcd expected(2, 2); - expected << 4, 3, - 2, 1; + Eigen::MatrixXcd expected(2, 2); + expected << 4, 3, 2, 1; - EXPECT_EQ(matrix, expected); + EXPECT_EQ(matrix, expected); } TEST(OperatorHelpersTest, PermuteMatrix_IdentityPermutation) { - Eigen::MatrixXcd matrix(3, 3); - matrix << 1, 2, 3, - 4, 5, 6, - 7, 8, 9; + Eigen::MatrixXcd matrix(3, 3); + matrix << 1, 2, 3, 4, 5, 6, 7, 8, 9; - // No change - std::vector permutation = {0, 1, 2}; + // No change + std::vector permutation = {0, 1, 2}; - OperatorHelpers::permute_matrix(matrix, permutation); + OperatorHelpers::permute_matrix(matrix, permutation); - Eigen::MatrixXcd expected(3, 3); - expected << 1, 2, 3, - 4, 5, 6, - 7, 8, 9; + Eigen::MatrixXcd expected(3, 3); + expected << 1, 2, 3, 4, 5, 6, 7, 8, 9; - EXPECT_EQ(matrix, expected); + EXPECT_EQ(matrix, expected); } TEST(OperatorHelpersTest, CanonicalizeDegrees_SortedDescending) { - std::vector degrees = {3, 1, 2}; - auto sorted = OperatorHelpers::canonicalize_degrees(degrees); - EXPECT_EQ(sorted, (std::vector{3, 2, 1})); + std::vector degrees = {3, 1, 2}; + auto sorted = OperatorHelpers::canonicalize_degrees(degrees); + EXPECT_EQ(sorted, (std::vector{3, 2, 1})); } TEST(OperatorHelpersTest, CanonicalizeDegrees_AlreadySorted) { - std::vector degrees = {5, 4, 3, 2, 1}; - auto sorted = OperatorHelpers::canonicalize_degrees(degrees); - EXPECT_EQ(sorted, (std::vector{5, 4, 3, 2, 1})); + std::vector degrees = {5, 4, 3, 2, 1}; + auto sorted = OperatorHelpers::canonicalize_degrees(degrees); + EXPECT_EQ(sorted, (std::vector{5, 4, 3, 2, 1})); } TEST(OperatorHelpersTest, CanonicalizeDegrees_EmptyList) { - std::vector degrees; - auto sorted = OperatorHelpers::canonicalize_degrees(degrees); - EXPECT_TRUE(sorted.empty()); + std::vector degrees; + auto sorted = OperatorHelpers::canonicalize_degrees(degrees); + EXPECT_TRUE(sorted.empty()); } TEST(OperatorHelpersTest, ArgsFromKwargs_ValidArgs) { - std::map kwargs = { - {"alpha", "0.5"}, - {"beta", "1.0"}, - {"gamma", "2.0"} - }; + std::map kwargs = { + {"alpha", "0.5"}, {"beta", "1.0"}, {"gamma", "2.0"}}; - std::vector required_args = {"alpha", "beta"}; - std::vector kwonly_args = {"gamma"}; + std::vector required_args = {"alpha", "beta"}; + std::vector kwonly_args = {"gamma"}; - auto [args, kwonly] = OperatorHelpers::args_from_kwargs(kwargs, required_args, kwonly_args); + auto [args, kwonly] = + OperatorHelpers::args_from_kwargs(kwargs, required_args, kwonly_args); - EXPECT_EQ(args.size(), 2); - EXPECT_EQ(args[0], "0.5"); - EXPECT_EQ(args[1], "1.0"); - - EXPECT_EQ(kwonly.size(), 1); - EXPECT_EQ(kwonly["gamma"], "2.0"); -} + EXPECT_EQ(args.size(), 2); + EXPECT_EQ(args[0], "0.5"); + EXPECT_EQ(args[1], "1.0"); + EXPECT_EQ(kwonly.size(), 1); + EXPECT_EQ(kwonly["gamma"], "2.0"); +} TEST(OperatorHelpersTest, ArgsFromKwargs_MissingRequiredArgs) { - std::map kwargs = { - {"beta", "1.0"}, - {"gamma", "2.0"} - }; + std::map kwargs = {{"beta", "1.0"}, + {"gamma", "2.0"}}; - std::vector required_args = {"alpha", "beta"}; - std::vector kwonly_args = {"gamma"}; + std::vector required_args = {"alpha", "beta"}; + std::vector kwonly_args = {"gamma"}; - EXPECT_THROW(OperatorHelpers::args_from_kwargs(kwargs, required_args, kwonly_args), std::invalid_argument); + EXPECT_THROW( + OperatorHelpers::args_from_kwargs(kwargs, required_args, kwonly_args), + std::invalid_argument); } - - - -