multipers 2.3.5b2__tar.gz → 2.3.5b4__tar.gz

multipers-2.3.5b4/AIDA/aida.cpp

@@ -0,0 +1,191 @@
+/**
+ * @file aida.cpp
+ * @author Jan Jendrysiak
+ * @version 0.2.1
+ * @date 2025-10-21
+ * @copyright 2025 TU Graz
+ *  This file is part of the AIDA library.
+ *  You can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ */
+
+#include <aida_interface.hpp>
+#include <option_parser.hpp>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <filesystem>
+
+namespace fs = std::filesystem;
+
+// Helper function declarations
+void write_to_file(std::ostringstream& ostream, 
+                   const std::string& input_directory,
+                   const std::string& file_without_extension,
+                   const std::string& extension,
+                   const std::string& output_string);
+void run_on_test_files(aida::AIDA_functor& decomposer, std::ostringstream& ostream);
+
+int main(int argc, char** argv) {
+    // Create decomposer with default config
+    aida::AIDA_functor decomposer;
+    decomposer.config.progress = true;
+    decomposer.config.show_info = true;
+    decomposer.config.sort_output = true;
+    decomposer.config.sort = true;
+    
+    // Parse options
+    aida::OptionParser parser;
+    parser.enable_stats_and_output();
+
+    if (!parser.parse(argc, argv, decomposer.config)) {
+        return 0; // Help/version shown or error
+    }
+    
+    // Extract file information
+    std::string matrix_path;
+    std::string input_directory;
+    std::string filename;
+    std::string file_without_extension;
+    std::string extension;
+    
+    if (parser.has_input_file()) {
+        fs::path fs_path(parser.get_input_file());
+        
+        if (fs_path.is_relative()) {
+            matrix_path = fs::current_path().string() + "/" + parser.get_input_file();
+        } else {
+            matrix_path = parser.get_input_file();
+        }
+        
+        input_directory = fs_path.parent_path().string();
+        filename = fs_path.filename().string();
+        
+        size_t dot_position = filename.find_last_of('.');
+        if (dot_position == std::string::npos) {
+            file_without_extension = filename;
+            extension = "";
+        } else {
+            file_without_extension = filename.substr(0, dot_position);
+            extension = filename.substr(dot_position);
+        }
+    }
+    
+    // Run decomposition
+    std::ostringstream ostream;
+    
+    if (!parser.test_files()) {
+        std::ifstream istream(matrix_path);
+        if (!istream.is_open()) {
+            std::cerr << "Error: Could not open input file: " << matrix_path << std::endl;
+            return 1;
+        }
+        
+        std::cout << "Decomposing " << filename << std::endl;
+        decomposer.to_stream(istream, ostream);
+    } else {
+        run_on_test_files(decomposer, ostream);
+    }
+    
+    // Show statistics
+    if (parser.show_indecomp_statistics()) {
+        decomposer.cumulative_statistics.print_statistics();
+    }
+    
+    if (parser.show_runtime_statistics()) {
+        decomposer.cumulative_runtime_statistics.print();
+        #if TIMERS
+            decomposer.cumulative_runtime_statistics.print_timers();
+        #endif
+    }
+    
+    if (decomposer.config.save_base_change) {
+        int total_row_ops = 0;
+        for (auto& base_change : decomposer.base_changes) {
+            total_row_ops += base_change->performed_row_ops.size();
+        }
+        if (decomposer.config.show_info) {
+            std::cout << "Basechange: Performed " << total_row_ops 
+                     << " row operations in total." << std::endl;
+        }
+    }
+    
+    // Write output
+    if (parser.has_output()) {
+        write_to_file(ostream, input_directory, file_without_extension, 
+                     extension, parser.get_output_string());
+    }
+    
+    // Comparison tests
+    if (decomposer.config.compare_both || decomposer.config.exhaustive_test) {
+        std::ifstream istream_test(matrix_path);
+        std::ostringstream ostream_test;
+        
+        aida::AIDA_functor test_decomposer;
+        test_decomposer.config = decomposer.config;
+        
+        if (decomposer.config.exhaustive_test) {
+            test_decomposer.config.exhaustive_test = false;
+            test_decomposer.config.exhaustive = true;
+        }
+        
+        if (decomposer.config.compare_both) {
+            test_decomposer.config.compare_both = false;
+            test_decomposer.config.exhaustive = true;
+            test_decomposer.config.brute_force = true;
+        }
+        
+        test_decomposer.to_stream(istream_test, ostream_test);
+        
+        aida::Full_merge_info merge_data = decomposer.merge_data_vec[0];
+        aida::Full_merge_info merge_data_test = test_decomposer.merge_data_vec[0];
+        
+        aida::index num_indecomp = decomposer.cumulative_statistics.num_of_summands;
+        aida::index num_indecomp_test = test_decomposer.statistics_vec.back().num_of_summands;
+        
+        if (num_indecomp != num_indecomp_test) {
+            std::cout << "Decomposition is different. AIDA: " << num_indecomp 
+                     << ", test: " << num_indecomp_test << std::endl;
+        }
+        
+        aida::compare_merge_info(merge_data, merge_data_test);
+    }
+    
+    return 0;
+}
+
+// Helper function implementations
+void write_to_file(std::ostringstream& ostream,
+                   const std::string& input_directory,
+                   const std::string& file_without_extension,
+                   const std::string& extension,
+                   const std::string& output_string) {
+    std::string output_path;
+    
+    if (output_string.empty()) {
+        output_path = input_directory + "/" + file_without_extension + ".sccsum";
+    } else if (fs::is_directory(output_string)) {
+        output_path = output_string + "/" + file_without_extension + ".sccsum";
+    } else {
+        output_path = output_string;
+    }
+    
+    std::ofstream output_file(output_path);
+    if (!output_file.is_open()) {
+        std::cerr << "Error: Could not open output file: " << output_path << std::endl;
+        return;
+    }
+    
+    output_file << ostream.str();
+    output_file.close();
+    
+    std::cout << "Output written to: " << output_path << std::endl;
+}
+
+void run_on_test_files(aida::AIDA_functor& decomposer, std::ostringstream& ostream) {
+    // Implementation for running test files
+    std::cout << "Running on test files..." << std::endl;
+    // Your test file logic here
+}

multipers-2.3.5b4/AIDA/birth_death.cpp

@@ -0,0 +1,80 @@
+#include <grlina/graded_linalg.hpp>
+#include <iostream>
+#include <filesystem>
+
+using namespace graded_linalg;
+
+void death(std::filesystem::path input_path, std::filesystem::path output_path, double epsilon) {
+    R2GradedSparseMatrix<int> presentation = R2GradedSparseMatrix<int>(input_path.string());
+    presentation.sort_columns_lexicographically();
+    presentation.sort_rows_lexicographically();
+    presentation.minimize();
+    r2degree step = {epsilon, epsilon};
+    auto original = presentation;
+    presentation.shift(step);
+    R2GradedSparseMatrix<int> zero = R2GradedSparseMatrix<int>(0, presentation.get_num_rows());
+    zero.col_degrees = vec<r2degree>();
+    zero.row_degrees = presentation.row_degrees;
+    zero.data = vec<vec<int>>();
+    R2GradedSparseMatrix<int> shifted = shifted_identity<r2degree, R2GradedSparseMatrix<int>>(presentation.row_degrees, step);
+    auto ker_epsilon = shifted.inverse_image_copy(presentation, zero);
+    auto death = ker_epsilon.presentation_of_submodule(original);
+
+    std::ofstream output_file(output_path);
+    if (!output_file.is_open()) {
+        std::cerr << "Error: Unable to open output file " << output_path << std::endl;
+        return;
+    } else {
+        death.to_stream(output_file);
+        output_file.close();
+        std::cout << "death curve computed and saved to: " << output_path << std::endl;
+    }
+
+}
+
+
+void birth(std::filesystem::path input_path, std::filesystem::path output_path, double epsilon) {
+    R2GradedSparseMatrix<int> presentation = R2GradedSparseMatrix<int>(input_path.string());
+    presentation.sort_columns_lexicographically();
+    presentation.sort_rows_lexicographically();
+    presentation.minimize();
+    r2degree step = {epsilon, epsilon};
+    R2GradedSparseMatrix<int> shifted = shifted_identity<r2degree, R2GradedSparseMatrix<int>>(presentation.row_degrees, step);
+    presentation.quotient_by(shifted);
+
+    std::ofstream output_file(output_path);
+    if (!output_file.is_open()) {
+        std::cerr << "Error: Unable to open output file " << output_path << std::endl;
+        return;
+    } else {
+        presentation.to_stream(output_file);
+        output_file.close();
+        std::cout << "birth curve computed and saved to: " << output_path << std::endl;
+    }
+}
+
+
+int main(int argc, char** argv) {
+    
+    std::string filepath;
+
+    if (argc != 2) {
+        std::cerr << "Usage: " << argv[0] << " <file_path>" << std::endl;
+        filepath = "/home/wsljan/AIDA/tests/test_presentations/ex1.scc";
+    } else {
+        filepath = argv[1];
+    }
+
+    std::filesystem::path input_path(filepath);
+    
+    std::string birth_path = insert_suffix_before_extension(filepath, "_birth");
+    std::filesystem::path birth_output_path(birth_path);
+
+    std::string death_path = insert_suffix_before_extension(filepath, "_death");
+    std::filesystem::path death_output_path(death_path);
+
+    double epsilon = 0.01;
+    birth(input_path, birth_output_path, epsilon);
+    death(input_path, death_output_path, epsilon);
+    return 0;
+} // main