{"id":25267556,"url":"https://github.com/kgorze/dna-assembly-problem-solver","last_synced_at":"2026-07-03T01:33:42.103Z","repository":{"id":273625366,"uuid":"913466151","full_name":"kGorze/DNA-Assembly-Problem-Solver","owner":"kGorze","description":"DNA sequence reconstruction via genetic algorithms for SBH, featuring adaptive crossover and robust error handling.","archived":false,"fork":false,"pushed_at":"2025-02-03T22:03:12.000Z","size":23927,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"master","last_synced_at":"2025-10-26T11:43:44.386Z","etag":null,"topics":["bioinformatics","cpp","dna-assembly","genetic-algorithms","metaheuristics","optimization","sbhs","sequence-reconstruction"],"latest_commit_sha":null,"homepage":"","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/kGorze.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2025-01-07T18:31:34.000Z","updated_at":"2025-06-27T18:20:47.000Z","dependencies_parsed_at":"2025-01-22T02:28:03.701Z","dependency_job_id":"b6974c0d-31db-482c-9a77-0fae43f3c32a","html_url":"https://github.com/kGorze/DNA-Assembly-Problem-Solver","commit_stats":null,"previous_names":["kgorze/optymalizacja_kombinatoryczna","kgorze/dna-assembly-problem-solver"],"tags_count":1,"template":false,"template_full_name":null,"purl":"pkg:github/kGorze/DNA-Assembly-Problem-Solver","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/kGorze%2FDNA-Assembly-Problem-Solver","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/kGorze%2FDNA-Assembly-Problem-Solver/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/kGorze%2FDNA-Assembly-Problem-Solver/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/kGorze%2FDNA-Assembly-Problem-Solver/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/kGorze","download_url":"https://codeload.github.com/kGorze/DNA-Assembly-Problem-Solver/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/kGorze%2FDNA-Assembly-Problem-Solver/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":35069183,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-07-02T02:00:06.368Z","response_time":173,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["bioinformatics","cpp","dna-assembly","genetic-algorithms","metaheuristics","optimization","sbhs","sequence-reconstruction"],"created_at":"2025-02-12T09:40:11.002Z","updated_at":"2026-07-03T01:33:42.071Z","avatar_url":"https://github.com/kGorze.png","language":"C++","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Optymalizacja Kombinatoryczna - DNA Assembly Problem Solver\n\n## Spis treści\n- [Wprowadzenie](#wprowadzenie)\n- [Struktura projektu](#struktura-projektu)\n- [Algorytmy](#algorytmy)\n- [Komponenty](#komponenty)\n- [Konfiguracja](#konfiguracja)\n- [Interfejsy](#interfejsy)\n- [Szczegółowa dokumentacja](#szczegółowa-dokumentacja)\n\n## Wprowadzenie\nProgram implementuje rozwiązanie problemu składania DNA (DNA Assembly Problem) przy użyciu algorytmów metaheurystycznych, w szczególności algorytmu genetycznego. Program zawiera zaawansowane mechanizmy optymalizacji i adaptacji parametrów. Zadanie na labolatoria do dr. Radoma - Bioinformatyka 3 semestr, optymalizacja kombinatoryczna.\n\n## Struktura projektu\n```\n.\n├── include/                 # Pliki nagłówkowe\n│   ├── metaheuristics/     # Implementacje metaheurystyk\n│   ├── interfaces/         # Interfejsy\n│   ├── dna/               # Obsługa instancji DNA\n│   ├── utils/             # Narzędzia pomocnicze\n│   └── configuration/     # Konfiguracja\n├── src/                    # Pliki źródłowe\n└── test/                  # Testy jednostkowe\n```\n\n## Algorytmy\n\n### Algorytm Genetyczny (GeneticAlgorithm)\nGłówna klasa implementująca algorytm genetyczny dla problemu DNA Assembly.\n\n#### Główne komponenty:\n- **Inicjalizacja**: `initializePopulation(int popSize, const DNAInstance\u0026 instance)`\n  - Tworzy początkową populację rozwiązań\n  - Parametry:\n    - `popSize`: Rozmiar populacji\n    - `instance`: Instancja problemu DNA\n\n- **Ewaluacja**: `evaluatePopulation()`\n  - Ocenia jakość każdego osobnika w populacji\n  - Wykorzystuje funkcję przystosowania opartą na grafie\n\n- **Selekcja**: Implementowana przez interfejs `ISelection`\n  - Wybiera osobniki do reprodukcji\n  - Dostępne strategie:\n    - Selekcja turniejowa\n    - Selekcja rankingowa\n    - Selekcja ruletki\n\n- **Krzyżowanie**: Implementowane przez interfejs `ICrossover`\n  - Tworzy nowe rozwiązania przez kombinację istniejących\n  - Dostępne operatory:\n    - Krzyżowanie jednopunktowe\n    - Krzyżowanie dwupunktowe\n    - Krzyżowanie adaptacyjne (AdaptiveCrossover)\n\n- **Mutacja**: Implementowana przez interfejs `IMutation`\n  - Wprowadza losowe zmiany w rozwiązaniach\n  - Dostępne operatory:\n    - Mutacja przez zamianę\n    - Mutacja przez inwersję\n    - Mutacja przez przesunięcie\n\n### Reprezentacja rozwiązań\nImplementowana w klasie `PermutationRepresentation`:\n- Reprezentacja permutacyjna fragmentów DNA\n- Operacje na permutacjach\n- Walidacja poprawności rozwiązań\n\n## Komponenty\n\n### DNAInstance\nKlasa reprezentująca instancję problemu:\n```cpp\nclass DNAInstance {\n    std::vector\u003cstd::string\u003e fragments;  // Fragmenty DNA\n    int k;                              // Parametr k dla odległości Levenshteina\n    std::string originalSequence;       // Oryginalna sekwencja (jeśli znana)\n};\n```\n\n### Individual\nReprezentacja pojedynczego osobnika w populacji:\n```cpp\nclass Individual {\n    std::vector\u003cint\u003e genes;            // Reprezentacja rozwiązania\n    double fitness;                    // Wartość funkcji przystosowania\n    std::string dna;                   // Złożona sekwencja DNA\n};\n```\n\n### FitnessImpl\nImplementacje funkcji przystosowania:\n- `OptimizedGraphBasedFitness`: Ocena bazująca na grafie\n- `LevenshteinBasedFitness`: Ocena bazująca na odległości Levenshteina\n\n## Konfiguracja\n\n### GAConfig\nKonfiguracja algorytmu genetycznego:\n```cpp\nstruct GAConfig {\n    int populationSize;                // Rozmiar populacji\n    int maxGenerations;               // Maksymalna liczba generacji\n    double crossoverProbability;      // Prawdopodobieństwo krzyżowania\n    double mutationProbability;       // Prawdopodobieństwo mutacji\n    SelectionType selectionType;      // Typ selekcji\n    CrossoverType crossoverType;      // Typ krzyżowania\n    MutationType mutationType;        // Typ mutacji\n};\n```\n\n## Interfejsy\n\n### Podstawowe interfejsy algorytmu\n\n#### IAlgorithm\nBazowy interfejs dla wszystkich algorytmów:\n```cpp\nclass IAlgorithm {\n    virtual std::string run(const DNAInstance\u0026 instance) = 0;\n    virtual ~IAlgorithm() = default;\n};\n```\n\n#### IRepresentation\nInterfejs reprezentacji rozwiązania:\n```cpp\nclass IRepresentation {\n    virtual std::vector\u003cint\u003e decode(const std::string\u0026 dna) = 0;\n    virtual std::string encode(const std::vector\u003cint\u003e\u0026 genes) = 0;\n    virtual bool isValid(const std::vector\u003cint\u003e\u0026 genes) = 0;\n};\n```\n\n### Interfejsy operatorów genetycznych\n\n#### ISelection\nInterfejs selekcji osobników:\n```cpp\nclass ISelection {\n    virtual std::vector\u003cstd::shared_ptr\u003cIndividual\u003e\u003e select(\n        const std::vector\u003cstd::shared_ptr\u003cIndividual\u003e\u003e\u0026 population,\n        int count) = 0;\n    \n    virtual SelectionType getType() const = 0;\n};\n```\n\n#### ICrossover\nInterfejs operatora krzyżowania:\n```cpp\nclass ICrossover {\n    virtual std::pair\u003cstd::shared_ptr\u003cIndividual\u003e, std::shared_ptr\u003cIndividual\u003e\u003e\n    crossover(const std::shared_ptr\u003cIndividual\u003e\u0026 parent1,\n             const std::shared_ptr\u003cIndividual\u003e\u0026 parent2) = 0;\n             \n    virtual CrossoverType getType() const = 0;\n};\n```\n\n#### IMutation\nInterfejs operatora mutacji:\n```cpp\nclass IMutation {\n    virtual void mutate(std::shared_ptr\u003cIndividual\u003e individual) = 0;\n    virtual MutationType getType() const = 0;\n    virtual void setMutationProbability(double probability) = 0;\n};\n```\n\n#### IReplacement\nInterfejs strategii wymiany pokoleń:\n```cpp\nclass IReplacement {\n    virtual std::vector\u003cstd::shared_ptr\u003cIndividual\u003e\u003e replace(\n        const std::vector\u003cstd::shared_ptr\u003cIndividual\u003e\u003e\u0026 oldPopulation,\n        const std::vector\u003cstd::shared_ptr\u003cIndividual\u003e\u003e\u0026 offspring) = 0;\n        \n    virtual ReplacementType getType() const = 0;\n};\n```\n\n### Interfejsy oceny i zatrzymania\n\n#### IFitness\nInterfejs funkcji przystosowania:\n```cpp\nclass IFitness {\n    virtual double calculate(const std::vector\u003cint\u003e\u0026 genes,\n                           const DNAInstance\u0026 instance) = 0;\n                           \n    virtual FitnessType getType() const = 0;\n};\n```\n\n#### IStopping\nInterfejs kryterium zatrzymania:\n```cpp\nclass IStopping {\n    virtual bool shouldStop(int generation, double bestFitness) = 0;\n    virtual void reset() = 0;\n    virtual StoppingType getType() const = 0;\n};\n```\n\n### Interfejsy optymalizacyjne\n\n#### IPopulationCache\nInterfejs cache'owania populacji:\n```cpp\nclass IPopulationCache {\n    virtual void addToCache(const std::vector\u003cint\u003e\u0026 genes, double fitness) = 0;\n    virtual bool isInCache(const std::vector\u003cint\u003e\u0026 genes) const = 0;\n    virtual double getCachedFitness(const std::vector\u003cint\u003e\u0026 genes) const = 0;\n    virtual void clear() = 0;\n    virtual size_t size() const = 0;\n};\n```\n\n#### IBenchmark\nInterfejs dla benchmarków:\n```cpp\nclass IBenchmark {\n    virtual void run() = 0;\n    virtual void generateReport(const std::string\u0026 outputFile) = 0;\n    virtual BenchmarkType getType() const = 0;\n};\n```\n\n## Implementacje interfejsów\n\n### Operatory selekcji\n- `TournamentSelection`: Selekcja turniejowa\n- `RouletteSelection`: Selekcja metodą ruletki\n- `RankSelection`: Selekcja rankingowa\n\n### Operatory krzyżowania\n- `SinglePointCrossover`: Krzyżowanie jednopunktowe\n- `TwoPointCrossover`: Krzyżowanie dwupunktowe\n- `UniformCrossover`: Krzyżowanie równomierne\n- `AdaptiveCrossover`: Krzyżowanie adaptacyjne\n\n### Operatory mutacji\n- `SwapMutation`: Mutacja przez zamianę\n- `InversionMutation`: Mutacja przez inwersję\n- `ScrambleMutation`: Mutacja przez przemieszanie\n\n### Strategie wymiany pokoleń\n- `GenerationalReplacement`: Wymiana generacyjna\n- `ElitistReplacement`: Wymiana elitarna\n- `SteadyStateReplacement`: Wymiana w stanie ustalonym\n\n### Funkcje przystosowania\n- `GraphBasedFitness`: Ocena bazująca na grafie\n- `LevenshteinFitness`: Ocena bazująca na odległości Levenshteina\n- `HybridFitness`: Ocena hybrydowa\n\n### Kryteria zatrzymania\n- `GenerationLimit`: Limit generacji\n- `FitnessThreshold`: Próg funkcji przystosowania\n- `TimeLimit`: Limit czasowy\n- `StagnationDetection`: Wykrywanie stagnacji\n\n## Szczegółowa dokumentacja\n\n### Klasa GeneticAlgorithm\n\n#### Metody publiczne:\n- `GeneticAlgorithm(std::unique_ptr\u003cIRepresentation\u003e representation, GAConfig\u0026 config, bool debugMode = false)`\n  - Konstruktor inicjalizujący algorytm genetyczny\n  - Parametry:\n    - `representation`: Implementacja reprezentacji rozwiązań\n    - `config`: Konfiguracja algorytmu\n    - `debugMode`: Tryb debugowania\n\n- `std::string run(const DNAInstance\u0026 instance)`\n  - Uruchamia algorytm genetyczny\n  - Zwraca: Najlepsze znalezione rozwiązanie (sekwencję DNA)\n\n- `double getBestFitness()`\n  - Zwraca wartość przystosowania najlepszego rozwiązania\n\n#### Metody prywatne:\n- `void initializePopulation(int popSize, const DNAInstance\u0026 instance)`\n  - Inicjalizuje populację początkową\n\n- `void evaluatePopulation()`\n  - Ocenia wszystkie osobniki w populacji\n\n- `bool updateGlobalBest()`\n  - Aktualizuje najlepsze znalezione rozwiązanie\n\n- `void logGenerationStats()`\n  - Zapisuje statystyki generacji\n\n### Klasa AdaptiveCrossover\n\nImplementuje adaptacyjny operator krzyżowania:\n```cpp\nclass AdaptiveCrossover : public ICrossover {\n    void updateCrossoverRates();      // Aktualizacja współczynników\n    void adaptParameters();           // Adaptacja parametrów\n    double calculateSuccess();        // Obliczenie skuteczności\n};\n```\n\n### Klasa PathAnalyzer\n\nAnalizuje ścieżki w grafie reprezentującym problem:\n```cpp\nclass PathAnalyzer {\n    std::vector\u003cPreprocessedEdge\u003e findBestPath();\n    double evaluatePath(const std::vector\u003cint\u003e\u0026 path);\n    void preprocessEdges();\n};\n```\n\n## Główne moduły programu\n\n### Main (main.cpp)\nGłówny plik programu zawierający logikę sterującą i obsługę trybów działania:\n\n#### Tryby działania programu:\n- `debug` - Tryb debugowania z domyślnymi ustawieniami\n- `generate_instance` - Generowanie instancji testowych\n- `test_instance` - Rozwiązywanie problemu rekonstrukcji DNA z pliku wejściowego\n- `tuning` - Strojenie parametrów algorytmu\n- `tuning_hybrid` - Zaawansowane strojenie hybrydowe (1+lambda) ES + Racing\n\n#### Główne funkcje:\n```cpp\nvoid printUsage()\n// Wyświetla instrukcję użycia programu i dostępne opcje\n\nDNAInstance generateInstance(int n, int k, int deltaK, int lNeg, int lPoz)\n// Generuje instancję problemu DNA o zadanych parametrach\n// Parametry:\n//   n - długość DNA (300-700)\n//   k - długość oligonukleotydów (7-10)\n//   deltaK - zakres Delta K (0-2)\n//   lNeg - błędy negatywne (0 lub \u003e=10)\n//   lPoz - błędy pozytywne (0 lub \u003e=10)\n\nvoid runGeneticAlgorithm(const DNAInstance\u0026 instance,\n                        const std::string\u0026 outputFile,\n                        int processId,\n                        const std::string\u0026 configFile,\n                        bool debugMode)\n// Uruchamia algorytm genetyczny dla danej instancji\n// Parametry:\n//   instance - instancja problemu DNA\n//   outputFile - plik wyjściowy dla wyników\n//   processId - identyfikator procesu\n//   configFile - plik konfiguracyjny\n//   debugMode - tryb debugowania\n\ndouble runGeneticAlgorithmWithFitness(...)\n// Wersja zwracająca wartość funkcji przystosowania\n\nvoid runParameterTuningWithRacing(const DNAInstance\u0026 instance)\n// Uruchamia strojenie parametrów z wykorzystaniem metody Racing\n\nTuningResult runParameterTuning(...)\n// Przeprowadza strojenie parametrów i zwraca wyniki\n\n### Generator DNA (generator/)\n\n#### DNAGenerator\nKlasa odpowiedzialna za generowanie instancji problemu:\n```cpp\nclass DNAGenerator {\n    std::string generateRandomDNA(int length);\n    std::vector\u003cstd::string\u003e generateFragments(const std::string\u0026 dna, int k);\n    void introduceErrors(std::vector\u003cstd::string\u003e\u0026 fragments, int lNeg, int lPoz);\n};\n```\n\n### Moduł strojenia (tuning/)\n\n#### ParameterTuningManager\nZarządza procesem strojenia parametrów:\n```cpp\nclass ParameterTuningManager {\n    void tuneParameters();\n    void evaluateConfiguration(const ParameterSet\u0026 params);\n    void saveResults(const std::string\u0026 outputFile);\n};\n```\n\n#### Racing\nImplementacja metody Racing do selekcji konfiguracji:\n```cpp\nclass Racing {\n    void runRace(std::vector\u003cConfiguration\u003e\u0026 configs);\n    void eliminateConfigurations();\n    Configuration getBestConfiguration();\n};\n```\n\n#### ParameterParser\nParsowanie i walidacja parametrów strojenia:\n```cpp\nclass ParameterParser {\n    // Metody parsowania\n    ParameterSet parseConfigFile(const std::string\u0026 filename);\n    void validateParameters(const ParameterSet\u0026 params);\n    \n    // Obsługa różnych typów parametrów\n    int parseIntParameter(const std::string\u0026 value, const std::string\u0026 name);\n    double parseDoubleParameter(const std::string\u0026 value, const std::string\u0026 name);\n    std::string parseEnumParameter(const std::string\u0026 value, const std::vector\u003cstd::string\u003e\u0026 allowedValues);\n};\n```\n\n#### TuningStructures\nStruktury danych używane w procesie strojenia:\n```cpp\nstruct ParameterSet {\n    std::map\u003cstd::string, std::variant\u003cint, double, std::string\u003e\u003e parameters;\n    double fitness;\n    int evaluations;\n};\n\nstruct Configuration {\n    ParameterSet params;\n    std::vector\u003cdouble\u003e results;\n    double mean;\n    double stdDev;\n};\n\nstruct TuningResult {\n    ParameterSet bestParams;\n    double bestFitness;\n    int generations;\n    double tuningTime;\n};\n```\n\n#### MetaEA\nMetaewolucyjny algorytm do strojenia parametrów:\n```cpp\nclass MetaEA {\n    // Główne metody\n    void evolveParameters();\n    void evaluatePopulation();\n    void selectBestConfigurations();\n    \n    // Operatory\n    ParameterSet crossover(const ParameterSet\u0026 parent1, const ParameterSet\u0026 parent2);\n    void mutate(ParameterSet\u0026 params);\n    \n    // Parametry meta-algorytmu\n    const int META_POPULATION_SIZE = 20;\n    const int META_GENERATIONS = 50;\n    const double META_MUTATION_RATE = 0.1;\n};\n```\n\n### Moduł benchmarków (benchmark/)\n\n#### CrossoverBenchmark\nTesty wydajności operatorów krzyżowania:\n```cpp\nclass CrossoverBenchmark {\n    void runBenchmark();\n    void compareCrossoverOperators();\n    void generateStatistics();\n};\n```\n\n#### AdaptiveCrossoverBenchmark\nTesty wydajności adaptacyjnego operatora krzyżowania:\n```cpp\nclass AdaptiveCrossoverBenchmark {\n    void testAdaptation();\n    void measureConvergence();\n};\n```\n\n### Moduł błędów DNA (dna/)\n\n#### ErrorIntroduction\nKlasy do wprowadzania błędów w sekwencjach DNA:\n```cpp\nclass NegativeErrorIntroducer {\n    void introduceErrors(std::vector\u003cstd::string\u003e\u0026 fragments, int count);\n};\n\nclass PositiveErrorIntroducer {\n    void introduceErrors(std::vector\u003cstd::string\u003e\u0026 fragments, int count);\n};\n```\n\n### Narzędzia pomocnicze (utils/)\n\n#### Random\nGenerator liczb pseudolosowych:\n```cpp\nclass Random {\n    // Generowanie liczb losowych\n    int getRandomInt(int min, int max);\n    double getRandomDouble(double min, double max);\n    bool getRandomBool(double probability);\n    \n    // Operacje na kolekcjach\n    template\u003ctypename T\u003e\n    void shuffle(std::vector\u003cT\u003e\u0026 vec);\n    \n    template\u003ctypename T\u003e\n    T getRandomElement(const std::vector\u003cT\u003e\u0026 vec);\n};\n```\n\n#### Timer\nPomiar czasu wykonania:\n```cpp\nclass Timer {\n    void start();\n    void stop();\n    double getElapsedTime() const;\n    void reset();\n    \n    static std::string formatTime(double seconds);\n};\n```\n\n#### Logging\nSystem logowania:\n```cpp\nclass Logger {\n    // Poziomy logowania\n    enum class Level {\n        DEBUG,\n        INFO,\n        WARNING,\n        ERROR\n    };\n    \n    // Metody logowania\n    void log(Level level, const std::string\u0026 message);\n    void setLogLevel(Level level);\n    void setLogFile(const std::string\u0026 filename);\n    \n    // Konfiguracja\n    void enableConsoleOutput(bool enable);\n    void enableFileOutput(bool enable);\n};\n```\n\n#### PerformanceProfillingFramework\nNarzędzie do profilowania wydajności:\n```cpp\nclass Profiler {\n    // Pomiar wydajności\n    void startSection(const std::string\u0026 name);\n    void endSection(const std::string\u0026 name);\n    \n    // Raportowanie\n    void generateReport();\n    void saveReport(const std::string\u0026 filename);\n    \n    // Statystyki\n    struct SectionStats {\n        double totalTime;\n        int calls;\n        double avgTime;\n        double minTime;\n        double maxTime;\n    };\n};\n```\n\n#### ZobristHasher\nImplementacja hashowania Zobrista dla efektywnego cache'owania:\n```cpp\nclass ZobristHasher {\n    // Inicjalizacja\n    void initialize(size_t size);\n    \n    // Hashowanie\n    size_t hash(const std::vector\u003cint\u003e\u0026 genes);\n    void updateHash(size_t\u0026 currentHash, int pos, int oldVal, int newVal);\n    \n    // Parametry\n    static constexpr size_t HASH_SIZE = 64;\n};\n```\n\n#### UtilityFunctions\nZbiór funkcji pomocniczych:\n```cpp\nnamespace Utils {\n    // Operacje na plikach\n    std::string readFile(const std::string\u0026 filename);\n    void writeFile(const std::string\u0026 filename, const std::string\u0026 content);\n    \n    // Operacje na stringach\n    std::vector\u003cstd::string\u003e split(const std::string\u0026 str, char delimiter);\n    std::string trim(const std::string\u0026 str);\n    \n    // Konwersje\n    template\u003ctypename T\u003e\n    std::string toString(const T\u0026 value);\n    \n    template\u003ctypename T\u003e\n    T fromString(const std::string\u0026 str);\n    \n    // Operacje matematyczne\n    double calculateMean(const std::vector\u003cdouble\u003e\u0026 values);\n    double calculateStdDev(const std::vector\u003cdouble\u003e\u0026 values);\n    \n    // Operacje na DNA\n    int calculateLevenshteinDistance(const std::string\u0026 s1, const std::string\u0026 s2);\n    double calculateSequenceSimilarity(const std::string\u0026 s1, const std::string\u0026 s2);\n}\n```\n\n## Format plików wejściowych/wyjściowych\n\n### Plik konfiguracyjny (config.txt)\n```\npopulation_size=100\nmax_generations=1000\ncrossover_probability=0.8\nmutation_probability=0.1\nselection_type=tournament\ncrossover_type=adaptive\nmutation_type=swap\ntournament_size=3\nelite_size=2\n```\n\n### Plik instancji (instance.txt)\n```\n300 8    # N=300 (długość DNA), K=8 (długość oligonukleotydów)\nACGTACGT # Fragment 1\nCGTACGTA # Fragment 2\n...\nfragment_n\n```\ngdzie:\n- n: liczba fragmentów\n- k: parametr k dla odległości Levenshteina\n- fragment_i: i-ty fragment DNA\n\n### Format pliku konfiguracji\n```json\n{\n  \"population_size\": 100,\n  \"max_generations\": 1000,\n  \"crossover_probability\": 0.8,\n  \"mutation_probability\": 0.1,\n  \"selection_type\": \"tournament\",\n  \"crossover_type\": \"adaptive\",\n  \"mutation_type\": \"swap\"\n}\n```\n\n## Użycie programu\n\n### Kompilacja\n```bash\nmkdir build\ncd build\ncmake ..\nmake\n```\n\n### Uruchomienie\n```bash\n./dna_assembly \u003cplik_instancji\u003e \u003cplik_konfiguracji\u003e\n```\n\n### Format pliku instancji\n```\nn k\nfragment_1\nfragment_2\n...\nfragment_n\n```\n\n### Format pliku konfiguracji\n```json\n{\n  \"population_size\": 100,\n  \"max_generations\": 1000,\n  \"crossover_probability\": 0.8,\n  \"mutation_probability\": 0.1,\n  \"selection_type\": \"tournament\",\n  \"crossover_type\": \"adaptive\",\n  \"mutation_type\": \"swap\"\n}\n```\n\n## Wymagania systemowe\n- C++17 lub nowszy\n- CMake 3.10 lub nowszy\n- Boost (dla testów jednostkowych)\n\n### Naiwny algorytm (naive/)\n\n#### NaiveReconstruction\nImplementacja naiwnego podejścia do problemu rekonstrukcji DNA:\n```cpp\nclass NaiveReconstruction {\n    // Główne metody\n    std::string reconstructDNA(const std::vector\u003cstd::string\u003e\u0026 fragments);\n    \n    // Metody pomocnicze\n    double calculateOverlap(const std::string\u0026 s1, const std::string\u0026 s2);\n    std::pair\u003cint, int\u003e findBestMatch(const std::vector\u003cstd::string\u003e\u0026 fragments);\n    void mergePair(std::vector\u003cstd::string\u003e\u0026 fragments, int i, int j);\n};\n```\n\nAlgorytm działa poprzez:\n1. Znajdowanie par fragmentów o największym pokryciu\n2. Łączenie znalezionych par\n3. Powtarzanie procesu aż do uzyskania jednej sekwencji\n\n### Szczegóły modułu strojenia (tuning/)\n\n#### ParameterParser\nParsowanie i walidacja parametrów strojenia:\n```cpp\nclass ParameterParser {\n    // Metody parsowania\n    ParameterSet parseConfigFile(const std::string\u0026 filename);\n    void validateParameters(const ParameterSet\u0026 params);\n    \n    // Obsługa różnych typów parametrów\n    int parseIntParameter(const std::string\u0026 value, const std::string\u0026 name);\n    double parseDoubleParameter(const std::string\u0026 value, const std::string\u0026 name);\n    std::string parseEnumParameter(const std::string\u0026 value, const std::vector\u003cstd::string\u003e\u0026 allowedValues);\n};\n```\n\n#### TuningStructures\nStruktury danych używane w procesie strojenia:\n```cpp\nstruct ParameterSet {\n    std::map\u003cstd::string, std::variant\u003cint, double, std::string\u003e\u003e parameters;\n    double fitness;\n    int evaluations;\n};\n\nstruct Configuration {\n    ParameterSet params;\n    std::vector\u003cdouble\u003e results;\n    double mean;\n    double stdDev;\n};\n\nstruct TuningResult {\n    ParameterSet bestParams;\n    double bestFitness;\n    int generations;\n    double tuningTime;\n};\n```\n\n#### MetaEA\nMetaewolucyjny algorytm do strojenia parametrów:\n```cpp\nclass MetaEA {\n    // Główne metody\n    void evolveParameters();\n    void evaluatePopulation();\n    void selectBestConfigurations();\n    \n    // Operatory\n    ParameterSet crossover(const ParameterSet\u0026 parent1, const ParameterSet\u0026 parent2);\n    void mutate(ParameterSet\u0026 params);\n    \n    // Parametry meta-algorytmu\n    const int META_POPULATION_SIZE = 20;\n    const int META_GENERATIONS = 50;\n    const double META_MUTATION_RATE = 0.1;\n};\n```\n\n### Szczegóły implementacji algorytmu genetycznego\n\n#### PopulationCacheImpl\nImplementacja cache'owania populacji dla przyspieszenia obliczeń:\n```cpp\nclass PopulationCacheImpl : public IPopulationCache {\n    // Metody zarządzania cache'm\n    void addToCache(const std::vector\u003cint\u003e\u0026 genes, double fitness);\n    bool isInCache(const std::vector\u003cint\u003e\u0026 genes) const;\n    double getCachedFitness(const std::vector\u003cint\u003e\u0026 genes) const;\n    \n    // Parametry cache'a\n    const size_t MAX_CACHE_SIZE = 10000;\n    void cleanCache();\n};\n```\n\n#### GeneticAlgorithmRunner\nKlasa zarządzająca uruchomieniem algorytmu genetycznego:\n```cpp\nclass GeneticAlgorithmRunner {\n    // Główne metody\n    void run(const DNAInstance\u0026 instance);\n    void initialize();\n    void evolve();\n    void finalize();\n    \n    // Metody pomocnicze\n    void updateStatistics();\n    void logProgress();\n    void checkStoppingCriteria();\n    \n    // Parametry wykonania\n    const int CHECKPOINT_INTERVAL = 100;\n    const int LOG_INTERVAL = 10;\n};\n```\n\n## Przykłady użycia\n\n### Przykład 1: Podstawowe użycie\n```cpp\n// Inicjalizacja\nauto instance = DNAInstance::fromFile(\"instance.txt\");\nauto config = GAConfig::fromFile(\"config.txt\");\nauto ga = GeneticAlgorithm(std::make_unique\u003cPermutationRepresentation\u003e(), config);\n\n// Uruchomienie\nstd::string result = ga.run(instance);\nstd::cout \u003c\u003c \"Zrekonstruowana sekwencja: \" \u003c\u003c result \u003c\u003c std::endl;\n```\n\n### Przykład 2: Zaawansowana konfiguracja\n```cpp\n// Konfiguracja operatorów\nauto selection = std::make_unique\u003cTournamentSelection\u003e(3);\nauto crossover = std::make_unique\u003cAdaptiveCrossover\u003e();\nauto mutation = std::make_unique\u003cSwapMutation\u003e(0.1);\n\n// Konfiguracja algorytmu\nGAConfig config;\nconfig.setPopulationSize(100)\n      .setMaxGenerations(1000)\n      .setSelection(std::move(selection))\n      .setCrossover(std::move(crossover))\n      .setMutation(std::move(mutation));\n\n// Uruchomienie z logowaniem\nLogger::getInstance().setLogLevel(Logger::Level::DEBUG);\nauto ga = GeneticAlgorithm(std::make_unique\u003cPermutationRepresentation\u003e(), config);\nga.run(instance);\n```\n\n### Przykład 3: Strojenie parametrów\n```cpp\n// Konfiguracja strojenia\nauto tuner = ParameterTuningManager(\"tuning_results.csv\");\ntuner.addParameter(\"population_size\", {50, 100, 200})\n     .addParameter(\"crossover_rate\", {0.7, 0.8, 0.9})\n     .addParameter(\"mutation_rate\", {0.01, 0.05, 0.1});\n\n// Uruchomienie strojenia\ntuner.tune(instance, 30); // 30 iteracji dla każdej konfiguracji\n```\n\n## Workflow trybu debug\n\n### 1. Inicjalizacja i konfiguracja\n```cpp\n// Tworzenie instancji problemu\nauto instance = DNAInstance::fromFile(\"instance.txt\");\n\n// Konfiguracja w trybie debug\nGAConfig config;\nconfig.setPopulationSize(50)         // Mniejsza populacja dla szybszego debugowania\n      .setMaxGenerations(100)        // Mniej generacji\n      .setDebugMode(true)           // Włączenie trybu debug\n      .setLogLevel(Logger::Level::DEBUG);\n\n// Inicjalizacja loggera\nLogger::getInstance().enableFileOutput(true)\n                    .setLogFile(\"debug_output.txt\")\n                    .enableConsoleOutput(true);\n\n// Inicjalizacja profilera\nProfiler::getInstance().startSection(\"main\");\n```\n\n### 2. Przebieg algorytmu w trybie debug\n\n#### 2.1. Inicjalizacja populacji\n```cpp\nvoid GeneticAlgorithm::initializePopulation() {\n    Logger::debug(\"Inicjalizacja populacji początkowej\");\n    Profiler::startSection(\"initialization\");\n    \n    // Tworzenie początkowej populacji\n    for (int i = 0; i \u003c config.populationSize; i++) {\n        auto individual = createRandomIndividual();\n        population.push_back(individual);\n        Logger::debug(f\"Osobnik {i}: {individual-\u003etoString()}\");\n    }\n    \n    Profiler::endSection(\"initialization\");\n}\n```\n\n#### 2.2. Główna pętla ewolucyjna\n```cpp\nvoid GeneticAlgorithm::evolve() {\n    for (int generation = 0; generation \u003c config.maxGenerations; generation++) {\n        Profiler::startSection(\"generation\");\n        \n        // Selekcja rodziców\n        Logger::debug(\"Generacja {generation}: Selekcja\");\n        auto parents = selection-\u003eselect(population, config.selectionSize);\n        \n        // Krzyżowanie\n        Logger::debug(\"Krzyżowanie wybranych osobników\");\n        auto offspring = crossover-\u003ecrossover(parents);\n        \n        // Mutacja\n        Logger::debug(\"Mutacja potomstwa\");\n        for (auto\u0026 child : offspring) {\n            mutation-\u003emutate(child);\n        }\n        \n        // Ewaluacja\n        Logger::debug(\"Obliczanie przystosowania\");\n        evaluatePopulation(offspring);\n        \n        // Wymiana pokoleń\n        Logger::debug(\"Wymiana pokoleń\");\n        population = replacement-\u003ereplace(population, offspring);\n        \n        // Statystyki i debug info\n        logDebugInfo(generation);\n        \n        Profiler::endSection(\"generation\");\n    }\n}\n```\n\n#### 2.3. Ewaluacja i statystyki\n```cpp\nvoid GeneticAlgorithm::evaluatePopulation() {\n    Profiler::startSection(\"evaluation\");\n    \n    for (auto\u0026 individual : population) {\n        // Obliczanie przystosowania\n        double fitness = fitnessCalculator-\u003ecalculate(individual);\n        individual-\u003esetFitness(fitness);\n        \n        // Debug info\n        Logger::debug(f\"Fitness: {fitness}, DNA: {individual-\u003egetDNA()}\");\n    }\n    \n    // Statystyki populacji\n    double avgFitness = calculateAverageFitness();\n    double bestFitness = findBestFitness();\n    \n    Logger::debug(f\"Średnie przystosowanie: {avgFitness}\");\n    Logger::debug(f\"Najlepsze przystosowanie: {bestFitness}\");\n    \n    Profiler::endSection(\"evaluation\");\n}\n```\n\n### 3. Narzędzia debugowania\n\n#### 3.1. Logger\nUżywany do śledzenia przebiegu algorytmu:\n```cpp\n// Poziomy logowania\nLogger::debug(\"Szczegółowe informacje dla debugowania\");\nLogger::info(\"Ogólne informacje o postępie\");\nLogger::warning(\"Ostrzeżenia\");\nLogger::error(\"Błędy krytyczne\");\n```\n\n#### 3.2. Profiler\nMierzy wydajność poszczególnych sekcji:\n```cpp\n// Przykładowy raport profilera\nSection          | Total Time | Calls | Avg Time\n-----------------|------------|-------|----------\ninitialization   | 0.123s     | 1     | 0.123s\ngeneration       | 15.432s    | 100   | 0.154s\nevaluation       | 10.234s    | 100   | 0.102s\nselection        | 2.345s     | 100   | 0.023s\ncrossover        | 1.876s     | 100   | 0.019s\nmutation         | 0.987s     | 100   | 0.010s\n```\n\n#### 3.3. Wizualizacja postępu\n```cpp\nvoid GeneticAlgorithm::visualizeProgress() {\n    // Wykres fitness w czasie\n    plotFitnessProgress();\n    \n    // Wizualizacja różnorodności populacji\n    plotPopulationDiversity();\n    \n    // Statystyki operatorów\n    plotOperatorStatistics();\n}\n```\n\n### 4. Analiza wyników\n\n#### 4.1. Statystyki końcowe\n```cpp\nstruct DebugStatistics {\n    double bestFitness;\n    double averageFitness;\n    double worstFitness;\n    double populationDiversity;\n    int generationsToConvergence;\n    double executionTime;\n    \n    std::map\u003cstd::string, double\u003e operatorEffectiveness;\n};\n```\n\n#### 4.2. Walidacja rozwiązania\n```cpp\nvoid GeneticAlgorithm::validateSolution() {\n    auto bestSolution = getBestIndividual();\n    \n    // Sprawdzenie poprawności DNA\n    bool isValid = validator-\u003evalidateDNA(bestSolution-\u003egetDNA());\n    Logger::debug(f\"Poprawność rozwiązania: {isValid}\");\n    \n    // Szczegółowa analiza błędów\n    auto errors = validator-\u003eanalyzeErrors(bestSolution-\u003egetDNA());\n    for (const auto\u0026 error : errors) {\n        Logger::debug(f\"Błąd: {error.description} w pozycji {error.position}\");\n    }\n}\n```\n\n### 5. Przykład użycia trybu debug\n```cpp\nint main() {\n    // Inicjalizacja z trybem debug\n    auto ga = GeneticAlgorithm(config, true);\n    \n    // Uruchomienie z pełnym logowaniem\n    Logger::setLogLevel(Logger::Level::DEBUG);\n    Profiler::getInstance().enable();\n    \n    // Wykonanie algorytmu\n    auto result = ga.run(instance);\n    \n    // Analiza wyników\n    ga.validateSolution();\n    ga.visualizeProgress();\n    \n    // Generowanie raportu\n    Profiler::getInstance().generateReport(\"profiling_results.txt\");\n    Logger::saveLog(\"debug_log.txt\");\n}\n```\n\n## Skrypty testowania i analizy wyników (scripts/)\n\n### Framework testowania (sbh_testing_framework.py)\nFramework do automatycznego testowania rozwiązań na różnych instancjach:\n\n```python\nclass SBHTestingFramework:\n    def __init__(self, config_path: str):\n        \"\"\"\n        Inicjalizacja frameworku testowego\n        :param config_path: Ścieżka do pliku konfiguracyjnego\n        \"\"\"\n        self.config = self._load_config(config_path)\n        self.results_db = ResultsDatabase()\n        self.test_cases = TestCaseManager()\n    \n    def run_test_suite(self, test_suite: str):\n        \"\"\"\n        Uruchomienie zestawu testów\n        :param test_suite: Nazwa zestawu testów (np. 'easy', 'medium', 'hard')\n        \"\"\"\n        for test_case in self.test_cases.get_suite(test_suite):\n            self._run_single_test(test_case)\n            self._collect_metrics(test_case)\n    \n    def generate_report(self, output_path: str):\n        \"\"\"\n        Generowanie raportu z testów\n        :param output_path: Ścieżka do pliku wyjściowego\n        \"\"\"\n        self.results_db.generate_report(output_path)\n\nclass TestCase:\n    \"\"\"Reprezentacja pojedynczego przypadku testowego\"\"\"\n    def __init__(self, dna_length: int, oligo_length: int, \n                 neg_errors: int, pos_errors: int):\n        self.dna_length = dna_length\n        self.oligo_length = oligo_length\n        self.neg_errors = neg_errors\n        self.pos_errors = pos_errors\n        self.original_sequence = None\n        self.fragments = []\n```\n\n### System rankingowy (ranking_system.py)\nSystem do tworzenia rankingu rozwiązań:\n\n```python\nclass RankingSystem:\n    def __init__(self, results_db_path: str):\n        \"\"\"\n        Inicjalizacja systemu rankingowego\n        :param results_db_path: Ścieżka do bazy wyników\n        \"\"\"\n        self.results = self._load_results(results_db_path)\n        self.metrics = MetricsCalculator()\n    \n    def calculate_rankings(self):\n        \"\"\"Obliczanie rankingów dla różnych kategorii\"\"\"\n        return {\n            'overall': self._calculate_overall_ranking(),\n            'by_size': self._calculate_size_based_ranking(),\n            'by_error_type': self._calculate_error_based_ranking(),\n            'by_time': self._calculate_time_based_ranking()\n        }\n    \n    def generate_ranking_report(self, output_path: str):\n        \"\"\"\n        Generowanie raportu rankingowego\n        :param output_path: Ścieżka do pliku wyjściowego\n        \"\"\"\n        rankings = self.calculate_rankings()\n        self._generate_report(rankings, output_path)\n\nclass MetricsCalculator:\n    \"\"\"Kalkulator metryk dla rankingu\"\"\"\n    def calculate_solution_score(self, solution: Solution) -\u003e float:\n        \"\"\"\n        Obliczanie wyniku dla pojedynczego rozwiązania\n        Uwzględnia:\n        - Dokładność rekonstrukcji\n        - Czas wykonania\n        - Zużycie pamięci\n        - Stabilność wyników\n        \"\"\"\n        accuracy = self._calculate_accuracy(solution)\n        time_score = self._calculate_time_score(solution)\n        memory_score = self._calculate_memory_score(solution)\n        stability = self._calculate_stability(solution)\n        \n        return self._combine_scores(accuracy, time_score, \n                                  memory_score, stability)\n```\n\n### Wizualizacja wyników (visualization_manager.py)\nNarzędzie do wizualizacji wyników testów:\n\n```python\nclass VisualizationManager:\n    def __init__(self, results_data: pd.DataFrame):\n        \"\"\"\n        Inicjalizacja menedżera wizualizacji\n        :param results_data: DataFrame z wynikami\n        \"\"\"\n        self.data = results_data\n        self.plt_style = self._configure_plot_style()\n    \n    def plot_performance_comparison(self):\n        \"\"\"Generowanie wykresów porównawczych wydajności\"\"\"\n        self._plot_accuracy_comparison()\n        self._plot_time_comparison()\n        self._plot_memory_usage()\n        self._plot_convergence_rates()\n    \n    def generate_error_analysis(self):\n        \"\"\"Analiza i wizualizacja błędów\"\"\"\n        self._plot_error_distribution()\n        self._plot_error_correlation()\n        self._generate_error_heatmap()\n```\n\n### Przykłady użycia skryptów\n\n#### 1. Uruchomienie zestawu testów\n```python\n# Inicjalizacja i uruchomienie testów\nframework = SBHTestingFramework('config/test_config.yaml')\nframework.run_test_suite('comprehensive')\nframework.generate_report('results/test_report.pdf')\n```\n\n#### 2. Generowanie rankingu\n```python\n# Tworzenie rankingu rozwiązań\nranking = RankingSystem('results/results_database.db')\nrankings = ranking.calculate_rankings()\nranking.generate_ranking_report('results/ranking_report.pdf')\n```\n\n#### 3. Wizualizacja wyników\n```python\n# Wizualizacja wyników\nresults_data = pd.read_csv('results/test_results.csv')\nviz = VisualizationManager(results_data)\nviz.plot_performance_comparison()\nviz.generate_error_analysis()\n```\n\n### Format plików konfiguracyjnych\n\n#### test_config.yaml\n```yaml\ntest_suites:\n  easy:\n    dna_length: [300, 400]\n    oligo_length: [7, 8]\n    neg_errors: [0, 10]\n    pos_errors: [0, 10]\n    repetitions: 5\n  \n  medium:\n    dna_length: [500, 600]\n    oligo_length: [8, 9]\n    neg_errors: [20, 30]\n    pos_errors: [20, 30]\n    repetitions: 10\n    \n  hard:\n    dna_length: [700, 800]\n    oligo_length: [9, 10]\n    neg_errors: [40, 50]\n    pos_errors: [40, 50]\n    repetitions: 15\n```\n\n#### ranking_config.yaml\n```yaml\nmetrics:\n  accuracy:\n    weight: 0.4\n    threshold: 0.95\n  \n  time:\n    weight: 0.3\n    max_time: 3600\n  \n  memory:\n    weight: 0.2\n    max_memory: 1024\n  \n  stability:\n    weight: 0.1\n    min_repetitions: 5\n```\n\n### Generowane raporty\n\n#### Test Report (test_report.pdf)\n```\nTest Suite Results\n-----------------\nSuite: Comprehensive\nTotal test cases: 150\nSuccess rate: 92%\n\nDetailed Results:\n1. Easy instances (50 cases)\n   - Success rate: 98%\n   - Avg. time: 12.3s\n   - Avg. memory: 256MB\n\n2. Medium instances (50 cases)\n   - Success rate: 94%\n   - Avg. time: 45.7s\n   - Avg. memory: 512MB\n\n3. Hard instances (50 cases)\n   - Success rate: 84%\n   - Avg. time: 187.2s\n   - Avg. memory: 1024MB\n```\n\n#### Ranking Report (ranking_report.pdf)\n```\nAlgorithm Rankings\n-----------------\nOverall Ranking:\n1. AdaptiveGA v2.1 (Score: 0.92)\n2. StandardGA v1.5 (Score: 0.87)\n3. HybridGA v1.0 (Score: 0.85)\n\nCategory Rankings:\n1. Best for small instances:\n   - AdaptiveGA v2.1 (Score: 0.95)\n   \n2. Best for large instances:\n   - HybridGA v1.0 (Score: 0.88)\n   \n3. Best time performance:\n   - StandardGA v1.5 (Score: 0.91)\n```\n\n## Google Tests i metodologia testowania\n\n### 1. Struktura testów\n```\ntests/\n├── google_tests/                    # Testy jednostkowe z Google Test\n│   ├── genetic/                     # Testy modułu genetycznego\n│   │   ├── crossover_test.cpp      # Testy operatorów krzyżowania\n│   │   ├── mutation_test.cpp       # Testy operatorów mutacji\n│   │   ├── selection_test.cpp      # Testy metod selekcji\n│   │   └── fitness_test.cpp        # Testy funkcji przystosowania\n│   ├── dna/                        # Testy modułu DNA\n│   │   ├── instance_test.cpp       # Testy instancji DNA\n│   │   └── error_test.cpp          # Testy wprowadzania błędów\n│   └── utils/                      # Testy narzędzi\n│       ├── random_test.cpp         # Testy generatora liczb losowych\n│       └── timer_test.cpp          # Testy pomiaru czasu\n├── integration_tests/              # Testy integracyjne\n│   ├── algorithm_test.cpp          # Testy przepływu algorytmu\n│   └── system_test.cpp             # Testy całego systemu\n└── performance_tests/              # Testy wydajnościowe\n    ├── benchmark_test.cpp          # Testy wydajności\n    └── stress_test.cpp             # Testy obciążeniowe\n```\n\n### 2. Przykłady implementacji testów\n\n#### 2.1. Test operatora krzyżowania\n```cpp\nTEST(CrossoverTest, SinglePointCrossoverMaintainsValidPermutation) {\n    // Arrange\n    auto parent1 = std::make_shared\u003cIndividual\u003e(std::vector\u003cint\u003e{1,2,3,4,5});\n    auto parent2 = std::make_shared\u003cIndividual\u003e(std::vector\u003cint\u003e{5,4,3,2,1});\n    auto crossover = std::make_unique\u003cSinglePointCrossover\u003e();\n    \n    // Act\n    auto [child1, child2] = crossover-\u003ecrossover(parent1, parent2);\n    \n    // Assert\n    EXPECT_TRUE(isValidPermutation(child1-\u003egetGenes()));\n    EXPECT_TRUE(isValidPermutation(child2-\u003egetGenes()));\n    EXPECT_EQ(child1-\u003egetGenes().size(), 5);\n    EXPECT_EQ(child2-\u003egetGenes().size(), 5);\n}\n```\n\n#### 2.2. Test funkcji przystosowania\n```cpp\nTEST(FitnessTest, OptimalSolutionHasMaxFitness) {\n    // Arrange\n    auto instance = createTestInstance();\n    auto solution = createOptimalSolution(instance);\n    auto fitness = std::make_unique\u003cGraphBasedFitness\u003e();\n    \n    // Act\n    double fitnessValue = fitness-\u003ecalculate(solution-\u003egetGenes(), instance);\n    \n    // Assert\n    EXPECT_NEAR(fitnessValue, 1.0, 0.001);\n}\n```\n\n#### 2.3. Test mutacji\n```cpp\nTEST(MutationTest, SwapMutationChangesExactlyTwoPositions) {\n    // Arrange\n    auto individual = std::make_shared\u003cIndividual\u003e(std::vector\u003cint\u003e{1,2,3,4,5});\n    auto originalGenes = individual-\u003egetGenes();\n    auto mutation = std::make_unique\u003cSwapMutation\u003e(1.0); // 100% szansa na mutację\n    \n    // Act\n    mutation-\u003emutate(individual);\n    auto mutatedGenes = individual-\u003egetGenes();\n    \n    // Assert\n    int differences = 0;\n    for (size_t i = 0; i \u003c originalGenes.size(); ++i) {\n        if (originalGenes[i] != mutatedGenes[i]) differences++;\n    }\n    EXPECT_EQ(differences, 2);\n}\n```\n\n### 3. Testy wydajnościowe\n\n#### 3.1. Test obciążeniowy\n```cpp\nTEST(StressTest, HandlesLargeInstances) {\n    // Arrange\n    const int NUM_TESTS = 100;\n    const int DNA_LENGTH = 1000;\n    auto ga = setupGeneticAlgorithm();\n    \n    // Act \u0026 Assert\n    for (int i = 0; i \u003c NUM_TESTS; ++i) {\n        auto instance = generateLargeInstance(DNA_LENGTH);\n        auto start = std::chrono::high_resolution_clock::now();\n        \n        auto result = ga.run(instance);\n        \n        auto end = std::chrono::high_resolution_clock::now();\n        auto duration = std::chrono::duration_cast\u003cstd::chrono::seconds\u003e\n                       (end - start).count();\n        \n        EXPECT_LE(duration, 60); // Max 1 minuta na instancję\n        EXPECT_GE(ga.getBestFitness(), 0.85);\n    }\n}\n```\n\n### 4. Automatyzacja testów\n\n#### 4.1. Skrypt do uruchamiania testów\n```bash\n#!/bin/bash\n# run_tests.sh\n\n# Kompilacja\ncd build\ncmake -DBUILD_TESTING=ON ..\nmake -j$(nproc)\n\n# Testy jednostkowe\necho \"Running unit tests...\"\n./tests/google_tests/unit_tests --gtest_output=\"xml:unit_test_results.xml\"\n\n# Testy integracyjne\necho \"Running integration tests...\"\n./tests/integration_tests/integration_tests --gtest_output=\"xml:integration_test_results.xml\"\n\n# Testy wydajnościowe\necho \"Running performance tests...\"\n./tests/performance_tests/performance_tests --gtest_output=\"xml:performance_test_results.xml\"\n\n# Analiza wyników\npython3 ../scripts/analyze_test_results.py\n```\n\n#### 4.2. Skrypt analizy wyników\n```python\n# analyze_test_results.py\ndef analyze_test_results():\n    unit_results = parse_xml_results('unit_test_results.xml')\n    integration_results = parse_xml_results('integration_test_results.xml')\n    performance_results = parse_xml_results('performance_test_results.xml')\n    \n    generate_report(unit_results, integration_results, performance_results)\n```\n\n### 5. Konfiguracja CMake dla testów\n\n```cmake\n# CMakeLists.txt\nenable_testing()\n\n# Google Test\nfind_package(GTest REQUIRED)\ninclude_directories(${GTEST_INCLUDE_DIRS})\n\n# Testy jednostkowe\nadd_executable(unit_tests\n    tests/google_tests/genetic/crossover_test.cpp\n    tests/google_tests/genetic/mutation_test.cpp\n    tests/google_tests/genetic/selection_test.cpp\n    tests/google_tests/genetic/fitness_test.cpp\n    # ... pozostałe pliki testów\n)\n\ntarget_link_libraries(unit_tests\n    PRIVATE\n    GTest::GTest\n    GTest::Main\n    ${PROJECT_NAME}_lib\n)\n\n# Dodanie testów do CTest\nadd_test(NAME unit_tests COMMAND unit_tests)\nadd_test(NAME integration_tests COMMAND integration_tests)\nadd_test(NAME performance_tests COMMAND performance_tests)\n```\n\n### 6. Continuous Integration\n\n```yaml\n# .github/workflows/tests.yml\nname: Tests\n\non: [push, pull_request]\n\njobs:\n  test:\n    runs-on: ubuntu-latest\n    \n    steps:\n    - uses: actions/checkout@v2\n    \n    - name: Install dependencies\n      run: |\n        sudo apt-get update\n        sudo apt-get install -y libgtest-dev cmake\n        \n    - name: Build and test\n      run: |\n        mkdir build \u0026\u0026 cd build\n        cmake -DBUILD_TESTING=ON ..\n        make\n        ctest --output-on-failure --verbose\n```\n\n### 7. Pokrycie kodu testami\n\n#### 7.1. Konfiguracja lcov\n```bash\n# Instalacja lcov\nsudo apt-get install lcov\n\n# Kompilacja z flagami pokrycia\ncmake -DCMAKE_BUILD_TYPE=Debug -DENABLE_COVERAGE=ON ..\nmake\n\n# Generowanie raportu pokrycia\nlcov --capture --directory . --output-file coverage.info\nlcov --remove coverage.info '/usr/*' --output-file coverage.info\ngenhtml coverage.info --output-directory coverage_report\n```\n\n#### 7.2. Badge pokrycia w README\n```markdown\n![Coverage](https://img.shields.io/badge/coverage-94%25-green.svg)\n```\n\n### 8. Dobre praktyki testowania\n\n1. **Organizacja testów**\n   - Jeden plik testowy na jeden plik źródłowy\n   - Grupowanie testów w logiczne kategorie\n   - Jasne nazewnictwo testów (Given_When_Then)\n\n2. **Struktura testu**\n   - Arrange (przygotowanie)\n   - Act (działanie)\n   - Assert (sprawdzenie)\n\n3. **Testowanie brzegowych przypadków**\n   - Puste wejście\n   - Maksymalne wartości\n   - Nieprawidłowe dane\n   - Błędy alokacji pamięci\n\n4. **Mockowanie i stubbing**\n   - Używanie mock objects dla zewnętrznych zależności\n   - Stubbing dla deterministycznych testów\n   - Izolacja testowanego kodu\n\n5. **Wydajność testów**\n   - Szybkie testy jednostkowe\n   - Dłuższe testy integracyjne w osobnej grupie\n   - Testy wydajnościowe uruchamiane na żądanie\n```\n\n## Operatory krzyżowania (Crossover)\n\n### 1. Krzyżowanie jednopunktowe (SinglePointCrossover)\n```cpp\nclass SinglePointCrossover : public ICrossover {\n    std::pair\u003cstd::shared_ptr\u003cIndividual\u003e, std::shared_ptr\u003cIndividual\u003e\u003e\n    crossover(const std::shared_ptr\u003cIndividual\u003e\u0026 parent1,\n             const std::shared_ptr\u003cIndividual\u003e\u0026 parent2) override;\n};\n```\n\n#### Zasada działania:\n1. Wybierany jest losowy punkt przecięcia (k) w zakresie [1, n-1], gdzie n to długość chromosomu\n2. Pierwszy potomek otrzymuje geny [1..k] od pierwszego rodzica i [k+1..n] od drugiego\n3. Drugi potomek otrzymuje geny [1..k] od drugiego rodzica i [k+1..n] od pierwszego\n4. Wykonywana jest naprawa permutacji, aby zachować poprawność rozwiązania\n\n#### Przykład:\n```\nRodzic 1: [1 2 3 | 4 5 6]\nRodzic 2: [6 5 4 | 3 2 1]\nPunkt przecięcia: 3\n\nPrzed naprawą:\nPotomek 1: [1 2 3 | 3 2 1]\nPotomek 2: [6 5 4 | 4 5 6]\n\nPo naprawie:\nPotomek 1: [1 2 3 | 6 5 4]\nPotomek 2: [6 5 4 | 1 2 3]\n```\n\n### 2. Krzyżowanie dwupunktowe (TwoPointCrossover)\n```cpp\nclass TwoPointCrossover : public ICrossover {\n    std::pair\u003cstd::shared_ptr\u003cIndividual\u003e, std::shared_ptr\u003cIndividual\u003e\u003e\n    crossover(const std::shared_ptr\u003cIndividual\u003e\u0026 parent1,\n             const std::shared_ptr\u003cIndividual\u003e\u0026 parent2) override;\n};\n```\n\n#### Zasada działania:\n1. Wybierane są dwa losowe punkty przecięcia (k1, k2) gdzie k1 \u003c k2\n2. Pierwszy potomek otrzymuje segmenty [1..k1] i [k2+1..n] od pierwszego rodzica i [k1+1..k2] od drugiego\n3. Drugi potomek otrzymuje segmenty [1..k1] i [k2+1..n] od drugiego rodzica i [k1+1..k2] od pierwszego\n4. Wykonywana jest naprawa permutacji\n\n#### Przykład:\n```\nRodzic 1: [1 2 | 3 4 | 5 6]\nRodzic 2: [6 5 | 4 3 | 2 1]\nPunkty przecięcia: 2, 4\n\nPrzed naprawą:\nPotomek 1: [1 2 | 4 3 | 5 6]\nPotomek 2: [6 5 | 3 4 | 2 1]\n\nPo naprawie:\nPotomek 1: [1 2 | 4 3 | 5 6]\nPotomek 2: [6 5 | 3 4 | 2 1]\n```\n\n### 3. Krzyżowanie równomierne (UniformCrossover)\n```cpp\nclass UniformCrossover : public ICrossover {\n    std::pair\u003cstd::shared_ptr\u003cIndividual\u003e, std::shared_ptr\u003cIndividual\u003e\u003e\n    crossover(const std::shared_ptr\u003cIndividual\u003e\u0026 parent1,\n             const std::shared_ptr\u003cIndividual\u003e\u0026 parent2) override;\nprivate:\n    double crossoverProbability = 0.5;\n};\n```\n\n#### Zasada działania:\n1. Dla każdej pozycji i w chromosomie:\n   - Z prawdopodobieństwem p (domyślnie 0.5) gen pochodzi od pierwszego rodzica\n   - Z prawdopodobieństwem (1-p) gen pochodzi od drugiego rodzica\n2. Wykonywana jest naprawa permutacji dla obu potomków\n\n#### Przykład:\n```\nRodzic 1: [1 2 3 4 5 6]\nRodzic 2: [6 5 4 3 2 1]\nMaska:    [1 0 1 0 1 0] (1: gen z rodzica 1, 0: gen z rodzica 2)\n\nPrzed naprawą:\nPotomek 1: [1 5 3 3 5 1]\nPotomek 2: [6 2 4 4 2 6]\n\nPo naprawie:\nPotomek 1: [1 5 3 4 2 6]\nPotomek 2: [6 2 4 3 5 1]\n```\n\n### 4. Krzyżowanie adaptacyjne (AdaptiveCrossover)\n```cpp\nclass AdaptiveCrossover : public ICrossover {\n    std::pair\u003cstd::shared_ptr\u003cIndividual\u003e, std::shared_ptr\u003cIndividual\u003e\u003e\n    crossover(const std::shared_ptr\u003cIndividual\u003e\u0026 parent1,\n             const std::shared_ptr\u003cIndividual\u003e\u0026 parent2) override;\nprivate:\n    void updateCrossoverRates();\n    void adaptParameters();\n    std::vector\u003cCrossoverOperator\u003e operators;\n    std::vector\u003cdouble\u003e successRates;\n};\n```\n\n#### Zasada działania:\n1. Utrzymuje pulę różnych operatorów krzyżowania\n2. Monitoruje skuteczność każdego operatora\n3. Adaptuje prawdopodobieństwa użycia operatorów na podstawie ich skuteczności\n4. Wybiera operator do krzyżowania na podstawie zaktualizowanych prawdopodobieństw\n\n#### Przykład adaptacji:\n```\nPoczątkowe prawdopodobieństwa:\n- SinglePoint:        0.33\n- TwoPoint:          0.33\n- Uniform:           0.33\n- Cycle:             0.33\n- PMX:               0.33\n- EdgeRecombination: 0.33\n\nPo 100 generacjach:\n- SinglePoint:        0.45 (najlepsze wyniki)\n- TwoPoint:          0.35\n- Uniform:           0.20 (najgorsze wyniki)\n```\n\n### 5. Krzyżowanie cykliczne (CycleCrossover)\n```cpp\nclass CycleCrossover : public ICrossover {\n    std::pair\u003cstd::shared_ptr\u003cIndividual\u003e, std::shared_ptr\u003cIndividual\u003e\u003e\n    crossover(const std::shared_ptr\u003cIndividual\u003e\u0026 parent1,\n             const std::shared_ptr\u003cIndividual\u003e\u0026 parent2) override;\nprivate:\n    std::vector\u003cint\u003e findCycle(const std::vector\u003cint\u003e\u0026 p1, \n                              const std::vector\u003cint\u003e\u0026 p2);\n};\n```\n\n#### Zasada działania:\n1. Znajduje cykle w permutacjach rodziców\n2. Zachowuje kompletne cykle z pierwszego rodzica dla pierwszego potomka\n3. Wypełnia pozostałe pozycje genami z drugiego rodzica\n4. Dla drugiego potomka proces jest odwrotny\n\n#### Przykład:\n```\nRodzic 1: [1 2 3 4 5 6]\nRodzic 2: [2 4 5 1 6 3]\n\nCykl 1: 1-\u003e2-\u003e4-\u003e1\nCykl 2: 3-\u003e5-\u003e6-\u003e3\n\nPotomek 1: [1 2 5 4 6 3]\nPotomek 2: [2 4 3 1 5 6]\n```\n\n### 6. Krzyżowanie porządkowe (OrderCrossover)\n```cpp\nclass OrderCrossover : public ICrossover {\n    std::pair\u003cstd::shared_ptr\u003cIndividual\u003e, std::shared_ptr\u003cIndividual\u003e\u003e\n    crossover(const std::shared_ptr\u003cIndividual\u003e\u0026 parent1,\n             const std::shared_ptr\u003cIndividual\u003e\u0026 parent2) override;\n};\n```\n\n#### Zasada działania:\n1. Wybiera losowy podciąg z pierwszego rodzica\n2. Kopiuje ten podciąg do potomka na te same pozycje\n3. Wypełnia pozostałe pozycje genami z drugiego rodzica w kolejności ich występowania\n4. Dla drugiego potomka proces jest odwrotny\n\n#### Przykład:\n```\nRodzic 1: [1 2 3 4 5 6]\nRodzic 2: [6 5 4 3 2 1]\nWybrany podciąg: [2 3 4]\n\nPotomek 1: [6 2 3 4 5 1]\nPotomek 2: [1 5 4 3 2 6]\n```\n\n### 7. Implementacja naprawy permutacji\n```cpp\nclass PermutationRepair {\npublic:\n    static void repair(std::vector\u003cint\u003e\u0026 genes) {\n        std::vector\u003cbool\u003e used(genes.size(), false);\n        std::vector\u003cint\u003e missing;\n        \n        // Znajdź duplikaty i brakujące elementy\n        for (int i = 0; i \u003c genes.size(); i++) {\n            if (used[genes[i]]) {\n                missing.push_back(i);\n            } else {\n                used[genes[i]] = true;\n            }\n        }\n        \n        // Znajdź brakujące wartości\n        std::vector\u003cint\u003e values;\n        for (int i = 0; i \u003c used.size(); i++) {\n            if (!used[i]) {\n                values.push_back(i);\n            }\n        }\n        \n        // Napraw permutację\n        for (int i = 0; i \u003c missing.size(); i++) {\n            genes[missing[i]] = values[i];\n        }\n    }\n};\n```\n\n### 8. Porównanie skuteczności operatorów\n```cpp\nstruct CrossoverEffectiveness {\n    std::string name;\n    double avgFitness;\n    double successRate;\n    double avgExecutionTime;\n    int validOffspringRate;\n};\n\nstd::vector\u003cCrossoverEffectiveness\u003e results = {\n    {\"SinglePoint\",  0.85, 0.92, 0.12, 95},\n    {\"TwoPoint\",     0.87, 0.90, 0.15, 93},\n    {\"Uniform\",      0.82, 0.88, 0.18, 90},\n    {\"Adaptive\",     0.89, 0.94, 0.20, 96},\n    {\"Cycle\",        0.84, 0.89, 0.14, 94},\n    {\"Order\",        0.86, 0.91, 0.13, 92}\n};\n```\n\n### 9. Krzyżowanie PMX (Partially Mapped Crossover)\n```cpp\nclass PMXCrossover : public ICrossover {\n    std::pair\u003cstd::shared_ptr\u003cIndividual\u003e, std::shared_ptr\u003cIndividual\u003e\u003e\n    crossover(const std::shared_ptr\u003cIndividual\u003e\u0026 parent1,\n             const std::shared_ptr\u003cIndividual\u003e\u0026 parent2) override;\nprivate:\n    void createMapping(const std::vector\u003cint\u003e\u0026 section1,\n                      const std::vector\u003cint\u003e\u0026 section2,\n                      std::map\u003cint, int\u003e\u0026 mapping);\n};\n```\n\n#### Zasada działania:\n1. Wybiera dwa punkty przecięcia, definiując sekcję do mapowania\n2. Kopiuje sekcję z pierwszego rodzica do pierwszego potomka\n3. Tworzy mapowanie między elementami w sekcji\n4. Używa mapowania do wypełnienia pozostałych pozycji\n5. Powtarza proces dla drugiego potomka w odwrotnej kolejności\n\n#### Przykład:\n```\nRodzic 1: [1 2 3 | 4 5 6 | 7 8 9]\nRodzic 2: [9 8 7 | 1 3 2 | 6 5 4]\nPunkty przecięcia: 3, 6\n\nMapowanie:\n4 ↔ 1\n5 ↔ 3\n6 ↔ 2\n\nPrzed mapowaniem:\nPotomek 1: [_ _ _ | 4 5 6 | _ _ _]\nPotomek 2: [_ _ _ | 1 3 2 | _ _ _]\n\nPo mapowaniu:\nPotomek 1: [3 1 2 | 4 5 6 | 7 8 9]\nPotomek 2: [9 8 7 | 1 3 2 | 4 5 6]\n```\n\n### 10. Krzyżowanie krawędziowe (Edge Recombination Crossover)\n```cpp\nclass EdgeRecombinationCrossover : public ICrossover {\n    std::pair\u003cstd::shared_ptr\u003cIndividual\u003e, std::shared_ptr\u003cIndividual\u003e\u003e\n    crossover(const std::shared_ptr\u003cIndividual\u003e\u0026 parent1,\n             const std::shared_ptr\u003cIndividual\u003e\u0026 parent2) override;\nprivate:\n    struct EdgeList {\n        std::vector\u003cstd::set\u003cint\u003e\u003e adjacency;\n        void buildFrom(const std::vector\u003cint\u003e\u0026 p1, const std::vector\u003cint\u003e\u0026 p2);\n        std::set\u003cint\u003e getNeighbors(int node) const;\n        void removeNode(int node);\n    };\n};\n```\n\n#### Zasada działania:\n1. Tworzy listę krawędzi (sąsiedztwa) z obu rodziców\n2. Rozpoczyna od losowego miasta z jednego z rodziców\n3. Iteracyjnie wybiera następne miasto z najmniejszą liczbą pozostałych sąsiadów\n4. W przypadku remisu, wybiera losowo z dostępnych opcji\n5. Aktualizuje listę krawędzi po każdym wyborze\n\n#### Przykład:\n```\nRodzic 1: [1 2 3 4 5]\nRodzic 2: [5 3 1 2 4]\n\nLista sąsiedztwa:\n1: {2, 3, 5}  // Sąsiedzi z obu rodziców\n2: {1, 3, 4}\n3: {1, 2, 4, 5}\n4: {2, 3, 5}\n5: {1, 3, 4}\n\nProces budowy potomka:\nStart: 1\nLista sąsiadów: 2(2), 3(3), 5(2) → Wybierz 2\nLista sąsiadów: 3(2), 4(1) → Wybierz 3\nLista sąsiadów: 4(1), 5(1) → Wybierz 4\nPozostało: 5\n\nPotomek: [1 2 3 4 5]\n```\n\n### 11. Krzyżowanie adaptacyjne rozszerzone (Enhanced Adaptive Crossover)\n```cpp\nclass EnhancedAdaptiveCrossover : public ICrossover {\n    std::pair\u003cstd::shared_ptr\u003cIndividual\u003e, std::shared_ptr\u003cIndividual\u003e\u003e\n    crossover(const std::shared_ptr\u003cIndividual\u003e\u0026 parent1,\n             const std::shared_ptr\u003cIndividual\u003e\u0026 parent2) override;\nprivate:\n    std::vector\u003cstd::shared_ptr\u003cICrossover\u003e\u003e m_crossovers;\n    std::vector\u003cdouble\u003e m_weights;\n    \n    void updateWeights(const std::vector\u003cdouble\u003e\u0026 fitnessDiffs);\n    std::shared_ptr\u003cICrossover\u003e selectOperator();\n};\n```\n\n#### Zasada działania:\n1. Utrzymuje pulę wszystkich dostępnych operatorów krzyżowania:\n   - SinglePointCrossover\n   - TwoPointCrossover\n   - UniformCrossover\n   - CycleCrossover\n   - PMXCrossover\n   - EdgeRecombinationCrossover\n\n2. Adaptacyjnie dostosowuje wagi operatorów na podstawie ich skuteczności:\n   ```cpp\n   void updateWeights(const std::vector\u003cdouble\u003e\u0026 fitnessDiffs) {\n       double total = 0.0;\n       for (size_t i = 0; i \u003c m_crossovers.size(); ++i) {\n           m_weights[i] = m_weights[i] * 0.9 + fitnessDiffs[i] * 0.1;\n           total += m_weights[i];\n       }\n       // Normalizacja wag\n       for (auto\u0026 weight : m_weights) {\n           weight /= total;\n       }\n   }\n   ```\n\n#### Przykład adaptacji:\n```\nPoczątkowe wagi:\n- SinglePoint:        0.167\n- TwoPoint:          0.167\n- Uniform:           0.167\n- Cycle:             0.167\n- PMX:               0.167\n- EdgeRecombination: 0.167\n\nPo 100 generacjach:\n- SinglePoint:        0.15\n- TwoPoint:          0.12\n- Uniform:           0.10\n- Cycle:             0.20\n- PMX:               0.30\n- EdgeRecombination: 0.20\n```\n\n### 12. Porównanie skuteczności wszystkich operatorów\n```cpp\nstruct DetailedCrossoverEffectiveness {\n    std::string name;\n    double avgFitness;\n    double successRate;\n    double avgExecutionTime;\n    int validOffspringRate;\n    double diversityMaintenance;\n    double convergenceSpeed;\n};\n\nstd::vector\u003cDetailedCrossoverEffectiveness\u003e extendedResults = {\n    {\"SinglePoint\",        0.85, 0.92, 0.12, 95, 0.75, 0.82},\n    {\"TwoPoint\",          0.87, 0.90, 0.15, 93, 0.78, 0.85},\n    {\"Uniform\",           0.82, 0.88, 0.18, 90, 0.85, 0.78},\n    {\"Cycle\",             0.84, 0.89, 0.14, 94, 0.80, 0.83},\n    {\"PMX\",               0.89, 0.94, 0.16, 96, 0.88, 0.90},\n    {\"EdgeRecombination\", 0.88, 0.93, 0.20, 95, 0.90, 0.87},\n    {\"AdaptiveMix\",       0.91, 0.95, 0.22, 97, 0.92, 0.92}\n};\n```\n\nWnioski z porównania:\n1. PMX i EdgeRecombination najlepiej zachowują strukturę rozwiązania\n2. Adaptive Mix osiąga najlepsze wyniki dzięki dynamicznemu doborowi operatorów\n3. EdgeRecombination najlepiej zachowuje różnorodność populacji\n4. PMX ma najlepszy stosunek jakości do czasu wykonania\n5. Operatory proste (SinglePoint, TwoPoint) są najszybsze, ale mniej skuteczne\n\n# Test Coverage Overview\n\n## I. Pliki `.cpp` (z katalogu `src`)\n\n### 1. Benchmark\n| Plik źródłowy                                 | Plik testowy                                                        | Status |\n|-----------------------------------------------|---------------------------------------------------------------------|---------|\n| src/benchmark/adaptive_crossover_benchmark.cpp| tests/google_tests/benchmark/adaptive_crossover_benchmark_test.cpp | ❌      |\n| src/benchmark/crossover_benchmark.cpp         | tests/google_tests/benchmark/crossover_benchmark_test.cpp          | ❌      |\n| src/benchmark/naive_benchmark.cpp             | tests/google_tests/benchmark/naive_benchmark_test.cpp              | ❌      |\n\n### 2. Configuration\n| Plik źródłowy                                          | Plik testowy                                                       | Status |\n|--------------------------------------------------------|----------------------------------------------------------------------|---------|\n| src/configuration/genetic_algorithm_configuration.cpp   | tests/google_tests/configuration/genetic_algorithm_configuration_test.cpp | ❌      |\n\n### 3. DNA\n| Plik źródłowy                      | Plik testowy                                             | Status |\n|------------------------------------|------------------------------------------------------------|---------|\n| src/dna/dna_generator.cpp          | tests/google_tests/dna/dna_generator_test.cpp              | ✅      |\n| src/dna/dna_instance.cpp           | tests/google_tests/dna/dna_instance_test.cpp               | ✅      |\n| src/dna/dna_instance_builder.cpp   | tests/google_tests/dna/dna_instance_builder_test.cpp       | ✅      |\n| src/dna/dna_instance_io.cpp        | tests/google_tests/dna/dna_instance_io_test.cpp            | ✅      |\n| src/dna/error_introduction.cpp     | tests/google_tests/dna/error_introduction_test.cpp         | ✅      |\n| src/dna/spectrum_generator.cpp     | tests/google_tests/dna/spectrum_generator_test.cpp         | ✅      |\n\n### 4. Generator\n| Plik źródłowy                         | Plik testowy                                                | Status |\n|---------------------------------------|---------------------------------------------------------------|---------|\n| src/generator/dna_generator.cpp       | tests/google_tests/generator/dna_generator_test.cpp           | ✅      |\n| src/generator/spectrum_generator.cpp  | tests/google_tests/generator/spectrum_generator_test.cpp      | ✅      |\n\n### 5. Main\n| Plik źródłowy             | Plik testowy                                   | Status |\n|---------------------------|--------------------------------------------------|---------|\n| src/main.cpp              | tests/google_tests/main/main_test.cpp            | ❌      |\n\n### 6. Metaheuristics\n| Plik źródłowy                                      | Plik testowy                                                    | Status |\n|----------------------------------------------------|-------------------------------------------------------------------|---------|\n| src/metaheuristics/adaptive_crossover.cpp          | tests/google_tests/metaheuristics/adaptive_crossover_test.cpp     | ✅      |\n| src/metaheuristics/crossover.cpp                   | tests/google_tests/metaheuristics/crossover_test.cpp              | ❌      |\n| src/metaheuristics/crossover_impl.cpp              | tests/google_tests/metaheuristics/crossover_impl_test.cpp         | ❌      |\n| src/metaheuristics/edge_table.cpp                  | tests/google_tests/metaheuristics/edge_table_test.cpp             | ❌      |\n| src/metaheuristics/fitness.cpp                     | tests/google_tests/metaheuristics/fitness_test.cpp                | ❌      |\n| src/metaheuristics/fitness_impl.cpp                | tests/google_tests/metaheuristics/fitness_impl_test.cpp           | ❌      |\n| src/metaheuristics/genetic_algorithm.cpp           | tests/google_tests/metaheuristics/genetic_algorithm_test.cpp      | ✅      |\n| src/metaheuristics/genetic_algorithm_runner.cpp    | tests/google_tests/metaheuristics/genetic_algorithm_runner_test.cpp | ❌     |\n| src/metaheuristics/individual.cpp                  | tests/google_tests/metaheuristics/individual_test.cpp             | ❌      |\n| src/metaheuristics/mutation.cpp                    | tests/google_tests/metaheuristics/mutation_test.cpp               | ❌      |\n| src/metaheuristics/mutation_impl.cpp               | tests/google_tests/metaheuristics/mutation_impl_test.cpp          | ❌      |\n| src/metaheuristics/path_analyzer.cpp               | tests/google_tests/metaheuristics/path_analyzer_test.cpp          | ❌      |\n| src/metaheuristics/permutation_representation.cpp  | tests/google_tests/metaheuristics/permutation_representation_test.cpp | ❌  |\n| src/metaheuristics/population_cache.cpp            | tests/google_tests/metaheuristics/population_cache_test.cpp       | ❌      |\n| src/metaheuristics/selection.cpp                   | tests/google_tests/metaheuristics/selection_test.cpp              | ❌      |\n| src/metaheuristics/selection_impl.cpp              | tests/google_tests/metaheuristics/selection_impl_test.cpp         | ❌      |\n| src/metaheuristics/stopping_criteria.cpp           | tests/google_tests/metaheuristics/stopping_criteria_test.cpp      | ❌      |\n\n### 7. Naive\n| Plik źródłowy                              | Plik testowy                                             | Status |\n|--------------------------------------------|------------------------------------------------------------|---------|\n| src/naive/naive_reconstruction.cpp         | tests/google_tests/naive/naive_reconstruction_test.cpp     | ❌      |\n\n### 8. Tuning\n| Plik źródłowy                                 | Plik testowy                                                       | Status |\n|-----------------------------------------------|----------------------------------------------------------------------|---------|\n| src/tuning/parameter_parser.cpp               | tests/google_tests/tuning/parameter_parser_test.cpp                  | ❌      |\n| src/tuning/parameter_tuning_manager.cpp       | tests/google_tests/tuning/parameter_tuning_manager_test.cpp          | ❌      |\n| src/tuning/tuning_structures.cpp              | tests/google_tests/tuning/tuning_structures_test.cpp                 | ❌      |\n\n### 9. Utils\n| Plik źródłowy                                             | Plik testowy                                              | Status |\n|-----------------------------------------------------------|-------------------------------------------------------------|---------|\n| src/utils/logging.cpp                                     | tests/google_tests/utils/logging_test.cpp                   | ❌      |\n| src/utils/performance_profilling_framework.cpp            | tests/google_tests/utils/performance_profilling_test.cpp    | ❌      |\n| src/utils/utility_functions.cpp                           | tests/google_tests/utils/utility_functions_test.cpp         | ❌      |\n\n## II. Pliki nagłówkowe `.h` bez plików `.cpp`\n\n### A. `include/common.h`\n| Plik nagłówkowy                      | Plik testowy                                | Status |\n|--------------------------------------|-----------------------------------------------|---------|\n| include/common.h                     | tests/google_tests/common/common_test.cpp     | ❌      |\n\n### B. `include/config`\n| Plik nagłówkowy                      | Plik testowy                                   | Status |\n|--------------------------------------|--------------------------------------------------|---------|\n| include/config/genetic_config.h      | tests/google_tests/config/genetic_config_test.cpp| ❌      |\n\n### C. `include/interfaces`\n| Plik nagłówkowy                      | Plik testowy                                       | Status |\n|--------------------------------------|-------------------------------------------------------|---------|\n| include/interfaces/i_algorithm.h     | tests/google_tests/interfaces/i_algorithm_test.cpp    | ❌      |\n| include/interfaces/i_benchmark.h     | tests/google_tests/interfaces/i_benchmark_test.cpp    | ❌      |\n| include/interfaces/i_crossover.h     | tests/google_tests/interfaces/i_crossover_test.cpp    | ❌      |\n| include/interfaces/i_fitness.h       | tests/google_tests/interfaces/i_fitness_test.cpp      | ❌      |\n| include/interfaces/i_mutation.h      | tests/google_tests/interfaces/i_mutation_test.cpp     | ❌      |\n| include/interfaces/i_population_cache.h | tests/google_tests/interfaces/i_population_cache_test.cpp| ❌      |\n| include/interfaces/i_replacement.h   | tests/google_tests/interfaces/i_replacement_test.cpp  | ❌      |\n| include/interfaces/i_representation.h| tests/google_tests/interfaces/i_representation_test.cpp| ❌      |\n| include/interfaces/i_selection.h     | tests/google_tests/interfaces/i_selection_test.cpp    | ❌      |\n| include/interfaces/i_stopping.h      | tests/google_tests/interfaces/i_stopping_test.cpp     | ❌      |\n\n### D. `include/io`\n| Plik nagłówkowy                     | Plik testowy                               | Status |\n|-------------------------------------|----------------------------------------------|---------|\n| include/io/instance_io.h            | tests/google_tests/io/instance_io_test.cpp   | ✅      |\n\n### E. `include/metaheuristics`\n| Plik nagłówkowy                       | Plik testowy                                                 | Status |\n|---------------------------------------|----------------------------------------------------------------|---------|\n| include/metaheuristics/adaptive_mutation.h       | tests/google_tests/metaheuristics/adaptive_mutation_test.cpp       | ❌      |\n| include/metaheuristics/concrete_fitness.h        | tests/google_tests/metaheuristics/concrete_fitness_test.cpp        | ❌      |\n| include/metaheuristics/dna_utils.h               | tests/google_tests/metaheuristics/dna_utils_test.cpp               | ❌      |\n| include/metaheuristics/preprocessed_edge.h       | tests/google_tests/metaheuristics/preprocessed_edge_test.cpp       | ❌      |\n| include/metaheuristics/replacement_impl.h        | tests/google_tests/metaheuristics/replacement_impl_test.cpp        | ❌      |\n\n### F. `include/tuning`\n| Plik nagłówkowy                         | Plik testowy                                           | Status |\n|-----------------------------------------|----------------------------------------------------------|---------|\n| include/tuning/meta_ea.h               | tests/google_tests/tuning/meta_ea_test.cpp               | ❌      |\n| include/tuning/parameters.h            | tests/google_tests/tuning/parameters_test.cpp            | ❌      |\n| include/tuning/racing.h                | tests/google_tests/tuning/racing_test.cpp                | ❌      |\n\n### G. `include/utils`\n| Plik nagłówkowy                                      | Plik testowy                                              | Status |\n|------------------------------------------------------|-------------------------------------------------------------|---------|\n| include/utils/random.h                               | tests/google_tests/utils/random_test.cpp                    | ✅      |\n| include/utils/timer.h                                | tests/google_tests/utils/timer_test.cpp                     | ❌      |\n| include/utils/zobrist_hasher.h                       | tests/google_tests/utils/zobrist_hasher_test.cpp            | ❌      |\n\n## Test Coverage Summary\n\n- Total Files: 52\n- Files with Tests: 11\n- Coverage Percentage: 21.15%\n\n### Coverage by Module\n- DNA Module: 100% (6/6)\n- Generator Module: 100% (2/2)\n- Metaheuristics Module: 11.76% (2/17)\n- Utils Module: 33.33% (1/3)\n- Other Modules: 0% (0/24)\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fkgorze%2Fdna-assembly-problem-solver","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fkgorze%2Fdna-assembly-problem-solver","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fkgorze%2Fdna-assembly-problem-solver/lists"}