genetic-algorithm-lib 1.0.0__cp310-cp310-win32.whl

genetic_algorithm_lib/__init__.py

@@ -0,0 +1,29 @@
+"""Python bindings for the Genetic Algorithm framework.
+
+This package is a thin wrapper around the compiled extension module ``_core``.
+After installation, users should:
+
+    import genetic_algorithm_lib as ga
+
+"""
+
+from __future__ import annotations
+
+# The extension is expected to live at ``genetic_algorithm_lib._core`` in wheels.
+# The fallback supports local non-wheel builds where it may be top-level.
+try:
+    from ._core import *  # type: ignore  # noqa: F401,F403
+except ImportError:  # pragma: no cover
+    from _core import *  # type: ignore  # noqa: F401,F403
+
+
+def __getattr__(name: str):
+    if name == "__version__":
+        from importlib.metadata import PackageNotFoundError, version
+
+        try:
+            return version("genetic-algorithm-lib")
+        except PackageNotFoundError:  # pragma: no cover
+            return "0.0.0"
+
+    raise AttributeError(name)

genetic_algorithm_lib-1.0.0.dist-info/METADATA

@@ -0,0 +1,576 @@
+Metadata-Version: 2.2
+Name: genetic-algorithm-lib
+Version: 1.0.0
+Summary: Genetic Algorithm framework with C++ core and Python bindings
+Author: Rahuldrabit
+License: Apache-2.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C++
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering
+Project-URL: Homepage, https://github.com/Rahuldrabit/Genetic_algorithm
+Project-URL: Repository, https://github.com/Rahuldrabit/Genetic_algorithm
+Project-URL: Issues, https://github.com/Rahuldrabit/Genetic_algorithm/issues
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Genetic Algorithm Framework (C++)
+
+A reusable C++ genetic algorithm framework you can embed in any application. It exposes a small, modern C++ API and ships with a rich set of crossover, mutation, and selection operators.
+
+## 🚀 Features
+
+- **Multi-Representation Support**: Binary, Real-valued, Integer, and Permutation representations
+- **Comprehensive Operators**: 35+ crossover, mutation, and selection operators
+- **Benchmark Functions**: Rastrigin, Ackley, Schwefel, Rosenbrock, and Sphere optimization problems
+- **Modern Build System**: CMake-based build configuration
+- **Cross-Platform**: Works on Linux, macOS, and Windows
+- **Multi-Language Support**: C++ (primary), Python bindings, and C-compatible interfaces
+- **Performance Benchmarks**: Comprehensive benchmark suite for operators and functions
+- **Production-Ready**: Modern C++17 with smart pointers and RAII
+
+## 📖 Documentation
+
+- **Complete user guide with C++ and Python examples**: [USER_GUIDE.md](USER_GUIDE.md)
+- Complete feature checklist : [FEATURE_CHECKLIST.md](FEATURE_CHECKLIST.md)
+- Architecture overview and usage guidance: [ARCHITECTURE.md](ARCHITECTURE.md)
+
+## 📁 Project Structure
+
+```
+Genetic_algorithm/
+├── CMakeLists.txt              # Main CMake configuration
+├── README.md                   # This file
+├── include/ga/                 # Public framework headers (installable)
+│   ├── config.hpp              # Config, Bounds, Result, Fitness alias
+│   └── genetic_algorithm.hpp   # GeneticAlgorithm class and factories
+├── src/
+│   └── genetic_algorithm.cpp   # Core GA engine implementation
+├── examples/
+│   └── minimal.cpp             # Tiny example app using the framework
+├── simple-ga-test.cc           # Legacy interactive demo (still works)
+├── crossover/                  # Crossover operators
+│   ├── base_crossover.h/cc     # Base crossover interface
+│   ├── one_point_crossover.h/cc
+│   ├── two_point_crossover.h/cc
+│   ├── uniform_crossover.h/cc
+│   ├── blend_crossover.h/cc
+│   ├── simulated_binary_crossover.h/cc
+│   ├── order_crossover.h/cc
+│   ├── partially_mapped_crossover.h/cc
+│   ├── cycle_crossover.h/cc
+│   └── ... (15+ more operators)
+├── mutation/                   # Mutation operators
+│   ├── base_mutation.h/cc      # Base mutation interface
+│   ├── bit_flip_mutation.h/cc
+│   ├── gaussian_mutation.h/cc
+│   ├── uniform_mutation.h/cc
+│   ├── swap_mutation.h/cc
+│   └── ... (10+ more operators)
+├── selection-operator/         # Selection methods
+│   ├── base_selection.h/cc     # Base selection interface
+│   ├── tournament_selection.h/cc
+│   ├── roulette_wheel_selection.h/cc
+│   ├── rank_selection.h/cc
+│   └── ... (5+ more operators)
+├── benchmark/                  # Benchmark suite (NEW!)
+│   ├── ga_benchmark.h/cc       # Comprehensive benchmarks
+│   └── benchmark_main.cc       # Benchmark executable
+└── simple-GA-Test/             # Test suite and fitness functions
+    ├── fitness-function.h      # Fitness function declarations
+    ├── fitness-fuction.cc      # Fitness function implementations
+    └── README.md              # Detailed test documentation
+```
+
+## 🛠️ Building with CMake
+
+### Prerequisites
+
+- **CMake** (version 3.16 or higher)
+- **C++17 compatible compiler**:
+  - GCC 7+ (Linux/macOS)
+  - Clang 5+ (Linux/macOS)
+  - MSVC 2017+ (Windows)
+
+### Quick Start
+
+#### Using Build Script (Recommended)
+
+```bash
+# Clone or navigate to the project directory
+cd test-ga
+
+# Build and run in one command
+./build.sh --run
+
+# Or build only
+./build.sh
+```
+
+#### Using CMake Directly
+
+```bash
+cd Genetic_algorithm
+
+# Create build directory
+mkdir build && cd build
+
+# Configure with CMake
+cmake ..
+
+# Build the project
+cmake --build .
+
+# Run the legacy demo
+./bin/simple_ga_test
+```
+
+### Advanced Build Options
+
+```bash
+# Debug build with verbose output
+cmake -DCMAKE_BUILD_TYPE=Debug ..
+cmake --build . --verbose
+
+# Release build with optimizations
+cmake -DCMAKE_BUILD_TYPE=Release ..
+cmake --build . -j$(nproc)
+
+# Install to system (optional)
+sudo cmake --build . --target install
+```
+
+### Build Script
+
+The project includes a convenient build script (`build.sh`) that automates the build process:
+
+```bash
+# Basic build
+./build.sh
+
+# Build with options
+./build.sh --debug --run --verbose
+
+# Clean build
+./build.sh --clean
+
+# Install to system
+./build.sh --install
+```
+
+### CMake Targets
+
+- `genetic_algorithm`: Static library (the framework)
+- `simple-ga-test`: Interactive demo executable
+- `run`: Build and run the GA test
+- `clean-results`: Remove output files
+- `install`: Install to system
+
+```bash
+# Use custom targets
+cmake --build . --target run
+cmake --build . --target clean-results
+```
+
+## 🎯 Using the framework in your code
+
+The public API is in `include/ga`. Example:
+
+```cpp
+#include <ga/genetic_algorithm.hpp>
+#include <cmath>
+
+static double rastrigin(const std::vector<double>& x) {
+  const double A = 10.0;
+  double sum = A * x.size();
+  for (double xi : x) sum += xi*xi - A*std::cos(2*M_PI*xi);
+  // convert minimization to maximization fitness
+  return 1000.0 / (1.0 + sum);
+}
+
+int main() {
+  ga::Config cfg;
+  cfg.populationSize = 60;
+  cfg.generations = 100;
+  cfg.dimension = 10;
+  cfg.bounds = {-5.12, 5.12};
+
+  ga::GeneticAlgorithm alg(cfg);
+  ga::Result res = alg.run(rastrigin);
+}
+```
+
+You can also compile and run the ready-made example:
+
+```bash
+cmake --build build -j
+./build/examples/minimal
+```
+
+NSGA-II minimal example:
+
+```bash
+cmake --build build -j
+./build/examples/ga-nsga2-minimal
+```
+
+High-level optimizer API example:
+
+```bash
+cmake --build build -j
+./build/examples/ga-optimizer-minimal
+```
+
+NSGA-III sanity test:
+
+```bash
+cmake --build build --target nsga3-sanity
+./build/tests/nsga3-sanity
+```
+
+To customize operators:
+
+```cpp
+#include <ga/genetic_algorithm.hpp>
+
+auto alg = ga::GeneticAlgorithm(cfg);
+alg.setCrossoverOperator(ga::makeTwoPointCrossover());
+alg.setMutationOperator(ga::makeUniformMutation());
+```
+
+### C API (Baseline Wrapper)
+
+The project includes a C-compatible API in `include/ga/c_api.h`.
+
+Key C API additions:
+- `ga_validate_config(...)` for pre-run argument checks
+- `ga_history_length(...)`, `ga_best_history(...)`, `ga_avg_history(...)` for convergence history export
+
+```c
+#include <ga/c_api.h>
+
+static double sphere_fitness(const double* genes, int length, void* user_data) {
+  (void)user_data;
+  double sum = 0.0;
+  for (int i = 0; i < length; ++i) {
+    sum += genes[i] * genes[i];
+  }
+  return 1000.0 / (1.0 + sum);
+}
+
+int main(void) {
+  ga_config_c cfg = {60, 100, 10, 0.8, 0.1, -5.12, 5.12, 0.05, 42};
+  if (ga_validate_config(&cfg) != GA_STATUS_OK) {
+    return 1;
+  }
+
+  ga_handle* h = ga_create(&cfg);
+  if (!h) {
+    return 1;
+  }
+
+  if (ga_run(h, sphere_fitness, 0) != GA_STATUS_OK) {
+    ga_destroy(h);
+    return 1;
+  }
+
+  double best = ga_best_fitness(h);
+
+  int n = ga_history_length(h);
+  double history[1024];
+  if (n > 0 && n <= 1024) {
+    (void)ga_best_history(h, history, n);
+  }
+
+  ga_destroy(h);
+  (void)best;
+  return 0;
+}
+```
+
+### NSGA-II Utilities (C++ Core)
+
+NSGA-II helper APIs are available in `include/ga/algorithms/moea/nsga2.hpp`:
+- non-dominated sorting
+- crowding distance
+- callback-based generation loop (`run(...)`)
+
+NSGA-III helper APIs are available in `include/ga/moea/nsga3.hpp`:
+- Das-Dennis reference point generation
+- reference-point environmental selection niching with intercept-based normalization
+
+High-level optimizer methods in `include/ga/api/optimizer.hpp` now include:
+- `optimizeMultiObjective(...)` (NSGA-II)
+- `optimizeMultiObjectiveNsga3(...)`
+
+Distributed evaluation backends in `include/ga/evaluation/distributed_executor.hpp`:
+- `LocalDistributedExecutor` (threaded local backend)
+- `ProcessDistributedExecutor` (true multi-process backend on POSIX)
+
+Python bindings (`python/ga_bindings.cpp`) also expose:
+- NSGA-III objective-space utilities (`Nsga3`, `nsga3_reference_points`, `nsga3_environmental_select_indices`)
+- checkpoint JSON API (`CheckpointState`, `checkpoint_save_json`, `checkpoint_load_json`)
+
+### Interactive Mode (Recommended)
+
+```bash
+./bin/simple_ga_test
+```
+
+The program will guide you through:
+1. **Representation selection** (binary, real_valued, integer, permutation)
+2. **Operator validation** against chosen representation
+3. **Automatic configuration** of compatible operators
+
+### Command Line Testing
+
+#### Real-Valued Optimization
+```bash
+echo -e "real_valued\nblend\ngaussian\ntournament" | ./bin/simple_ga_test
+```
+
+#### Binary Optimization
+```bash
+echo -e "binary\nuniform\nbit_flip\ntournament" | ./bin/simple_ga_test
+```
+
+#### Integer Optimization
+```bash
+echo -e "integer\narithmetic\nrandom_resetting\ntournament" | ./bin/simple_ga_test
+```
+
+#### Permutation Problems
+```bash
+echo -e "permutation\norder_crossover\nswap\ntournament" | ./bin/simple_ga_test
+```
+
+#### C API Sanity Test
+```bash
+cmake --build build --target c-api-sanity
+./build/tests/c-api-sanity
+```
+
+#### Feature Foundation Sanity Test
+```bash
+cmake --build build --target features-foundation-sanity
+./build/tests/features-foundation-sanity
+```
+
+#### Process Distributed Backend Sanity Test
+```bash
+cmake --build build --target process-distributed-sanity
+./build/tests/process-distributed-sanity
+```
+
+## 🔧 Configuration
+
+The framework uses `ga::Config`:
+
+```cpp
+struct Bounds { double lower, upper; };
+struct Config {
+  int populationSize = 50;
+  int generations = 100;
+  int dimension = 10;
+  double crossoverRate = 0.8;
+  double mutationRate = 0.1;
+  Bounds bounds{-5.12, 5.12};
+  double eliteRatio = 0.05; // 5% elites
+  unsigned seed = 0;        // 0 -> random
+};
+```
+
+## 📊 Supported Representations & Operators
+
+### Binary Representation
+- **Crossovers**: One-point, Two-point, Uniform
+- **Mutations**: Bit-flip
+- **Use Cases**: Feature selection, binary optimization
+
+### Real-Valued Representation
+- **Crossovers**: Arithmetic, Blend (BLX-α), SBX, One-point, Two-point, Uniform
+- **Mutations**: Gaussian, Uniform
+- **Use Cases**: Continuous function optimization, parameter tuning
+
+### Integer Representation
+- **Crossovers**: One-point, Two-point, Uniform, Arithmetic
+- **Mutations**: Random resetting, Creep
+- **Use Cases**: Discrete optimization, scheduling problems
+
+### Permutation Representation
+- **Crossovers**: Order crossover (OX), Partially mapped crossover (PMX), Cycle crossover
+- **Mutations**: Swap, Insert, Scramble, Inversion
+- **Use Cases**: Traveling salesman problem, job scheduling
+
+## 🧪 Benchmark Functions
+
+The framework includes 5 standard optimization test functions:
+
+1. **Sphere Function**: Simple unimodal function (baseline)
+2. **Rastrigin Function**: Highly multimodal with many local optima
+3. **Ackley Function**: One global minimum with many local minima
+4. **Schwefel Function**: Deceptive function with global optimum far from local optima
+5. **Rosenbrock Function**: Narrow valley, challenging for optimization
+
+## 🔬 Running Benchmarks
+
+The framework includes a comprehensive benchmark suite that tests:
+- **Operator Performance**: Speed of crossover, mutation, and selection operators
+- **Function Optimization**: Convergence quality on test functions
+- **Scalability**: Performance vs. population size and problem dimension
+
+### Quick Start
+
+```bash
+# Build the benchmark executable
+cmake --build build
+
+# Run all benchmarks
+./build/bin/ga-benchmark --all
+
+# Run specific benchmark categories
+./build/bin/ga-benchmark --operators      # Test operator performance
+./build/bin/ga-benchmark --functions      # Test function optimization
+./build/bin/ga-benchmark --scalability    # Test scalability
+
+# Customize benchmark iterations
+./build/bin/ga-benchmark --operators --iterations 1000
+
+# Export results to CSV
+./build/bin/ga-benchmark --all --csv
+
+# Show help
+./build/bin/ga-benchmark --help
+```
+
+### Benchmark Results
+
+**Operator Performance (typical results on modern CPU):**
+| Operator Category | Representative | Throughput |
+|-------------------|----------------|------------|
+| Binary Crossover | TwoPointCrossover | 2M ops/sec |
+| Real Crossover | BlendCrossover (BLX-α) | 5M ops/sec |
+| Permutation Crossover | OrderCrossover (OX) | 869K ops/sec |
+| Binary Mutation | BitFlipMutation | 1.1M ops/sec |
+| Real Mutation | GaussianMutation | 6.6M ops/sec |
+| Permutation Mutation | SwapMutation | 20M ops/sec |
+| Selection | TournamentSelection | 181K ops/sec |
+
+**Function Optimization (convergence times):**
+| Function | Generations | Time (ms) | Best Fitness |
+|----------|-------------|-----------|--------------|
+| Sphere | 100 | ~1 | >500 |
+| Rastrigin | 200 | ~5 | >60 |
+| Ackley | 150 | ~4 | >60 |
+| Schwefel | 200 | ~7 | Variable |
+| Rosenbrock | 300 | ~8 | >200 |
+
+*Results will vary based on hardware, problem configuration, and random seed.*
+
+### Understanding Benchmark Output
+
+The benchmark tool generates:
+- **Console output**: Real-time progress and summary statistics
+- **benchmark_results.txt**: Detailed results with all metrics
+- **benchmark_results.csv**: Machine-readable format (with `--csv` flag)
+
+## 🏗️ Architecture & Efficiency
+
+For a detailed analysis of the framework's architecture, efficiency, and usability across C++, Python, and C, see [ARCHITECTURE.md](ARCHITECTURE.md).
+
+**Key Highlights:**
+- ⚡ **Performance**: Native C++17 with zero-overhead abstractions
+- 🔧 **Extensible**: Easy to add custom operators and fitness functions
+- 🌐 **Multi-language**: C++ core with Python bindings
+- 📊 **Validated**: Comprehensive benchmark suite included
+- 🧪 **Tested**: Multiple test programs and sanity checks
+
+## 🔍 Development
+
+### Adding New Operators
+
+1. Create header and implementation files in the appropriate directory
+2. Inherit from the base operator class
+3. Implement required virtual methods
+4. Optionally expose convenience factories alongside `ga::make*` helpers
+
+### Adding New Fitness Functions
+
+1. Add declaration to `simple-GA-Test/fitness-function.h`
+2. Implement in `simple-GA-Test/fitness-fuction.cc`
+3. Add to the `GAConfig::FunctionType` enum
+4. Update the fitness function selection logic
+
+### Building for Development
+
+```bash
+# Debug build with symbols
+cmake -DCMAKE_BUILD_TYPE=Debug ..
+cmake --build .
+
+# Run with debug output
+./bin/simple_ga_test
+```
+
+## 📝 Output
+
+The program generates:
+- **Console output**: Progress information and final results
+- **ga_results.txt**: Detailed results including:
+  - Best fitness values per generation
+  - Average fitness values
+  - Best individual's chromosome
+  - Optimization statistics
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests if applicable
+5. Submit a pull request
+
+## 📄 License
+
+This project is open source. Please check individual files for license information.
+
+## 🆘 Troubleshooting
+
+### Common Issues
+
+**CMake not found:**
+```bash
+# Ubuntu/Debian
+sudo apt install cmake
+
+# macOS
+brew install cmake
+
+# Windows
+# Download from https://cmake.org/download/
+```
+
+**Compiler not found:**
+```bash
+# Ubuntu/Debian
+sudo apt install build-essential
+
+# macOS
+xcode-select --install
+```
+
+**Build errors:**
+```bash
+# Clean and rebuild
+rm -rf build
+mkdir build && cd build
+cmake ..
+cmake --build .
+```
+
+### Getting Help
+
+- Check the detailed documentation in `simple-GA-Test/README.md`
+- Review the CMake configuration in `CMakeLists.txt`
+- Examine the source code for implementation details 

genetic_algorithm_lib-1.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+genetic_algorithm_lib/__init__.py,sha256=Ik9fth76ImZYr1a3x4PkcsLVNCIAdXzftGM9rhfi398,912
+genetic_algorithm_lib/_core.cp310-win32.pyd,sha256=8TYT4hfFz-61NcEAV4Ls_yTpBgUNc4fP4kWNAafvNoE,1117184
+genetic_algorithm_lib-1.0.0.dist-info/METADATA,sha256=zgqv453widkAhOjYv766cVHJDcekZNtSuiO1QKfLbHo,16315
+genetic_algorithm_lib-1.0.0.dist-info/WHEEL,sha256=S_zGryBfjwWLi5e5LyCOGRp6hjXpi88SDdr41GgmxyI,102
+genetic_algorithm_lib-1.0.0.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+genetic_algorithm_lib-1.0.0.dist-info/RECORD,,

genetic_algorithm_lib-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 0.12.2
+Root-Is-Purelib: false
+Tag: cp310-cp310-win32
+

genetic_algorithm_lib-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.