Migrate to Sphinx

4 years ago · c63dc7bd26
parent 0653113ac0
commit c63dc7bd26
145 changed files with 26509 additions and 27920 deletions
--- a/0.2/.buildinfo
+++ b/0.2/.buildinfo
@ -0,0 +1,4 @@
 # Sphinx build info version 1
 # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
 config: ee6831c6da6d0184d9def67f9d29d23e
 tags: d77d1c0d9ca2f4c8421862c7c5a0d620
--- a/0.2/404.html
+++ b/0.2/404.html
@ -1,238 +0,0 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="shortcut icon" href="/img/favicon.ico">
    <title>MIPLearn</title>
    <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.12.0/css/all.css">
    <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.12.0/css/v4-shims.css">
    <link rel="stylesheet" href="//cdn.jsdelivr.net/npm/hack-font@3.3.0/build/web/hack.min.css">
    <link href='//rsms.me/inter/inter.css' rel='stylesheet' type='text/css'>
    <link href='//fonts.googleapis.com/css?family=Open+Sans:300italic,400italic,700italic,400,300,600,700&subset=latin-ext,latin' rel='stylesheet' type='text/css'>
    <link href="/css/bootstrap-custom.min.css" rel="stylesheet">
    <link href="/css/base.min.css" rel="stylesheet">
    <link href="/css/cinder.min.css" rel="stylesheet">
        <link rel="stylesheet" href="//cdn.jsdelivr.net/gh/highlightjs/cdn-release@9.18.0/build/styles/github.min.css">
    <link href="/css/custom.css" rel="stylesheet">
    <!-- HTML5 shim and Respond.js IE8 support of HTML5 elements and media queries -->
    <!--[if lt IE 9]>
            <script src="https://cdn.jsdelivr.net/npm/html5shiv@3.7.3/dist/html5shiv.min.js"></script>
            <script src="https://cdn.jsdelivr.net/npm/respond.js@1.4.2/dest/respond.min.js"></script>
        <![endif]-->
 </head>
 <body>
    <div class="navbar navbar-default navbar-fixed-top" role="navigation">
    <div class="container">
        <!-- Collapsed navigation -->
        <div class="navbar-header">
            <!-- Expander button -->
            <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
                <span class="sr-only">Toggle navigation</span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
            </button>
            <!-- Main title -->
              <a class="navbar-brand" href="/.">MIPLearn</a>
        </div>
        <!-- Expanded navigation -->
        <div class="navbar-collapse collapse">
                <!-- Main navigation -->
                <ul class="nav navbar-nav">
                    <li >
                        <a href="/.">Home</a>
                    </li>
                    <li >
                        <a href="/usage/">Usage</a>
                    </li>
                    <li >
                        <a href="/problems/">Problems</a>
                    </li>
                    <li >
                        <a href="/customization/">Customization</a>
                    </li>
                    <li >
                        <a href="/about/">About</a>
                    </li>
                    <li >
                        <a href="/api/miplearn/index.html">API</a>
                    </li>
                </ul>
            <ul class="nav navbar-nav navbar-right">
                    <li>
                        <a href="#" data-toggle="modal" data-target="#mkdocs_search_modal">
                            <i class="fas fa-search"></i> Search
                        </a>
                    </li>
                    <li>
                        <a href="https://github.com/ANL-CEEESA/MIPLearn/"><i class="fab fa-github"></i> GitHub</a>
                    </li>
            </ul>
        </div>
    </div>
 </div>
    <div class="container">
    <div class="row-fluid">
      <div id="main-content" class="span12">
        <h1 id="404-page-not-found" style="text-align: center">404</h1>
        <p style="text-align: center"><strong>Page not found</strong></p>
        <p style="text-align: center"><a href="/">Home</a></p>
      </div>
    </div>
    </div>
      <footer class="col-md-12 text-center">
            <hr>
            <p>
            <small>Copyright © 2020, UChicago Argonne, LLC. All Rights Reserved.</small><br>
            <small>Documentation built with <a href="http://www.mkdocs.org/">MkDocs</a>.</small>
            </p>
      </footer>
    <script src="//ajax.googleapis.com/ajax/libs/jquery/1.12.4/jquery.min.js"></script>
    <script src="/js/bootstrap-3.0.3.min.js"></script>
    <script src="//cdn.jsdelivr.net/gh/highlightjs/cdn-release@9.18.0/build/highlight.min.js"></script>
    <script>hljs.initHighlightingOnLoad();</script>
    <script>var base_url = "/"</script>
    <script src="/js/base.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
    <script src="/js/mathjax.js"></script>
    <script src="/search/main.js"></script>
    <div class="modal" id="mkdocs_search_modal" tabindex="-1" role="dialog" aria-labelledby="searchModalLabel" aria-hidden="true">
    <div class="modal-dialog modal-lg">
        <div class="modal-content">
            <div class="modal-header">
                <button type="button" class="close" data-dismiss="modal">
                    <span aria-hidden="true">&times;</span>
                    <span class="sr-only">Close</span>
                </button>
                <h4 class="modal-title" id="searchModalLabel">Search</h4>
            </div>
            <div class="modal-body">
                <p>
                    From here you can search these documents. Enter
                    your search terms below.
                </p>
                <form>
                    <div class="form-group">
                        <input type="text" class="form-control" placeholder="Search..." id="mkdocs-search-query" title="Type search term here">
                    </div>
                </form>
                <div id="mkdocs-search-results"></div>
            </div>
            <div class="modal-footer">
            </div>
        </div>
    </div>
 </div><div class="modal" id="mkdocs_keyboard_modal" tabindex="-1" role="dialog" aria-labelledby="keyboardModalLabel" aria-hidden="true">
    <div class="modal-dialog">
        <div class="modal-content">
            <div class="modal-header">
                <h4 class="modal-title" id="keyboardModalLabel">Keyboard Shortcuts</h4>
                <button type="button" class="close" data-dismiss="modal"><span aria-hidden="true">&times;</span><span class="sr-only">Close</span></button>
            </div>
            <div class="modal-body">
              <table class="table">
                <thead>
                  <tr>
                    <th style="width: 20%;">Keys</th>
                    <th>Action</th>
                  </tr>
                </thead>
                <tbody>
                  <tr>
                    <td class="help shortcut"><kbd>?</kbd></td>
                    <td>Open this help</td>
                  </tr>
                  <tr>
                    <td class="next shortcut"><kbd>n</kbd></td>
                    <td>Next page</td>
                  </tr>
                  <tr>
                    <td class="prev shortcut"><kbd>p</kbd></td>
                    <td>Previous page</td>
                  </tr>
                  <tr>
                    <td class="search shortcut"><kbd>s</kbd></td>
                    <td>Search</td>
                  </tr>
                </tbody>
              </table>
            </div>
            <div class="modal-footer">
            </div>
        </div>
    </div>
 </div>
    </body>
 </html>
--- a/0.2/_sources/about.md.txt
+++ b/0.2/_sources/about.md.txt
@ -0,0 +1,58 @@
 ```{sectnum}
 ---
 start: 4
 depth: 2
 suffix: .
 ---
 ```
 # About
 ## Authors
 * **Alinson S. Xavier,** Argonne National Laboratory <<axavier@anl.gov>>
 * **Feng Qiu,** Argonne National Laboratory <<fqiu@anl.gov>>
 ## Acknowledgments
 * Based upon work supported by **Laboratory Directed Research and Development** (LDRD) funding from Argonne National Laboratory, provided by the Director, Office of Science, of the U.S. Department of Energy under Contract No. DE-AC02-06CH11357, and the **U.S. Department of Energy Advanced Grid Modeling Program** under Grant DE-OE0000875.
 ## References
 If you use MIPLearn in your research, or the included problem generators, we kindly request that you cite the package as follows:
 * **Alinson S. Xavier, Feng Qiu.** *MIPLearn: An Extensible Framework for Learning-Enhanced Optimization*. Zenodo (2020). DOI: [10.5281/zenodo.4287567](https://doi.org/10.5281/zenodo.4287567)
 If you use MIPLearn in the field of power systems optimization, we kindly request that you cite the reference below, in which the main techniques implemented in MIPLearn were first developed:
 * **Alinson S. Xavier, Feng Qiu, Shabbir Ahmed.** *Learning to Solve Large-Scale Unit Commitment Problems.* INFORMS Journal on Computing (2020). DOI: [10.1287/ijoc.2020.0976](https://doi.org/10.1287/ijoc.2020.0976)
 ## License
 ```text
 MIPLearn, an extensible framework for Learning-Enhanced Mixed-Integer Optimization
 Copyright © 2020, UChicago Argonne, LLC. All Rights Reserved.
 Redistribution and use in source and binary forms, with or without modification, are permitted
 provided that the following conditions are met:
 1. Redistributions of source code must retain the above copyright notice, this list of
   conditions and the following disclaimer.
 2. Redistributions in binary form must reproduce the above copyright notice, this list of
   conditions and the following disclaimer in the documentation and/or other materials provided
   with the distribution.
 3. Neither the name of the copyright holder nor the names of its contributors may be used to
   endorse or promote products derived from this software without specific prior written
   permission.
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 ```
--- a/0.2/_sources/benchmark.md.txt
+++ b/0.2/_sources/benchmark.md.txt
@ -0,0 +1,177 @@
 ```{sectnum}
 ---
 start: 2
 depth: 2
 suffix: .
 ---
 ```
 # Benchmarks
 MIPLearn provides a selection of benchmark problems and random instance generators, covering applications from different fields, that can be used to evaluate new learning-enhanced MIP techniques in a measurable and reproducible way. In this page, we describe these problems, the included instance generators, and we present some benchmark results for  `LearningSolver` with default parameters.
 ## Preliminaries
 ### Benchmark challenges
 When evaluating the performance of a conventional MIP solver, *benchmark sets*, such as MIPLIB and TSPLIB, are typically used. The performance of newly proposed solvers or solution techniques are typically measured as the average (or total) running time the solver takes to solve the entire benchmark set. For Learning-Enhanced MIP solvers, it is also necessary to specify what instances should the solver be trained on (the *training instances*) before solving the actual set of instances we are interested in (the *test instances*). If the training instances are very similar to the test instances, we would expect a Learning-Enhanced Solver to present stronger perfomance benefits.
 In MIPLearn, each optimization problem comes with a set of **benchmark challenges**, which specify how should the training and test instances be generated. The first challenges are typically easier, in the sense that training and test instances are very similar. Later challenges gradually make the sets more distinct, and therefore harder to learn from.
 ### Baseline results
 To illustrate the performance of `LearningSolver`, and to set a baseline for newly proposed techniques, we present in this page, for each benchmark challenge, a small set of computational results measuring the solution speed of the solver and the solution quality with default parameters. For more detailed computational studies, see [references](about.md#references). We compare three solvers:
 * **baseline:** Gurobi 9.0 with default settings (a conventional state-of-the-art MIP solver)
 * **ml-exact:** `LearningSolver` with default settings, using Gurobi 9.0 as internal MIP solver
 * **ml-heuristic:** Same as above, but with `mode="heuristic"`
 All experiments presented here were performed on a Linux server (Ubuntu Linux 18.04 LTS) with Intel Xeon Gold 6230s (2 processors, 40 cores, 80 threads) and 256 GB RAM (DDR4, 2933 MHz). All solvers were restricted to use 4 threads, with no time limits, and 10 instances were solved simultaneously at a time.
 ## Maximum Weight Stable Set Problem
 ### Problem definition
 Given a simple undirected graph $G=(V,E)$ and weights $w \in \mathbb{R}^V$, the problem is to find a stable set $S \subseteq V$ that maximizes $ \sum_{v \in V} w_v$. We recall that a subset $S \subseteq V$ is a *stable set* if no two vertices of $S$ are adjacent. This is one of Karp's 21 NP-complete problems.
 ### Random instance generator
 The class `MaxWeightStableSetGenerator` can be used to generate random instances of this problem, with user-specified probability distributions. When the constructor parameter `fix_graph=True` is provided, one random Erdős-Rényi graph $G_{n,p}$ is generated during the constructor, where $n$ and $p$ are sampled from user-provided probability distributions `n` and `p`. To generate each instance, the generator independently samples each $w_v$ from the user-provided probability distribution `w`. When `fix_graph=False`, a new random graph is generated for each instance, while the remaining parameters are sampled in the same way.
 ### Challenge A
 * Fixed random Erdős-Rényi graph $G_{n,p}$ with $n=200$ and $p=5\%$
 * Random vertex weights $w_v \sim U(100, 150)$
 * 500 training instances, 50 test instances
 ```python
 MaxWeightStableSetGenerator(w=uniform(loc=100., scale=50.),
                            n=randint(low=200, high=201),
                            p=uniform(loc=0.05, scale=0.0),
                            fix_graph=True)
 ```
 ![alt](figures/benchmark_stab_a.png)
 ## Traveling Salesman Problem
 ### Problem definition
 Given a list of cities and the distance between each pair of cities, the problem asks for the
 shortest route starting at the first city, visiting each other city exactly once, then returning
 to the first city. This problem is a generalization of the Hamiltonian path problem, one of Karp's
 21 NP-complete problems.
 ### Random problem generator
 The class `TravelingSalesmanGenerator` can be used to generate random instances of this
 problem. Initially, the generator creates $n$ cities $(x_1,y_1),\ldots,(x_n,y_n) \in \mathbb{R}^2$,
 where $n, x_i$ and $y_i$ are sampled independently from the provided probability distributions `n`,
 `x` and `y`. For each pair of cities $(i,j)$, the distance $d_{i,j}$ between them is set to:
 $$
    d_{i,j} = \gamma_{i,j} \sqrt{(x_i-x_j)^2 + (y_i - y_j)^2}
 $$
 where $\gamma_{i,j}$ is sampled from the distribution `gamma`.
 If `fix_cities=True` is provided, the list of cities is kept the same for all generated instances.
 The $gamma$ values, and therefore also the distances, are still different.
 By default, all distances $d_{i,j}$ are rounded to the nearest integer.  If `round=False`
 is provided, this rounding will be disabled.
 ### Challenge A
 * Fixed list of 350 cities in the $[0, 1000]^2$ square
 * $\gamma_{i,j} \sim U(0.95, 1.05)$
 * 500 training instances, 50 test instances
 ```python
 TravelingSalesmanGenerator(x=uniform(loc=0.0, scale=1000.0),
                           y=uniform(loc=0.0, scale=1000.0),
                           n=randint(low=350, high=351),
                           gamma=uniform(loc=0.95, scale=0.1),
                           fix_cities=True,
                           round=True,
                          )
 ```
 ![alt](figures/benchmark_tsp_a.png)
 ## Multidimensional 0-1 Knapsack Problem
 ### Problem definition
 Given a set of $n$ items and $m$ types of resources (also called *knapsacks*), the problem is to find a subset of items that maximizes profit without consuming more resources than it is available. More precisely, the problem is:
 $$
 \begin{align*}
    \text{maximize}
        & \sum_{j=1}^n p_j x_j
        \\
    \text{subject to}
        & \sum_{j=1}^n w_{ij} x_j \leq b_i
        & \forall i=1,\ldots,m \\
    & x_j \in \{0,1\}
        & \forall j=1,\ldots,n
 \end{align*}
 $$
 ### Random instance generator
 The class `MultiKnapsackGenerator` can be used to generate random instances of this problem. The number of items $n$ and knapsacks $m$ are sampled from the user-provided probability distributions `n` and `m`. The weights $w_{ij}$ are sampled independently from the provided distribution `w`. The capacity of knapsack $i$ is set to
 $$
    b_i = \alpha_i \sum_{j=1}^n w_{ij}
 $$
 where $\alpha_i$, the tightness ratio, is sampled from the provided probability
 distribution `alpha`. To make the instances more challenging, the costs of the items
 are linearly correlated to their average weights. More specifically, the price of each
 item $j$ is set to:
 $$
    p_j = \sum_{i=1}^m \frac{w_{ij}}{m} + K  u_j,
 $$
 where $K$, the correlation coefficient, and $u_j$, the correlation multiplier, are sampled
 from the provided probability distributions `K` and `u`.
 If `fix_w=True` is provided, then $w_{ij}$ are kept the same in all generated instances. This also implies that $n$ and $m$ are kept fixed. Although the prices and capacities are derived from $w_{ij}$, as long as `u` and `K` are not constants, the generated instances will still not be completely identical.
 If a probability distribution `w_jitter` is provided, then item weights will be set to $w_{ij} \gamma_{ij}$ where $\gamma_{ij}$ is sampled from `w_jitter`. When combined with `fix_w=True`, this argument may be used to generate instances where the weight of each item is roughly the same, but not exactly identical, across all instances. The prices of the items and the capacities of the knapsacks will be calculated as above, but using these perturbed weights instead.
 By default, all generated prices, weights and capacities are rounded to the nearest integer number. If `round=False` is provided, this rounding will be disabled.
 !!! note "References"
    * Freville, Arnaud, and Gérard Plateau. *An efficient preprocessing procedure for the multidimensional 0–1 knapsack problem.* Discrete applied mathematics 49.1-3 (1994): 189-212.
    * Fréville, Arnaud. *The multidimensional 0–1 knapsack problem: An overview.* European Journal of Operational Research 155.1 (2004): 1-21.
 ### Challenge A
 * 250 variables, 10 constraints, fixed weights
 * $w \sim U(0, 1000), \gamma \sim U(0.95, 1.05)$
 * $K = 500, u \sim U(0, 1), \alpha = 0.25$
 * 500 training instances, 50 test instances
 ```python
 MultiKnapsackGenerator(n=randint(low=250, high=251),
                       m=randint(low=10, high=11),
                       w=uniform(loc=0.0, scale=1000.0),
                       K=uniform(loc=500.0, scale=0.0),
                       u=uniform(loc=0.0, scale=1.0),
                       alpha=uniform(loc=0.25, scale=0.0),
                       fix_w=True,
                       w_jitter=uniform(loc=0.95, scale=0.1),
                      )
 ```
 ![alt](figures/benchmark_knapsack_a.png)
--- a/0.2/_sources/customization.md.txt
+++ b/0.2/_sources/customization.md.txt
@ -0,0 +1,182 @@
 ```{sectnum}
 ---
 start: 3
 depth: 2
 suffix: .
 ---
 ```
 # Customization
 ## Customizing solver parameters
 ### Selecting the internal MIP solver
 By default, `LearningSolver` uses [Gurobi](https://www.gurobi.com/) as its internal MIP solver, and expects models to be provided using the Pyomo modeling language. Supported solvers and modeling languages include:
 * `GurobiPyomoSolver`: Gurobi with Pyomo (default).
 * `CplexPyomoSolver`: [IBM ILOG CPLEX](https://www.ibm.com/products/ilog-cplex-optimization-studio) with Pyomo.
 * `XpressPyomoSolver`: [FICO XPRESS Solver](https://www.fico.com/en/products/fico-xpress-solver) with Pyomo.
 * `GurobiSolver`: Gurobi without any modeling language.
 To switch between solvers, provide the desired class using the `solver` argument:
 ```python
 from miplearn import LearningSolver, CplexPyomoSolver
 solver = LearningSolver(solver=CplexPyomoSolver)
 ```
 To configure a particular solver, use the `params` constructor argument, as shown below.
 ```python
 from miplearn import LearningSolver, GurobiPyomoSolver
 solver = LearningSolver(
    solver=lambda: GurobiPyomoSolver(
        params={
            "TimeLimit": 900,
            "MIPGap": 1e-3,
            "NodeLimit": 1000,
        }
    ),
 )
 ```
 ## Customizing solver components
 `LearningSolver` is composed by a number of individual machine-learning components, each targeting a different part of the solution process. Each component can be individually enabled, disabled or customized. The following components are enabled by default:
 * `LazyConstraintComponent`: Predicts which lazy constraint to initially enforce.
 * `ObjectiveValueComponent`: Predicts the optimal value of the optimization problem, given the optimal solution to the LP relaxation.
 * `PrimalSolutionComponent`: Predicts optimal values for binary decision variables. In heuristic mode, this component fixes the variables to their predicted values. In exact mode, the predicted values are provided to the solver as a (partial) MIP start.
 The following components are also available, but not enabled by default:
 * `BranchPriorityComponent`: Predicts good branch priorities for decision variables.
 ### Selecting components
 To create a `LearningSolver` with a specific set of components, the `components` constructor argument may be used, as the next example shows:
 ```python
 # Create a solver without any components
 solver1 = LearningSolver(components=[])
 # Create a solver with only two components
 solver2 = LearningSolver(components=[
    LazyConstraintComponent(...),
    PrimalSolutionComponent(...),
 ])
 ```
 ### Adjusting component aggressiveness
 The aggressiveness of classification components, such as `PrimalSolutionComponent` and `LazyConstraintComponent`, can be adjusted through the `threshold` constructor argument. Internally, these components ask the machine learning models how confident are they on each prediction they make, then automatically discard all predictions that have low confidence. The `threshold` argument specifies how confident should the ML models be for a prediction to be considered trustworthy. Lowering a component's threshold increases its aggressiveness, while raising a component's threshold makes it more conservative.
 For example, if the ML model predicts that a certain binary variable will assume value `1.0` in the optimal solution with 75% confidence, and if the `PrimalSolutionComponent` is configured to discard all predictions with less than 90% confidence, then this variable will not be included in the predicted MIP start.
 MIPLearn currently provides two types of thresholds:
 * `MinProbabilityThreshold(p: List[float])` A threshold which indicates that a prediction is trustworthy if its probability of being correct, as computed by the machine learning model, is above a fixed value.
 * `MinPrecisionThreshold(p: List[float])` A dynamic threshold which automatically adjusts itself during training to ensure that the component achieves at least a given precision on the training data set. Note that increasing a component's precision may reduce its recall.
 The example below shows how to build a `PrimalSolutionComponent` which fixes variables to zero with at least 80% precision, and to one with at least 95% precision. Other components are configured similarly.
 ```python
 from miplearn import PrimalSolutionComponent, MinPrecisionThreshold
 PrimalSolutionComponent(
    mode="heuristic",
    threshold=MinPrecisionThreshold([0.80, 0.95]),
 )
 ```
 ### Evaluating component performance
 MIPLearn allows solver components to be modified, trained and evaluated in isolation. In the following example, we build and
 fit `PrimalSolutionComponent` outside the solver, then evaluate its performance.
 ```python
 from miplearn import PrimalSolutionComponent
 # User-provided set of previously-solved instances
 train_instances = [...]
 # Construct and fit component on a subset of training instances
 comp = PrimalSolutionComponent()
 comp.fit(train_instances[:100])
 # Evaluate performance on an additional set of training instances
 ev = comp.evaluate(train_instances[100:150])
 ``` 
 The method `evaluate` returns a dictionary with performance evaluation statistics for each training instance provided,
 and for each type of prediction the component makes. To obtain a summary across all instances, pandas may be used, as below:
 ```python
 import pandas as pd
 pd.DataFrame(ev["Fix one"]).mean(axis=1)
 ```
 ```text
 Predicted positive          3.120000
 Predicted negative        196.880000
 Condition positive         62.500000
 Condition negative        137.500000
 True positive               3.060000
 True negative             137.440000
 False positive              0.060000
 False negative             59.440000
 Accuracy                    0.702500
 F1 score                    0.093050
 Recall                      0.048921
 Precision                   0.981667
 Predicted positive (%)      1.560000
 Predicted negative (%)     98.440000
 Condition positive (%)     31.250000
 Condition negative (%)     68.750000
 True positive (%)           1.530000
 True negative (%)          68.720000
 False positive (%)          0.030000
 False negative (%)         29.720000
 dtype: float64
 ```
 Regression components (such as `ObjectiveValueComponent`) can also be trained and evaluated similarly,
 as the next example shows:
 ```python
 from miplearn import ObjectiveValueComponent
 comp = ObjectiveValueComponent()
 comp.fit(train_instances[:100])
 ev = comp.evaluate(train_instances[100:150])
 import pandas as pd
 pd.DataFrame(ev).mean(axis=1)
 ```
 ```text
 Mean squared error       7001.977827
 Explained variance          0.519790
 Max error                 242.375804
 Mean absolute error        65.843924
 R2                          0.517612
 Median absolute error      65.843924
 dtype: float64
 ```
 ### Using customized ML classifiers and regressors
 By default, given a training set of instantes, MIPLearn trains a fixed set of ML classifiers and regressors, then selects the best one based on cross-validation performance. Alternatively, the user may specify which ML model a component should use through the `classifier` or `regressor` contructor parameters. Scikit-learn classifiers and regressors are currently supported. A future version of the package will add compatibility with Keras models.
 The example below shows how to construct a `PrimalSolutionComponent` which internally uses scikit-learn's `KNeighborsClassifiers`. Any other scikit-learn classifier or pipeline can be used. It needs to be wrapped in `ScikitLearnClassifier` to ensure that all the proper data transformations are applied.
 ```python
 from miplearn import PrimalSolutionComponent, ScikitLearnClassifier
 from sklearn.neighbors import KNeighborsClassifier
 comp = PrimalSolutionComponent(
    classifier=ScikitLearnClassifier(
        KNeighborsClassifier(n_neighbors=5),
    ),
 )
 comp.fit(train_instances)
 ``` 
--- a/0.2/_sources/index.md.txt
+++ b/0.2/_sources/index.md.txt
@ -0,0 +1,35 @@
 # MIPLearn
 **MIPLearn** is an extensible framework for solving discrete optimization problems using a combination of Mixed-Integer Linear Programming (MIP) and Machine Learning (ML). The framework uses ML methods to automatically identify patterns in previously solved instances of the problem, then uses these patterns to accelerate the performance of conventional state-of-the-art MIP solvers (such as CPLEX, Gurobi or XPRESS).
 Unlike pure ML methods, MIPLearn is not only able to find high-quality solutions to discrete optimization problems, but it can also prove the optimality and feasibility of these solutions.
 Unlike conventional MIP solvers, MIPLearn can take full advantage of very specific observations that happen to be true in a particular family of instances (such as the observation that a particular constraint is typically redundant, or that a particular variable typically assumes a certain value). 
 For certain classes of problems, this approach has been shown to provide significant performance benefits (see [benchmarks](benchmark.md) and [references](about.md)).
 ## Features
 * **MIPLearn proposes a flexible problem specification format,** which allows users to describe their particular optimization problems to a Learning-Enhanced MIP solver, both from the MIP perspective and from the ML perspective, without making any assumptions on the problem being modeled, the mathematical formulation of the problem, or ML encoding. While the format is very flexible, some constraints are enforced to ensure that it is usable by an actual solver.
 * **MIPLearn provides a reference implementation of a *Learning-Enhanced Solver*,** which can use the above problem specification format to automatically predict, based on previously solved instances, a number of hints to accelerate MIP performance. Currently, the reference solver is able to predict: (i) partial solutions which are likely to work well as MIP starts; (ii) an initial set of lazy constraints to enforce; (iii) variable branching priorities to accelerate the exploration of the branch-and-bound tree; (iv) the optimal objective value based on the solution to the LP relaxation. The usage of the solver is very straightforward. The most suitable ML models are automatically selected, trained, cross-validated and applied to the problem with no user intervention.
 * **MIPLearn provides a set of benchmark problems and random instance generators,** covering applications from different domains, which can be used to quickly evaluate new learning-enhanced MIP techniques in a measurable and reproducible way.
 * **MIPLearn is customizable and extensible**. For MIP and ML researchers exploring new techniques to accelerate MIP performance based on historical data, each component of the reference solver can be individually replaced, extended or customized.
 ## Site contents
 ```{toctree}
 ---
 maxdepth: 2
 ---
 usage.md
 benchmark.md
 customization.md
 about.md
 ```
 ## Source Code
 * [https://github.com/ANL-CEEESA/MIPLearn](https://github.com/ANL-CEEESA/MIPLearn)
--- a/0.2/_sources/usage.md.txt
+++ b/0.2/_sources/usage.md.txt
@ -0,0 +1,246 @@
 ```{sectnum}
 ---
 start: 1
 depth: 2
 suffix: .
 ---
 ```
 # Using MIPLearn
 ## Installation
 In these docs, we describe the Python/Pyomo version of the package, although a [Julia/JuMP version](https://github.com/ANL-CEEESA/MIPLearn.jl) is also available. A mixed-integer solver is also required and its Python bindings must be properly installed. Supported solvers are currently CPLEX, Gurobi and XPRESS.
 To install MIPLearn, run: 
 ```bash
 pip3 install --upgrade miplearn==0.2.*
 ```
 After installation, the package `miplearn` should become available to Python. It can be imported
 as follows:
 ```python
 import miplearn
 ```
 ## Using `LearningSolver`
 The main class provided by this package is `LearningSolver`, a learning-enhanced MIP solver which uses information from previously solved instances to accelerate the solution of new instances. The following example shows its basic usage:
 ```python
 from miplearn import LearningSolver
 # List of user-provided instances
 training_instances = [...] 
 test_instances = [...]
 # Create solver
 solver = LearningSolver()
 # Solve all training instances
 for instance in training_instances:
    solver.solve(instance)
 # Learn from training instances
 solver.fit(training_instances)
 # Solve all test instances
 for instance in test_instances:
    solver.solve(instance)
 ```
 In this example, we have two lists of user-provided instances: `training_instances` and `test_instances`. We start by solving all training instances. Since there is no historical information available at this point, the instances will be processed from scratch, with no ML acceleration. After solving each instance, the solver stores within each `instance` object the optimal solution, the optimal objective value, and other information that can be used to accelerate future solves. After all training instances are solved, we call `solver.fit(training_instances)`. This instructs the solver to train all its internal machine-learning models based on the solutions of the (solved) trained instances. Subsequent calls to `solver.solve(instance)` will automatically use the trained Machine Learning models to accelerate the solution process.
 ## Describing problem instances
 Instances to be solved by `LearningSolver` must derive from the abstract class `miplearn.Instance`. The following three abstract methods must be implemented:
 * `instance.to_model()`, which returns a concrete Pyomo model corresponding to the instance;
 * `instance.get_instance_features()`, which returns a 1-dimensional Numpy array of (numerical) features describing the entire instance;
 * `instance.get_variable_features(var_name, index)`, which returns a 1-dimensional array of (numerical) features describing a particular decision variable.
 The first method is used by `LearningSolver` to construct a concrete Pyomo model, which will be provided to the internal MIP solver. The second and third methods provide an encoding of the instance, which can be used by the ML models to make predictions. In the knapsack problem, for example, an implementation may decide to provide as instance features the average weights, average prices, number of items and the size of the knapsack. The weight and the price of each individual item could be provided as variable features. See `src/python/miplearn/problems/knapsack.py` for a concrete example.
 An optional method which can be implemented is `instance.get_variable_category(var_name, index)`, which returns a category (a string, an integer or any hashable type) for each decision variable. If two variables have the same category, `LearningSolver` will use the same internal ML model to predict the values of both variables. By default, all variables belong to the `"default"` category, and therefore only one ML model is used for all variables. If the returned category is `None`, ML predictors will ignore the variable.
 It is not necessary to have a one-to-one correspondence between features and problem instances. One important (and deliberate) limitation of MIPLearn, however, is that `get_instance_features()` must always return arrays of same length for all relevant instances of the problem. Similarly, `get_variable_features(var_name, index)` must also always return arrays of same length for all variables in each category. It is up to the user to decide how to encode variable-length characteristics of the problem into fixed-length vectors. In graph problems, for example, graph embeddings can be used to reduce the (variable-length) lists of nodes and edges into a fixed-length structure that still preserves some properties of the graph. Different instance encodings may have significant impact on performance.
 ## Describing lazy constraints
 For many MIP formulations, it is not desirable to add all constraints up-front, either because the total number of constraints is very large, or because some of the constraints, even in relatively small numbers, can still cause significant performance impact when added to the formulation. In these situations, it may be desirable to generate and add constraints incrementaly, during the solution process itself. Conventional MIP solvers typically start by solving the problem without any lazy constraints. Whenever a candidate solution is found, the solver finds all violated lazy constraints and adds them to the formulation. MIPLearn significantly accelerates this process by using ML to predict which lazy constraints should be enforced from the very beginning of the optimization process, even before a candidate solution is available.
 MIPLearn supports two types of lazy constraints: through constraint annotations and through callbacks.
 ###  Adding lazy constraints through annotations
 The easiest way to create lazy constraints in MIPLearn is to add them to the model (just like any regular constraints), then annotate them as lazy, as described below. Just before the optimization starts, MIPLearn removes all lazy constraints from the model and places them in a lazy constraint pool. If any trained ML models are available, MIPLearn queries these models to decide which of these constraints should be moved back into the formulation. After this step, the optimization starts, and lazy constraints from the pool are added to the model in the conventional fashion.
 To tag a constraint as lazy, the following methods must be implemented:
 * `instance.has_static_lazy_constraints()`, which returns `True` if the model has any annotated lazy constraints. By default, this method returns `False`.
 * `instance.is_constraint_lazy(cid)`, which returns `True` if the constraint with name `cid` should be treated as a lazy constraint, and `False` otherwise.
 * `instance.get_constraint_features(cid)`, which returns a 1-dimensional Numpy array of (numerical) features describing the constraint.
 For instances such that `has_lazy_constraints` returns `True`, MIPLearn calls `is_constraint_lazy` for each constraint in the formulation, providing the name of the constraint. For constraints such that `is_constraint_lazy` returns `True`, MIPLearn additionally calls `get_constraint_features` to gather a ML representation of each constraint. These features are used to predict which lazy constraints should be initially enforced.
 An additional method that can be implemented is `get_lazy_constraint_category(cid)`, which returns a category (a string or any other hashable type) for each lazy constraint. Similarly to decision variable categories, if two lazy constraints have the same category, then MIPLearn will use the same internal ML model to decide whether to initially enforce them. By default, all lazy constraints belong to the `"default"` category, and therefore a single ML model is used.
 !!! warning
    If two lazy constraints belong to the same category, their feature vectors should have the same length.
 ### Adding lazy constraints through callbacks
 Although convenient, the method described in the previous subsection still requires the generation of all lazy constraints ahead of time, which can be prohibitively expensive. An alternative method is through a lazy constraint callbacks, described below. During the solution process, MIPLearn will repeatedly call a user-provided function to identify any violated lazy constraints. If violated constraints are identified, MIPLearn will additionally call another user-provided function to generate the constraint and add it to the formulation.
 To describe lazy constraints through user callbacks, the following methods need to be implemented:
 * `instance.has_dynamic_lazy_constraints()`, which returns `True` if the model has any lazy constraints generated by user callbacks. By default, this method returns `False`.
 * `instance.find_violated_lazy_constraints(model)`, which returns a list of identifiers corresponding to the lazy constraints found to be violated by the current solution. These identifiers should be strings, tuples or any other hashable type.
 * `instance.build_violated_lazy_constraints(model, cid)`, which returns either a list of Pyomo constraints, or a single Pyomo constraint, corresponding to the given lazy constraint identifier.
 * `instance.get_constraint_features(cid)`, which returns a 1-dimensional Numpy array of (numerical) features describing the constraint. If this constraint is not valid, returns `None`.
 * `instance.get_lazy_constraint_category(cid)`, which returns a category (a string or any other hashable type) for each lazy constraint, indicating which ML model to use. By default, returns `"default"`.
 Assuming that trained ML models are available, immediately after calling `solver.solve`, MIPLearn will call `get_constraint_features` for each lazy constraint identifier found in the training set. For constraints such that `get_constraint_features` returns a vector (instead of `None`), MIPLearn will call `get_constraint_category` to decide which trained ML model to use. It will then query the ML model to decide whether the constraint should be initially enforced. Assuming that the ML predicts this constraint will be necessary, MIPLearn calls `build_violated_constraints` then adds the returned list of Pyomo constraints to the model. The optimization then starts. When no trained ML models are available, this entire initial process is skipped, and MIPLearn behaves like a conventional solver.
 After the optimization process starts, MIPLearn will periodically call `find_violated_lazy_constraints` to verify if the current solution violates any lazy constraints. If any violated lazy constraints are found, MIPLearn will call the method `build_violated_lazy_constraints` and add the returned constraints to the formulation.
 ```{tip}
 When implementing `find_violated_lazy_constraints(self, model)`, the current solution may be accessed through `self.solution[var_name][index]`.
 ```
 ## Obtaining heuristic solutions
 By default, `LearningSolver` uses Machine Learning to accelerate the MIP solution process, while maintaining all optimality guarantees provided by the MIP solver. In the default mode of operation, for example, predicted optimal solutions are used only as MIP starts.
 For more significant performance benefits, `LearningSolver` can also be configured to place additional trust in the Machine Learning predictors, by using the `mode="heuristic"` constructor argument. When operating in this mode, if a ML model is statistically shown (through *stratified k-fold cross validation*) to have exceptionally high accuracy, the solver may decide to restrict the search space based on its predictions. The parts of the solution which the ML models cannot predict accurately will still be explored using traditional (branch-and-bound) methods.  For particular applications, this mode has been shown to quickly produce optimal or near-optimal solutions (see [references](about.md#references) and [benchmark results](benchmark.md)).
 ```{danger}
 The `heuristic` mode provides no optimality guarantees, and therefore should only be used if the solver is first trained on a large and representative set of training instances. Training on a small or non-representative set of instances may produce low-quality solutions, or make the solver incorrectly classify new instances as infeasible.
 ```
 ## Scaling Up
 ### Saving and loading solver state
 After solving a large number of training instances, it may be desirable to save the current state of `LearningSolver` to disk, so that the solver can still use the acquired knowledge after the application restarts. This can be accomplished by using the the utility functions `write_pickle_gz` and `read_pickle_gz`, as the following example illustrates:
 ```python
 from miplearn import LearningSolver, write_pickle_gz, read_pickle_gz
 # Solve training instances
 training_instances = [...]
 solver = LearningSolver()
 for instance in training_instances:
    solver.solve(instance)
 # Train machine-learning models
 solver.fit(training_instances)
 # Save trained solver to disk
 write_pickle_gz(solver, "solver.pkl.gz")
 # Application restarts...
 # Load trained solver from disk
 solver = read_pickle_gz("solver.pkl.gz")
 # Solve additional instances
 test_instances = [...]
 for instance in test_instances:
    solver.solve(instance)
 ```
 ### Solving instances in parallel
 In many situations, instances can be solved in parallel to accelerate the training process. `LearningSolver` provides the method `parallel_solve(instances)` to easily achieve this:
 ```python
 from miplearn import LearningSolver
 training_instances = [...]
 solver = LearningSolver()
 solver.parallel_solve(training_instances, n_jobs=4)
 solver.fit(training_instances)
 # Test phase...
 test_instances = [...]
 solver.parallel_solve(test_instances)
 ```
 ### Solving instances from the disk
 In all examples above, we have assumed that instances are available as Python objects, stored in memory. When problem instances are very large, or when there is a large number of problem instances, this approach may require an excessive amount of memory. To reduce memory requirements, MIPLearn can also operate on instances that are stored on disk, through the `PickleGzInstance` class, as the next example illustrates.
 ```python
 import pickle
 from miplearn import (
    LearningSolver,
    PickleGzInstance,
    write_pickle_gz,
 )
 # Construct and pickle 600 problem instances
 for i in range(600):
    instance = MyProblemInstance([...])
    write_pickle_gz(instance, "instance_%03d.pkl" % i)
 # Split instances into training and test
 test_instances  = [PickleGzInstance("instance_%03d.pkl" % i) for i in range(500)]
 train_instances = [PickleGzInstance("instance_%03d.pkl" % i) for i in range(500, 600)]
 # Create solver
 solver = LearningSolver([...])
 # Solve training instances 
 solver.parallel_solve(train_instances, n_jobs=4)
 # Train ML models
 solver.fit(train_instances)
 # Solve test instances 
 solver.parallel_solve(test_instances, n_jobs=4)
 ```
 By default, `solve` and `parallel_solve` modify files in place. That is, after the instances are loaded from disk and solved, MIPLearn writes them back to the disk, overwriting the original files. To discard the modifications instead, use `LearningSolver(..., discard_outputs=True)`. This can be useful, for example, during benchmarks.
 ## Running benchmarks
 MIPLearn provides the utility class `BenchmarkRunner`, which simplifies the task of comparing the performance of different solvers. The snippet below shows its basic usage:
 ```python
 from miplearn import BenchmarkRunner, LearningSolver
 # Create train and test instances
 train_instances = [...]
 test_instances  = [...]
 # Training phase...
 training_solver = LearningSolver(...)
 training_solver.parallel_solve(train_instances, n_jobs=10)
 # Test phase...
 benchmark = BenchmarkRunner({
    "Baseline": LearningSolver(...),
    "Strategy A": LearningSolver(...),
    "Strategy B": LearningSolver(...),
    "Strategy C": LearningSolver(...),
 })
 benchmark.fit(train_instances)
 benchmark.parallel_solve(test_instances, n_jobs=5)
 benchmark.write_csv("results.csv")
 ```
 The method `fit` trains the ML models for each individual solver. The method `parallel_solve` solves the test instances in parallel, and collects solver statistics such as running time and optimal value. Finally, `write_csv` produces a table of results. The columns in the CSV file depend on the components added to the solver.
 ## Current Limitations
 * Only binary and continuous decision variables are currently supported. General integer variables are not currently supported by some solver components.
--- a/0.2/_static/init.py
+++ b/0.2/_static/init.py
--- a/0.2/_static/pycache/init.cpython-38.pyc
+++ b/0.2/_static/pycache/init.cpython-38.pyc
--- a/0.2/_static/basic.css
+++ b/0.2/_static/basic.css
@ -0,0 +1,856 @@
 /*
 * basic.css
 * ~~~~~~~~~
 *
 * Sphinx stylesheet -- basic theme.
 *
 * :copyright: Copyright 2007-2021 by the Sphinx team, see AUTHORS.
 * :license: BSD, see LICENSE for details.
 *
 */
 /* -- main layout ----------------------------------------------------------- */
 div.clearer {
    clear: both;
 }
 div.section::after {
    display: block;
    content: '';
    clear: left;
 }
 /* -- relbar ---------------------------------------------------------------- */
 div.related {
    width: 100%;
    font-size: 90%;
 }
 div.related h3 {
    display: none;
 }
 div.related ul {
    margin: 0;
    padding: 0 0 0 10px;
    list-style: none;
 }
 div.related li {
    display: inline;
 }
 div.related li.right {
    float: right;
    margin-right: 5px;
 }
 /* -- sidebar --------------------------------------------------------------- */
 div.sphinxsidebarwrapper {
    padding: 10px 5px 0 10px;
 }
 div.sphinxsidebar {
    float: left;
    width: 270px;
    margin-left: -100%;
    font-size: 90%;
    word-wrap: break-word;
    overflow-wrap : break-word;
 }
 div.sphinxsidebar ul {
    list-style: none;
 }
 div.sphinxsidebar ul ul,
 div.sphinxsidebar ul.want-points {
    margin-left: 20px;
    list-style: square;
 }
 div.sphinxsidebar ul ul {
    margin-top: 0;
    margin-bottom: 0;
 }
 div.sphinxsidebar form {
    margin-top: 10px;
 }
 div.sphinxsidebar input {
    border: 1px solid #98dbcc;
    font-family: sans-serif;
    font-size: 1em;
 }
 div.sphinxsidebar #searchbox form.search {
    overflow: hidden;
 }
 div.sphinxsidebar #searchbox input[type="text"] {
    float: left;
    width: 80%;
    padding: 0.25em;
    box-sizing: border-box;
 }
 div.sphinxsidebar #searchbox input[type="submit"] {
    float: left;
    width: 20%;
    border-left: none;
    padding: 0.25em;
    box-sizing: border-box;
 }
 img {
    border: 0;
    max-width: 100%;
 }
 /* -- search page ----------------------------------------------------------- */
 ul.search {
    margin: 10px 0 0 20px;
    padding: 0;
 }
 ul.search li {
    padding: 5px 0 5px 20px;
    background-image: url(file.png);
    background-repeat: no-repeat;
    background-position: 0 7px;
 }
 ul.search li a {
    font-weight: bold;
 }
 ul.search li div.context {
    color: #888;
    margin: 2px 0 0 30px;
    text-align: left;
 }
 ul.keywordmatches li.goodmatch a {
    font-weight: bold;
 }
 /* -- index page ------------------------------------------------------------ */
 table.contentstable {
    width: 90%;
    margin-left: auto;
    margin-right: auto;
 }
 table.contentstable p.biglink {
    line-height: 150%;
 }
 a.biglink {
    font-size: 1.3em;
 }
 span.linkdescr {
    font-style: italic;
    padding-top: 5px;
    font-size: 90%;
 }
 /* -- general index --------------------------------------------------------- */
 table.indextable {
    width: 100%;
 }
 table.indextable td {
    text-align: left;
    vertical-align: top;
 }
 table.indextable ul {
    margin-top: 0;
    margin-bottom: 0;
    list-style-type: none;
 }
 table.indextable > tbody > tr > td > ul {
    padding-left: 0em;
 }
 table.indextable tr.pcap {
    height: 10px;
 }
 table.indextable tr.cap {
    margin-top: 10px;
    background-color: #f2f2f2;
 }
 img.toggler {
    margin-right: 3px;
    margin-top: 3px;
    cursor: pointer;
 }
 div.modindex-jumpbox {
    border-top: 1px solid #ddd;
    border-bottom: 1px solid #ddd;
    margin: 1em 0 1em 0;
    padding: 0.4em;
 }
 div.genindex-jumpbox {
    border-top: 1px solid #ddd;
    border-bottom: 1px solid #ddd;
    margin: 1em 0 1em 0;
    padding: 0.4em;
 }
 /* -- domain module index --------------------------------------------------- */
 table.modindextable td {
    padding: 2px;
    border-collapse: collapse;
 }
 /* -- general body styles --------------------------------------------------- */
 div.body {
    min-width: 450px;
    max-width: 800px;
 }
 div.body p, div.body dd, div.body li, div.body blockquote {
    -moz-hyphens: auto;
    -ms-hyphens: auto;
    -webkit-hyphens: auto;
    hyphens: auto;
 }
 a.headerlink {
    visibility: hidden;
 }
 a.brackets:before,
 span.brackets > a:before{
    content: "[";
 }
 a.brackets:after,
 span.brackets > a:after {
    content: "]";
 }
 h1:hover > a.headerlink,
 h2:hover > a.headerlink,
 h3:hover > a.headerlink,
 h4:hover > a.headerlink,
 h5:hover > a.headerlink,
 h6:hover > a.headerlink,
 dt:hover > a.headerlink,
 caption:hover > a.headerlink,
 p.caption:hover > a.headerlink,
 div.code-block-caption:hover > a.headerlink {
    visibility: visible;
 }
 div.body p.caption {
    text-align: inherit;
 }
 div.body td {
    text-align: left;
 }
 .first {
    margin-top: 0 !important;
 }
 p.rubric {
    margin-top: 30px;
    font-weight: bold;
 }
 img.align-left, .figure.align-left, object.align-left {
    clear: left;
    float: left;
    margin-right: 1em;
 }
 img.align-right, .figure.align-right, object.align-right {
    clear: right;
    float: right;
    margin-left: 1em;
 }
 img.align-center, .figure.align-center, object.align-center {
  display: block;
  margin-left: auto;
  margin-right: auto;
 }
 img.align-default, .figure.align-default {
  display: block;
  margin-left: auto;
  margin-right: auto;
 }
 .align-left {
    text-align: left;
 }
 .align-center {
    text-align: center;
 }
 .align-default {
    text-align: center;
 }
 .align-right {
    text-align: right;
 }
 /* -- sidebars -------------------------------------------------------------- */
 div.sidebar {
    margin: 0 0 0.5em 1em;
    border: 1px solid #ddb;
    padding: 7px;
    background-color: #ffe;
    width: 40%;
    float: right;
    clear: right;
    overflow-x: auto;
 }
 p.sidebar-title {
    font-weight: bold;
 }
 div.admonition, div.topic, blockquote {
    clear: left;
 }
 /* -- topics ---------------------------------------------------------------- */
 div.topic {
    border: 1px solid #ccc;
    padding: 7px;
    margin: 10px 0 10px 0;
 }
 p.topic-title {
    font-size: 1.1em;
    font-weight: bold;
    margin-top: 10px;
 }
 /* -- admonitions ----------------------------------------------------------- */
 div.admonition {
    margin-top: 10px;
    margin-bottom: 10px;
    padding: 7px;
 }
 div.admonition dt {
    font-weight: bold;
 }
 p.admonition-title {
    margin: 0px 10px 5px 0px;
    font-weight: bold;
 }
 div.body p.centered {
    text-align: center;
    margin-top: 25px;
 }
 /* -- content of sidebars/topics/admonitions -------------------------------- */
 div.sidebar > :last-child,
 div.topic > :last-child,
 div.admonition > :last-child {
    margin-bottom: 0;
 }
 div.sidebar::after,
 div.topic::after,
 div.admonition::after,
 blockquote::after {
    display: block;
    content: '';
    clear: both;
 }
 /* -- tables ---------------------------------------------------------------- */
 table.docutils {
    margin-top: 10px;
    margin-bottom: 10px;
    border: 0;
    border-collapse: collapse;
 }
 table.align-center {
    margin-left: auto;
    margin-right: auto;
 }
 table.align-default {
    margin-left: auto;
    margin-right: auto;
 }
 table caption span.caption-number {
    font-style: italic;
 }
 table caption span.caption-text {
 }
 table.docutils td, table.docutils th {
    padding: 1px 8px 1px 5px;
    border-top: 0;
    border-left: 0;
    border-right: 0;
    border-bottom: 1px solid #aaa;
 }
 table.footnote td, table.footnote th {
    border: 0 !important;
 }
 th {
    text-align: left;
    padding-right: 5px;
 }
 table.citation {
    border-left: solid 1px gray;
    margin-left: 1px;
 }
 table.citation td {
    border-bottom: none;
 }
 th > :first-child,
 td > :first-child {
    margin-top: 0px;
 }
 th > :last-child,
 td > :last-child {
    margin-bottom: 0px;
 }
 /* -- figures --------------------------------------------------------------- */
 div.figure {
    margin: 0.5em;
    padding: 0.5em;
 }
 div.figure p.caption {
    padding: 0.3em;
 }
 div.figure p.caption span.caption-number {
    font-style: italic;
 }
 div.figure p.caption span.caption-text {
 }
 /* -- field list styles ----------------------------------------------------- */
 table.field-list td, table.field-list th {
    border: 0 !important;
 }
 .field-list ul {
    margin: 0;
    padding-left: 1em;
 }
 .field-list p {
    margin: 0;
 }
 .field-name {
    -moz-hyphens: manual;
    -ms-hyphens: manual;
    -webkit-hyphens: manual;
    hyphens: manual;
 }
 /* -- hlist styles ---------------------------------------------------------- */
 table.hlist {
    margin: 1em 0;
 }
 table.hlist td {
    vertical-align: top;
 }
 /* -- other body styles ----------------------------------------------------- */
 ol.arabic {
    list-style: decimal;
 }
 ol.loweralpha {
    list-style: lower-alpha;
 }
 ol.upperalpha {
    list-style: upper-alpha;
 }
 ol.lowerroman {
    list-style: lower-roman;
 }
 ol.upperroman {
    list-style: upper-roman;
 }
 :not(li) > ol > li:first-child > :first-child,
 :not(li) > ul > li:first-child > :first-child {
    margin-top: 0px;
 }
 :not(li) > ol > li:last-child > :last-child,
 :not(li) > ul > li:last-child > :last-child {
    margin-bottom: 0px;
 }
 ol.simple ol p,
 ol.simple ul p,
 ul.simple ol p,
 ul.simple ul p {
    margin-top: 0;
 }
 ol.simple > li:not(:first-child) > p,
 ul.simple > li:not(:first-child) > p {
    margin-top: 0;
 }
 ol.simple p,
 ul.simple p {
    margin-bottom: 0;
 }
 dl.footnote > dt,
 dl.citation > dt {
    float: left;
    margin-right: 0.5em;
 }
 dl.footnote > dd,
 dl.citation > dd {
    margin-bottom: 0em;
 }
 dl.footnote > dd:after,
 dl.citation > dd:after {
    content: "";
    clear: both;
 }
 dl.field-list {
    display: grid;
    grid-template-columns: fit-content(30%) auto;
 }
 dl.field-list > dt {
    font-weight: bold;
    word-break: break-word;
    padding-left: 0.5em;
    padding-right: 5px;
 }
 dl.field-list > dt:after {
    content: ":";
 }
 dl.field-list > dd {
    padding-left: 0.5em;
    margin-top: 0em;
    margin-left: 0em;
    margin-bottom: 0em;
 }
 dl {
    margin-bottom: 15px;
 }
 dd > :first-child {
    margin-top: 0px;
 }
 dd ul, dd table {
    margin-bottom: 10px;
 }
 dd {
    margin-top: 3px;
    margin-bottom: 10px;
    margin-left: 30px;
 }
 dl > dd:last-child,
 dl > dd:last-child > :last-child {
    margin-bottom: 0;
 }
 dt:target, span.highlighted {
    background-color: #fbe54e;
 }
 rect.highlighted {
    fill: #fbe54e;
 }
 dl.glossary dt {
    font-weight: bold;
    font-size: 1.1em;
 }
 .optional {
    font-size: 1.3em;
 }
 .sig-paren {
    font-size: larger;
 }
 .versionmodified {
    font-style: italic;
 }
 .system-message {
    background-color: #fda;
    padding: 5px;
    border: 3px solid red;
 }
 .footnote:target  {
    background-color: #ffa;
 }
 .line-block {
    display: block;
    margin-top: 1em;
    margin-bottom: 1em;
 }
 .line-block .line-block {
    margin-top: 0;
    margin-bottom: 0;
    margin-left: 1.5em;
 }
 .guilabel, .menuselection {
    font-family: sans-serif;
 }
 .accelerator {
    text-decoration: underline;
 }
 .classifier {
    font-style: oblique;
 }
 .classifier:before {
    font-style: normal;
    margin: 0.5em;
    content: ":";
 }
 abbr, acronym {
    border-bottom: dotted 1px;
    cursor: help;
 }
 /* -- code displays --------------------------------------------------------- */
 pre {
    overflow: auto;
    overflow-y: hidden;  /* fixes display issues on Chrome browsers */
 }
 pre, div[class*="highlight-"] {
    clear: both;
 }
 span.pre {
    -moz-hyphens: none;
    -ms-hyphens: none;
    -webkit-hyphens: none;
    hyphens: none;
 }
 div[class*="highlight-"] {
    margin: 1em 0;
 }
 td.linenos pre {
    border: 0;
    background-color: transparent;
    color: #aaa;
 }
 table.highlighttable {
    display: block;
 }
 table.highlighttable tbody {
    display: block;
 }
 table.highlighttable tr {
    display: flex;
 }
 table.highlighttable td {
    margin: 0;
    padding: 0;
 }
 table.highlighttable td.linenos {
    padding-right: 0.5em;
 }
 table.highlighttable td.code {
    flex: 1;
    overflow: hidden;
 }
 .highlight .hll {
    display: block;
 }
 div.highlight pre,
 table.highlighttable pre {
    margin: 0;
 }
 div.code-block-caption + div {
    margin-top: 0;
 }
 div.code-block-caption {
    margin-top: 1em;
    padding: 2px 5px;
    font-size: small;
 }
 div.code-block-caption code {
    background-color: transparent;
 }
 table.highlighttable td.linenos,
 span.linenos,
 div.doctest > div.highlight span.gp {  /* gp: Generic.Prompt */
    user-select: none;
 }
 div.code-block-caption span.caption-number {
    padding: 0.1em 0.3em;
    font-style: italic;
 }
 div.code-block-caption span.caption-text {
 }
 div.literal-block-wrapper {
    margin: 1em 0;
 }
 code.descname {
    background-color: transparent;
    font-weight: bold;
    font-size: 1.2em;
 }
 code.descclassname {
    background-color: transparent;
 }
 code.xref, a code {
    background-color: transparent;
    font-weight: bold;
 }
 h1 code, h2 code, h3 code, h4 code, h5 code, h6 code {
    background-color: transparent;
 }
 .viewcode-link {
    float: right;
 }
 .viewcode-back {
    float: right;
    font-family: sans-serif;
 }
 div.viewcode-block:target {
    margin: -1px -10px;
    padding: 0 10px;
 }
 /* -- math display ---------------------------------------------------------- */
 img.math {
    vertical-align: middle;
 }
 div.body div.math p {
    text-align: center;
 }
 span.eqno {
    float: right;
 }
 span.eqno a.headerlink {
    position: absolute;
    z-index: 1;
 }
 div.math:hover a.headerlink {
    visibility: visible;
 }
 /* -- printout stylesheet --------------------------------------------------- */
@media print {
    div.document,
    div.documentwrapper,
    div.bodywrapper {
        margin: 0 !important;
        width: 100%;
    }
    div.sphinxsidebar,
    div.related,
    div.footer,
    #top-link {
        display: none;
    }
 }
--- a/0.2/_static/css/index.c5995385ac14fb8791e8eb36b4908be2.css
+++ b/0.2/_static/css/index.c5995385ac14fb8791e8eb36b4908be2.css
--- a/0.2/_static/css/theme.css
+++ b/0.2/_static/css/theme.css
@ -0,0 +1,117 @@
 :root {
  /*****************************************************************************
  * Theme config
  **/
  --pst-header-height: 60px;
  /*****************************************************************************
  * Font size
  **/
  --pst-font-size-base: 15px; /* base font size - applied at body / html level */
  /* heading font sizes */
  --pst-font-size-h1: 36px;
  --pst-font-size-h2: 32px;
  --pst-font-size-h3: 26px;
  --pst-font-size-h4: 21px;
  --pst-font-size-h5: 18px;
  --pst-font-size-h6: 16px;
  /* smaller then heading font sizes*/
  --pst-font-size-milli: 12px;
  --pst-sidebar-font-size: .9em;
  --pst-sidebar-caption-font-size: .9em;
  /*****************************************************************************
  * Font family
  **/
  /* These are adapted from https://systemfontstack.com/ */
  --pst-font-family-base-system: -apple-system, BlinkMacSystemFont, Segoe UI, "Helvetica Neue",
    Arial, sans-serif, Apple Color Emoji, Segoe UI Emoji, Segoe UI Symbol;
  --pst-font-family-monospace-system: "SFMono-Regular", Menlo, Consolas, Monaco,
    Liberation Mono, Lucida Console, monospace;
  --pst-font-family-base: var(--pst-font-family-base-system);
  --pst-font-family-heading: var(--pst-font-family-base);
  --pst-font-family-monospace: var(--pst-font-family-monospace-system);
  /*****************************************************************************
  * Color
  * 
  * Colors are defined in rgb string way, "red, green, blue"
  **/
  --pst-color-primary: 19, 6, 84;
  --pst-color-success: 40, 167, 69;
  --pst-color-info: 0, 123, 255;  /*23, 162, 184;*/
  --pst-color-warning: 255, 193, 7;
  --pst-color-danger: 220, 53, 69;
  --pst-color-text-base: 51, 51, 51;
  --pst-color-h1: var(--pst-color-primary);
  --pst-color-h2: var(--pst-color-primary);
  --pst-color-h3: var(--pst-color-text-base);
  --pst-color-h4: var(--pst-color-text-base);
  --pst-color-h5: var(--pst-color-text-base);
  --pst-color-h6: var(--pst-color-text-base);
  --pst-color-paragraph: var(--pst-color-text-base);
  --pst-color-link: 0, 91, 129;
  --pst-color-link-hover: 227, 46, 0;
  --pst-color-headerlink: 198, 15, 15;
  --pst-color-headerlink-hover: 255, 255, 255;
  --pst-color-preformatted-text: 34, 34, 34;
  --pst-color-preformatted-background: 250, 250, 250;
  --pst-color-inline-code: 232, 62, 140;
  --pst-color-active-navigation: 19, 6, 84;
  --pst-color-navbar-link: 77, 77, 77;
  --pst-color-navbar-link-hover: var(--pst-color-active-navigation);
  --pst-color-navbar-link-active: var(--pst-color-active-navigation);
  --pst-color-sidebar-link: 77, 77, 77;
  --pst-color-sidebar-link-hover: var(--pst-color-active-navigation);
  --pst-color-sidebar-link-active: var(--pst-color-active-navigation);
  --pst-color-sidebar-expander-background-hover: 244, 244, 244;
  --pst-color-sidebar-caption: 77, 77, 77;
  --pst-color-toc-link: 119, 117, 122;
  --pst-color-toc-link-hover: var(--pst-color-active-navigation);
  --pst-color-toc-link-active: var(--pst-color-active-navigation);
  /*****************************************************************************
  * Icon
  **/
  /* font awesome icons*/
  --pst-icon-check-circle: '\f058';
  --pst-icon-info-circle: '\f05a';
  --pst-icon-exclamation-triangle: '\f071';
  --pst-icon-exclamation-circle: '\f06a';
  --pst-icon-times-circle: '\f057';
  --pst-icon-lightbulb: '\f0eb';
  /*****************************************************************************
  * Admonitions
  **/
  --pst-color-admonition-default: var(--pst-color-info);
  --pst-color-admonition-note: var(--pst-color-info);
  --pst-color-admonition-attention: var(--pst-color-warning);
  --pst-color-admonition-caution: var(--pst-color-warning);
  --pst-color-admonition-warning: var(--pst-color-warning);
  --pst-color-admonition-danger: var(--pst-color-danger);
  --pst-color-admonition-error: var(--pst-color-danger);
  --pst-color-admonition-hint: var(--pst-color-success);
  --pst-color-admonition-tip: var(--pst-color-success);
  --pst-color-admonition-important: var(--pst-color-success);
  --pst-icon-admonition-default: var(--pst-icon-info-circle);
  --pst-icon-admonition-note: var(--pst-icon-info-circle);
  --pst-icon-admonition-attention: var(--pst-icon-exclamation-circle);
  --pst-icon-admonition-caution: var(--pst-icon-exclamation-triangle);
  --pst-icon-admonition-warning: var(--pst-icon-exclamation-triangle);
  --pst-icon-admonition-danger: var(--pst-icon-exclamation-triangle);
  --pst-icon-admonition-error: var(--pst-icon-times-circle);
  --pst-icon-admonition-hint: var(--pst-icon-lightbulb);
  --pst-icon-admonition-tip: var(--pst-icon-lightbulb);
  --pst-icon-admonition-important: var(--pst-icon-exclamation-circle);
 }
--- a/0.2/_static/custom.css
+++ b/0.2/_static/custom.css
@ -0,0 +1,7 @@
 h1.site-logo {
    font-size: 30px !important;
 }
 h1.site-logo small {
    font-size: 20px !important;
 }
--- a/0.2/_static/doctools.js
+++ b/0.2/_static/doctools.js
@ -0,0 +1,316 @@
 /*
 * doctools.js
 * ~~~~~~~~~~~
 *
 * Sphinx JavaScript utilities for all documentation.
 *
 * :copyright: Copyright 2007-2021 by the Sphinx team, see AUTHORS.
 * :license: BSD, see LICENSE for details.
 *
 */
 /**
 * select a different prefix for underscore
 */
 $u = _.noConflict();
 /**
 * make the code below compatible with browsers without
 * an installed firebug like debugger
 if (!window.console || !console.firebug) {
  var names = ["log", "debug", "info", "warn", "error", "assert", "dir",
    "dirxml", "group", "groupEnd", "time", "timeEnd", "count", "trace",
    "profile", "profileEnd"];
  window.console = {};
  for (var i = 0; i < names.length; ++i)
    window.console[names[i]] = function() {};
 }
 */
 /**
 * small helper function to urldecode strings
 */
 jQuery.urldecode = function(x) {
  return decodeURIComponent(x).replace(/\+/g, ' ');
 };
 /**
 * small helper function to urlencode strings
 */
 jQuery.urlencode = encodeURIComponent;
 /**
 * This function returns the parsed url parameters of the
 * current request. Multiple values per key are supported,
 * it will always return arrays of strings for the value parts.
 */
 jQuery.getQueryParameters = function(s) {
  if (typeof s === 'undefined')
    s = document.location.search;
  var parts = s.substr(s.indexOf('?') + 1).split('&');
  var result = {};
  for (var i = 0; i < parts.length; i++) {
    var tmp = parts[i].split('=', 2);
    var key = jQuery.urldecode(tmp[0]);
    var value = jQuery.urldecode(tmp[1]);
    if (key in result)
      result[key].push(value);
    else
      result[key] = [value];
  }
  return result;
 };
 /**
 * highlight a given string on a jquery object by wrapping it in
 * span elements with the given class name.
 */
 jQuery.fn.highlightText = function(text, className) {
  function highlight(node, addItems) {
    if (node.nodeType === 3) {
      var val = node.nodeValue;
      var pos = val.toLowerCase().indexOf(text);
      if (pos >= 0 &&
          !jQuery(node.parentNode).hasClass(className) &&
          !jQuery(node.parentNode).hasClass("nohighlight")) {
        var span;
        var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg");
        if (isInSVG) {
          span = document.createElementNS("http://www.w3.org/2000/svg", "tspan");
        } else {
          span = document.createElement("span");
          span.className = className;
        }
        span.appendChild(document.createTextNode(val.substr(pos, text.length)));
        node.parentNode.insertBefore(span, node.parentNode.insertBefore(
          document.createTextNode(val.substr(pos + text.length)),
          node.nextSibling));
        node.nodeValue = val.substr(0, pos);
        if (isInSVG) {
          var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
          var bbox = node.parentElement.getBBox();
          rect.x.baseVal.value = bbox.x;
          rect.y.baseVal.value = bbox.y;
          rect.width.baseVal.value = bbox.width;
          rect.height.baseVal.value = bbox.height;
          rect.setAttribute('class', className);
          addItems.push({
              "parent": node.parentNode,
              "target": rect});
        }
      }
    }
    else if (!jQuery(node).is("button, select, textarea")) {
      jQuery.each(node.childNodes, function() {
        highlight(this, addItems);
      });
    }
  }
  var addItems = [];
  var result = this.each(function() {
    highlight(this, addItems);
  });
  for (var i = 0; i < addItems.length; ++i) {
    jQuery(addItems[i].parent).before(addItems[i].target);
  }
  return result;
 };
 /*
 * backward compatibility for jQuery.browser
 * This will be supported until firefox bug is fixed.
 */
 if (!jQuery.browser) {
  jQuery.uaMatch = function(ua) {
    ua = ua.toLowerCase();
    var match = /(chrome)[ \/]([\w.]+)/.exec(ua) ||
      /(webkit)[ \/]([\w.]+)/.exec(ua) ||
      /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) ||
      /(msie) ([\w.]+)/.exec(ua) ||
      ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) ||
      [];
    return {
      browser: match[ 1 ] || "",
      version: match[ 2 ] || "0"
    };
  };
  jQuery.browser = {};
  jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true;
 }
 /**
 * Small JavaScript module for the documentation.
 */
 var Documentation = {
  init : function() {
    this.fixFirefoxAnchorBug();
    this.highlightSearchWords();
    this.initIndexTable();
    if (DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) {
      this.initOnKeyListeners();
    }
  },
  /**
   * i18n support
   */
  TRANSLATIONS : {},
  PLURAL_EXPR : function(n) { return n === 1 ? 0 : 1; },
  LOCALE : 'unknown',
  // gettext and ngettext don't access this so that the functions
  // can safely bound to a different name (_ = Documentation.gettext)
  gettext : function(string) {
    var translated = Documentation.TRANSLATIONS[string];
    if (typeof translated === 'undefined')
      return string;
    return (typeof translated === 'string') ? translated : translated[0];
  },
  ngettext : function(singular, plural, n) {
    var translated = Documentation.TRANSLATIONS[singular];
    if (typeof translated === 'undefined')
      return (n == 1) ? singular : plural;
    return translated[Documentation.PLURALEXPR(n)];
  },
  addTranslations : function(catalog) {
    for (var key in catalog.messages)
      this.TRANSLATIONS[key] = catalog.messages[key];
    this.PLURAL_EXPR = new Function('n', 'return +(' + catalog.plural_expr + ')');
    this.LOCALE = catalog.locale;
  },
  /**
   * add context elements like header anchor links
   */
  addContextElements : function() {
    $('div[id] > :header:first').each(function() {
      $('<a class="headerlink">\u00B6</a>').
      attr('href', '#' + this.id).
      attr('title', _('Permalink to this headline')).
      appendTo(this);
    });
    $('dt[id]').each(function() {
      $('<a class="headerlink">\u00B6</a>').
      attr('href', '#' + this.id).
      attr('title', _('Permalink to this definition')).
      appendTo(this);
    });
  },
  /**
   * workaround a firefox stupidity
   * see: https://bugzilla.mozilla.org/show_bug.cgi?id=645075
   */
  fixFirefoxAnchorBug : function() {
    if (document.location.hash && $.browser.mozilla)
      window.setTimeout(function() {
        document.location.href += '';
      }, 10);
  },
  /**
   * highlight the search words provided in the url in the text
   */
  highlightSearchWords : function() {
    var params = $.getQueryParameters();
    var terms = (params.highlight) ? params.highlight[0].split(/\s+/) : [];
    if (terms.length) {
      var body = $('div.body');
      if (!body.length) {
        body = $('body');
      }
      window.setTimeout(function() {
        $.each(terms, function() {
          body.highlightText(this.toLowerCase(), 'highlighted');
        });
      }, 10);
      $('<p class="highlight-link"><a href="javascript:Documentation.' +
        'hideSearchWords()">' + _('Hide Search Matches') + '</a></p>')
          .appendTo($('#searchbox'));
    }
  },
  /**
   * init the domain index toggle buttons
   */
  initIndexTable : function() {
    var togglers = $('img.toggler').click(function() {
      var src = $(this).attr('src');
      var idnum = $(this).attr('id').substr(7);
      $('tr.cg-' + idnum).toggle();
      if (src.substr(-9) === 'minus.png')
        $(this).attr('src', src.substr(0, src.length-9) + 'plus.png');
      else
        $(this).attr('src', src.substr(0, src.length-8) + 'minus.png');
    }).css('display', '');
    if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) {
        togglers.click();
    }
  },
  /**
   * helper function to hide the search marks again
   */
  hideSearchWords : function() {
    $('#searchbox .highlight-link').fadeOut(300);
    $('span.highlighted').removeClass('highlighted');
  },
  /**
   * make the url absolute
   */
  makeURL : function(relativeURL) {
    return DOCUMENTATION_OPTIONS.URL_ROOT + '/' + relativeURL;
  },
  /**
   * get the current relative url
   */
  getCurrentURL : function() {
    var path = document.location.pathname;
    var parts = path.split(/\//);
    $.each(DOCUMENTATION_OPTIONS.URL_ROOT.split(/\//), function() {
      if (this === '..')
        parts.pop();
    });
    var url = parts.join('/');
    return path.substring(url.lastIndexOf('/') + 1, path.length - 1);
  },
  initOnKeyListeners: function() {
    $(document).keydown(function(event) {
      var activeElementType = document.activeElement.tagName;
      // don't navigate when in search box, textarea, dropdown or button
      if (activeElementType !== 'TEXTAREA' && activeElementType !== 'INPUT' && activeElementType !== 'SELECT'
          && activeElementType !== 'BUTTON' && !event.altKey && !event.ctrlKey && !event.metaKey
          && !event.shiftKey) {
        switch (event.keyCode) {
          case 37: // left
            var prevHref = $('link[rel="prev"]').prop('href');
            if (prevHref) {
              window.location.href = prevHref;
              return false;
            }
          case 39: // right
            var nextHref = $('link[rel="next"]').prop('href');
            if (nextHref) {
              window.location.href = nextHref;
              return false;
            }
        }
      }
    });
  }
 };
 // quick alias for translations
 _ = Documentation.gettext;
 $(document).ready(function() {
  Documentation.init();
 });
--- a/0.2/_static/documentation_options.js
+++ b/0.2/_static/documentation_options.js
@ -0,0 +1,12 @@
 var DOCUMENTATION_OPTIONS = {
    URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'),
    VERSION: '0.2.0',
    LANGUAGE: 'None',
    COLLAPSE_INDEX: false,
    BUILDER: 'dirhtml',
    FILE_SUFFIX: '.html',
    LINK_SUFFIX: '.html',
    HAS_SOURCE: true,
    SOURCELINK_SUFFIX: '.txt',
    NAVIGATION_WITH_KEYS: true
 };
--- a/0.2/_static/file.png
+++ b/0.2/_static/file.png
--- a/0.2/_static/images/logo_binder.svg
+++ b/0.2/_static/images/logo_binder.svg
@ -0,0 +1,19 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!-- Generator: Adobe Illustrator 23.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
 <svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
 	 viewBox="0 0 44.4 44.4" style="enable-background:new 0 0 44.4 44.4;" xml:space="preserve">
 <style type="text/css">
 	.st0{fill:none;stroke:#F5A252;stroke-width:5;stroke-miterlimit:10;}
 	.st1{fill:none;stroke:#579ACA;stroke-width:5;stroke-miterlimit:10;}
 	.st2{fill:none;stroke:#E66581;stroke-width:5;stroke-miterlimit:10;}
 </style>
 <title>logo</title>
 <g>
 	<path class="st0" d="M33.9,6.4c3.6,3.9,3.4,9.9-0.5,13.5s-9.9,3.4-13.5-0.5s-3.4-9.9,0.5-13.5l0,0C24.2,2.4,30.2,2.6,33.9,6.4z"/>
 	<path class="st1" d="M35.1,27.3c2.6,4.6,1.1,10.4-3.5,13c-4.6,2.6-10.4,1.1-13-3.5s-1.1-10.4,3.5-13l0,0
 		C26.6,21.2,32.4,22.7,35.1,27.3z"/>
 	<path class="st2" d="M25.9,17.8c2.6,4.6,1.1,10.4-3.5,13s-10.4,1.1-13-3.5s-1.1-10.4,3.5-13l0,0C17.5,11.7,23.3,13.2,25.9,17.8z"/>
 	<path class="st1" d="M19.2,26.4c3.1-4.3,9.1-5.2,13.3-2.1c1.1,0.8,2,1.8,2.7,3"/>
 	<path class="st0" d="M19.9,19.4c-3.6-3.9-3.4-9.9,0.5-13.5s9.9-3.4,13.5,0.5"/>
 </g>
 </svg>
--- a/0.2/_static/images/logo_colab.png
+++ b/0.2/_static/images/logo_colab.png
--- a/0.2/_static/images/logo_jupyterhub.svg
+++ b/0.2/_static/images/logo_jupyterhub.svg
@ -0,0 +1 @@
 <svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" width="38.73" height="50" viewBox="0 0 38.73 50"><defs><style>.cls-1{fill:#767677;}.cls-2{fill:#f37726;}.cls-3{fill:#9e9e9e;}.cls-4{fill:#616262;}.cls-5{font-size:17.07px;fill:#fff;font-family:Roboto-Regular, Roboto;}</style></defs><title>logo_jupyterhub</title><g id="Canvas"><path id="path7_fill" data-name="path7 fill" class="cls-1" d="M39.51,3.53a3,3,0,0,1-1.7,2.9A3,3,0,0,1,34.48,6a3,3,0,0,1-.82-3.26,3,3,0,0,1,1.05-1.41A3,3,0,0,1,37.52.86a2.88,2.88,0,0,1,1,.6,3,3,0,0,1,.7.93,3.18,3.18,0,0,1,.28,1.14Z" transform="translate(-1.87 -0.69)"/><path id="path8_fill" data-name="path8 fill" class="cls-2" d="M21.91,38.39c-8,0-15.06-2.87-18.7-7.12a19.93,19.93,0,0,0,37.39,0C37,35.52,30,38.39,21.91,38.39Z" transform="translate(-1.87 -0.69)"/><path id="path9_fill" data-name="path9 fill" class="cls-2" d="M21.91,10.78c8,0,15.05,2.87,18.69,7.12a19.93,19.93,0,0,0-37.39,0C6.85,13.64,13.86,10.78,21.91,10.78Z" transform="translate(-1.87 -0.69)"/><path id="path10_fill" data-name="path10 fill" class="cls-3" d="M10.88,46.66a3.86,3.86,0,0,1-.52,2.15,3.81,3.81,0,0,1-1.62,1.51,3.93,3.93,0,0,1-2.19.34,3.79,3.79,0,0,1-2-.94,3.73,3.73,0,0,1-1.14-1.9,3.79,3.79,0,0,1,.1-2.21,3.86,3.86,0,0,1,1.33-1.78,3.92,3.92,0,0,1,3.54-.53,3.85,3.85,0,0,1,2.14,1.93,3.74,3.74,0,0,1,.37,1.43Z" transform="translate(-1.87 -0.69)"/><path id="path11_fill" data-name="path11 fill" class="cls-4" d="M4.12,9.81A2.18,2.18,0,0,1,2.9,9.48a2.23,2.23,0,0,1-.84-1A2.26,2.26,0,0,1,1.9,7.26a2.13,2.13,0,0,1,.56-1.13,2.18,2.18,0,0,1,2.36-.56,2.13,2.13,0,0,1,1,.76,2.18,2.18,0,0,1,.42,1.2A2.22,2.22,0,0,1,4.12,9.81Z" transform="translate(-1.87 -0.69)"/></g><text class="cls-5" transform="translate(5.24 30.01)">Hub</text></svg>
--- a/0.2/_static/jquery-3.5.1.js
+++ b/0.2/_static/jquery-3.5.1.js
--- a/0.2/_static/jquery.js
+++ b/0.2/_static/jquery.js
--- a/0.2/_static/js/index.1c5a1a01449ed65a7b51.js
+++ b/0.2/_static/js/index.1c5a1a01449ed65a7b51.js
--- a/0.2/_static/language_data.js
+++ b/0.2/_static/language_data.js
@ -0,0 +1,297 @@
 /*
 * language_data.js
 * ~~~~~~~~~~~~~~~~
 *
 * This script contains the language-specific data used by searchtools.js,
 * namely the list of stopwords, stemmer, scorer and splitter.
 *
 * :copyright: Copyright 2007-2021 by the Sphinx team, see AUTHORS.
 * :license: BSD, see LICENSE for details.
 *
 */
 var stopwords = ["a","and","are","as","at","be","but","by","for","if","in","into","is","it","near","no","not","of","on","or","such","that","the","their","then","there","these","they","this","to","was","will","with"];
 /* Non-minified version JS is _stemmer.js if file is provided */ 
 /**
 * Porter Stemmer
 */
 var Stemmer = function() {
  var step2list = {
    ational: 'ate',
    tional: 'tion',
    enci: 'ence',
    anci: 'ance',
    izer: 'ize',
    bli: 'ble',
    alli: 'al',
    entli: 'ent',
    eli: 'e',
    ousli: 'ous',
    ization: 'ize',
    ation: 'ate',
    ator: 'ate',
    alism: 'al',
    iveness: 'ive',
    fulness: 'ful',
    ousness: 'ous',
    aliti: 'al',
    iviti: 'ive',
    biliti: 'ble',
    logi: 'log'
  };
  var step3list = {
    icate: 'ic',
    ative: '',
    alize: 'al',
    iciti: 'ic',
    ical: 'ic',
    ful: '',
    ness: ''
  };
  var c = "[^aeiou]";          // consonant
  var v = "[aeiouy]";          // vowel
  var C = c + "[^aeiouy]*";    // consonant sequence
  var V = v + "[aeiou]*";      // vowel sequence
  var mgr0 = "^(" + C + ")?" + V + C;                      // [C]VC... is m>0
  var meq1 = "^(" + C + ")?" + V + C + "(" + V + ")?$";    // [C]VC[V] is m=1
  var mgr1 = "^(" + C + ")?" + V + C + V + C;              // [C]VCVC... is m>1
  var s_v   = "^(" + C + ")?" + v;                         // vowel in stem
  this.stemWord = function (w) {
    var stem;
    var suffix;
    var firstch;
    var origword = w;
    if (w.length < 3)
      return w;
    var re;
    var re2;
    var re3;
    var re4;
    firstch = w.substr(0,1);
    if (firstch == "y")
      w = firstch.toUpperCase() + w.substr(1);
    // Step 1a
    re = /^(.+?)(ss|i)es$/;
    re2 = /^(.+?)([^s])s$/;
    if (re.test(w))
      w = w.replace(re,"$1$2");
    else if (re2.test(w))
      w = w.replace(re2,"$1$2");
    // Step 1b
    re = /^(.+?)eed$/;
    re2 = /^(.+?)(ed|ing)$/;
    if (re.test(w)) {
      var fp = re.exec(w);
      re = new RegExp(mgr0);
      if (re.test(fp[1])) {
        re = /.$/;
        w = w.replace(re,"");
      }
    }
    else if (re2.test(w)) {
      var fp = re2.exec(w);
      stem = fp[1];
      re2 = new RegExp(s_v);
      if (re2.test(stem)) {
        w = stem;
        re2 = /(at|bl|iz)$/;
        re3 = new RegExp("([^aeiouylsz])\\1$");
        re4 = new RegExp("^" + C + v + "[^aeiouwxy]$");
        if (re2.test(w))
          w = w + "e";
        else if (re3.test(w)) {
          re = /.$/;
          w = w.replace(re,"");
        }
        else if (re4.test(w))
          w = w + "e";
      }
    }
    // Step 1c
    re = /^(.+?)y$/;
    if (re.test(w)) {
      var fp = re.exec(w);
      stem = fp[1];
      re = new RegExp(s_v);
      if (re.test(stem))
        w = stem + "i";
    }
    // Step 2
    re = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/;
    if (re.test(w)) {
      var fp = re.exec(w);
      stem = fp[1];
      suffix = fp[2];
      re = new RegExp(mgr0);
      if (re.test(stem))
        w = stem + step2list[suffix];
    }
    // Step 3
    re = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/;
    if (re.test(w)) {
      var fp = re.exec(w);
      stem = fp[1];
      suffix = fp[2];
      re = new RegExp(mgr0);
      if (re.test(stem))
        w = stem + step3list[suffix];
    }
    // Step 4
    re = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/;
    re2 = /^(.+?)(s|t)(ion)$/;
    if (re.test(w)) {
      var fp = re.exec(w);
      stem = fp[1];
      re = new RegExp(mgr1);
      if (re.test(stem))
        w = stem;
    }
    else if (re2.test(w)) {
      var fp = re2.exec(w);
      stem = fp[1] + fp[2];
      re2 = new RegExp(mgr1);
      if (re2.test(stem))
        w = stem;
    }
    // Step 5
    re = /^(.+?)e$/;
    if (re.test(w)) {
      var fp = re.exec(w);
      stem = fp[1];
      re = new RegExp(mgr1);
      re2 = new RegExp(meq1);
      re3 = new RegExp("^" + C + v + "[^aeiouwxy]$");
      if (re.test(stem) || (re2.test(stem) && !(re3.test(stem))))
        w = stem;
    }
    re = /ll$/;
    re2 = new RegExp(mgr1);
    if (re.test(w) && re2.test(w)) {
      re = /.$/;
      w = w.replace(re,"");
    }
    // and turn initial Y back to y
    if (firstch == "y")
      w = firstch.toLowerCase() + w.substr(1);
    return w;
  }
 }
 var splitChars = (function() {
    var result = {};
    var singles = [96, 180, 187, 191, 215, 247, 749, 885, 903, 907, 909, 930, 1014, 1648,
         1748, 1809, 2416, 2473, 2481, 2526, 2601, 2609, 2612, 2615, 2653, 2702,
         2706, 2729, 2737, 2740, 2857, 2865, 2868, 2910, 2928, 2948, 2961, 2971,
         2973, 3085, 3089, 3113, 3124, 3213, 3217, 3241, 3252, 3295, 3341, 3345,
         3369, 3506, 3516, 3633, 3715, 3721, 3736, 3744, 3748, 3750, 3756, 3761,
         3781, 3912, 4239, 4347, 4681, 4695, 4697, 4745, 4785, 4799, 4801, 4823,
         4881, 5760, 5901, 5997, 6313, 7405, 8024, 8026, 8028, 8030, 8117, 8125,
         8133, 8181, 8468, 8485, 8487, 8489, 8494, 8527, 11311, 11359, 11687, 11695,
         11703, 11711, 11719, 11727, 11735, 12448, 12539, 43010, 43014, 43019, 43587,
         43696, 43713, 64286, 64297, 64311, 64317, 64319, 64322, 64325, 65141];
    var i, j, start, end;
    for (i = 0; i < singles.length; i++) {
        result[singles[i]] = true;
    }
    var ranges = [[0, 47], [58, 64], [91, 94], [123, 169], [171, 177], [182, 184], [706, 709],
         [722, 735], [741, 747], [751, 879], [888, 889], [894, 901], [1154, 1161],
         [1318, 1328], [1367, 1368], [1370, 1376], [1416, 1487], [1515, 1519], [1523, 1568],
         [1611, 1631], [1642, 1645], [1750, 1764], [1767, 1773], [1789, 1790], [1792, 1807],
         [1840, 1868], [1958, 1968], [1970, 1983], [2027, 2035], [2038, 2041], [2043, 2047],
         [2070, 2073], [2075, 2083], [2085, 2087], [2089, 2307], [2362, 2364], [2366, 2383],
         [2385, 2391], [2402, 2405], [2419, 2424], [2432, 2436], [2445, 2446], [2449, 2450],
         [2483, 2485], [2490, 2492], [2494, 2509], [2511, 2523], [2530, 2533], [2546, 2547],
         [2554, 2564], [2571, 2574], [2577, 2578], [2618, 2648], [2655, 2661], [2672, 2673],
         [2677, 2692], [2746, 2748], [2750, 2767], [2769, 2783], [2786, 2789], [2800, 2820],
         [2829, 2830], [2833, 2834], [2874, 2876], [2878, 2907], [2914, 2917], [2930, 2946],
         [2955, 2957], [2966, 2968], [2976, 2978], [2981, 2983], [2987, 2989], [3002, 3023],
         [3025, 3045], [3059, 3076], [3130, 3132], [3134, 3159], [3162, 3167], [3170, 3173],
         [3184, 3191], [3199, 3204], [3258, 3260], [3262, 3293], [3298, 3301], [3312, 3332],
         [3386, 3388], [3390, 3423], [3426, 3429], [3446, 3449], [3456, 3460], [3479, 3481],
         [3518, 3519], [3527, 3584], [3636, 3647], [3655, 3663], [3674, 3712], [3717, 3718],
         [3723, 3724], [3726, 3731], [3752, 3753], [3764, 3772], [3774, 3775], [3783, 3791],
         [3802, 3803], [3806, 3839], [3841, 3871], [3892, 3903], [3949, 3975], [3980, 4095],
         [4139, 4158], [4170, 4175], [4182, 4185], [4190, 4192], [4194, 4196], [4199, 4205],
         [4209, 4212], [4226, 4237], [4250, 4255], [4294, 4303], [4349, 4351], [4686, 4687],
         [4702, 4703], [4750, 4751], [4790, 4791], [4806, 4807], [4886, 4887], [4955, 4968],
         [4989, 4991], [5008, 5023], [5109, 5120], [5741, 5742], [5787, 5791], [5867, 5869],
         [5873, 5887], [5906, 5919], [5938, 5951], [5970, 5983], [6001, 6015], [6068, 6102],
         [6104, 6107], [6109, 6111], [6122, 6127], [6138, 6159], [6170, 6175], [6264, 6271],
         [6315, 6319], [6390, 6399], [6429, 6469], [6510, 6511], [6517, 6527], [6572, 6592],
         [6600, 6607], [6619, 6655], [6679, 6687], [6741, 6783], [6794, 6799], [6810, 6822],
         [6824, 6916], [6964, 6980], [6988, 6991], [7002, 7042], [7073, 7085], [7098, 7167],
         [7204, 7231], [7242, 7244], [7294, 7400], [7410, 7423], [7616, 7679], [7958, 7959],
         [7966, 7967], [8006, 8007], [8014, 8015], [8062, 8063], [8127, 8129], [8141, 8143],
         [8148, 8149], [8156, 8159], [8173, 8177], [8189, 8303], [8306, 8307], [8314, 8318],
         [8330, 8335], [8341, 8449], [8451, 8454], [8456, 8457], [8470, 8472], [8478, 8483],
         [8506, 8507], [8512, 8516], [8522, 8525], [8586, 9311], [9372, 9449], [9472, 10101],
         [10132, 11263], [11493, 11498], [11503, 11516], [11518, 11519], [11558, 11567],
         [11622, 11630], [11632, 11647], [11671, 11679], [11743, 11822], [11824, 12292],
         [12296, 12320], [12330, 12336], [12342, 12343], [12349, 12352], [12439, 12444],
         [12544, 12548], [12590, 12592], [12687, 12689], [12694, 12703], [12728, 12783],
         [12800, 12831], [12842, 12880], [12896, 12927], [12938, 12976], [12992, 13311],
         [19894, 19967], [40908, 40959], [42125, 42191], [42238, 42239], [42509, 42511],
         [42540, 42559], [42592, 42593], [42607, 42622], [42648, 42655], [42736, 42774],
         [42784, 42785], [42889, 42890], [42893, 43002], [43043, 43055], [43062, 43071],
         [43124, 43137], [43188, 43215], [43226, 43249], [43256, 43258], [43260, 43263],
         [43302, 43311], [43335, 43359], [43389, 43395], [43443, 43470], [43482, 43519],
         [43561, 43583], [43596, 43599], [43610, 43615], [43639, 43641], [43643, 43647],
         [43698, 43700], [43703, 43704], [43710, 43711], [43715, 43738], [43742, 43967],
         [44003, 44015], [44026, 44031], [55204, 55215], [55239, 55242], [55292, 55295],
         [57344, 63743], [64046, 64047], [64110, 64111], [64218, 64255], [64263, 64274],
         [64280, 64284], [64434, 64466], [64830, 64847], [64912, 64913], [64968, 65007],
         [65020, 65135], [65277, 65295], [65306, 65312], [65339, 65344], [65371, 65381],
         [65471, 65473], [65480, 65481], [65488, 65489], [65496, 65497]];
    for (i = 0; i < ranges.length; i++) {
        start = ranges[i][0];
        end = ranges[i][1];
        for (j = start; j <= end; j++) {
            result[j] = true;
        }
    }
    return result;
 })();
 function splitQuery(query) {
    var result = [];
    var start = -1;
    for (var i = 0; i < query.length; i++) {
        if (splitChars[query.charCodeAt(i)]) {
            if (start !== -1) {
                result.push(query.slice(start, i));
                start = -1;
            }
        } else if (start === -1) {
            start = i;
        }
    }
    if (start !== -1) {
        result.push(query.slice(start));
    }
    return result;
 }
--- a/0.2/_static/minus.png
+++ b/0.2/_static/minus.png
--- a/0.2/_static/plus.png
+++ b/0.2/_static/plus.png
--- a/0.2/_static/pygments.css
+++ b/0.2/_static/pygments.css
@ -0,0 +1,82 @@
 pre { line-height: 125%; }
 td.linenos pre { color: #000000; background-color: #f0f0f0; padding-left: 5px; padding-right: 5px; }
 span.linenos { color: #000000; background-color: #f0f0f0; padding-left: 5px; padding-right: 5px; }
 td.linenos pre.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
 span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
 .highlight .hll { background-color: #ffffcc }
 .highlight { background: #f8f8f8; }
 .highlight .c { color: #8f5902; font-style: italic } /* Comment */
 .highlight .err { color: #a40000; border: 1px solid #ef2929 } /* Error */
 .highlight .g { color: #000000 } /* Generic */
 .highlight .k { color: #204a87; font-weight: bold } /* Keyword */
 .highlight .l { color: #000000 } /* Literal */
 .highlight .n { color: #000000 } /* Name */
 .highlight .o { color: #ce5c00; font-weight: bold } /* Operator */
 .highlight .x { color: #000000 } /* Other */
 .highlight .p { color: #000000; font-weight: bold } /* Punctuation */
 .highlight .ch { color: #8f5902; font-style: italic } /* Comment.Hashbang */
 .highlight .cm { color: #8f5902; font-style: italic } /* Comment.Multiline */
 .highlight .cp { color: #8f5902; font-style: italic } /* Comment.Preproc */
 .highlight .cpf { color: #8f5902; font-style: italic } /* Comment.PreprocFile */
 .highlight .c1 { color: #8f5902; font-style: italic } /* Comment.Single */
 .highlight .cs { color: #8f5902; font-style: italic } /* Comment.Special */
 .highlight .gd { color: #a40000 } /* Generic.Deleted */
 .highlight .ge { color: #000000; font-style: italic } /* Generic.Emph */
 .highlight .gr { color: #ef2929 } /* Generic.Error */
 .highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
 .highlight .gi { color: #00A000 } /* Generic.Inserted */
 .highlight .go { color: #000000; font-style: italic } /* Generic.Output */
 .highlight .gp { color: #8f5902 } /* Generic.Prompt */
 .highlight .gs { color: #000000; font-weight: bold } /* Generic.Strong */
 .highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
 .highlight .gt { color: #a40000; font-weight: bold } /* Generic.Traceback */
 .highlight .kc { color: #204a87; font-weight: bold } /* Keyword.Constant */
 .highlight .kd { color: #204a87; font-weight: bold } /* Keyword.Declaration */
 .highlight .kn { color: #204a87; font-weight: bold } /* Keyword.Namespace */
 .highlight .kp { color: #204a87; font-weight: bold } /* Keyword.Pseudo */
 .highlight .kr { color: #204a87; font-weight: bold } /* Keyword.Reserved */
 .highlight .kt { color: #204a87; font-weight: bold } /* Keyword.Type */
 .highlight .ld { color: #000000 } /* Literal.Date */
 .highlight .m { color: #0000cf; font-weight: bold } /* Literal.Number */
 .highlight .s { color: #4e9a06 } /* Literal.String */
 .highlight .na { color: #c4a000 } /* Name.Attribute */
 .highlight .nb { color: #204a87 } /* Name.Builtin */
 .highlight .nc { color: #000000 } /* Name.Class */
 .highlight .no { color: #000000 } /* Name.Constant */
 .highlight .nd { color: #5c35cc; font-weight: bold } /* Name.Decorator */
 .highlight .ni { color: #ce5c00 } /* Name.Entity */
 .highlight .ne { color: #cc0000; font-weight: bold } /* Name.Exception */
 .highlight .nf { color: #000000 } /* Name.Function */
 .highlight .nl { color: #f57900 } /* Name.Label */
 .highlight .nn { color: #000000 } /* Name.Namespace */
 .highlight .nx { color: #000000 } /* Name.Other */
 .highlight .py { color: #000000 } /* Name.Property */
 .highlight .nt { color: #204a87; font-weight: bold } /* Name.Tag */
 .highlight .nv { color: #000000 } /* Name.Variable */
 .highlight .ow { color: #204a87; font-weight: bold } /* Operator.Word */
 .highlight .w { color: #f8f8f8; text-decoration: underline } /* Text.Whitespace */
 .highlight .mb { color: #0000cf; font-weight: bold } /* Literal.Number.Bin */
 .highlight .mf { color: #0000cf; font-weight: bold } /* Literal.Number.Float */
 .highlight .mh { color: #0000cf; font-weight: bold } /* Literal.Number.Hex */
 .highlight .mi { color: #0000cf; font-weight: bold } /* Literal.Number.Integer */
 .highlight .mo { color: #0000cf; font-weight: bold } /* Literal.Number.Oct */
 .highlight .sa { color: #4e9a06 } /* Literal.String.Affix */
 .highlight .sb { color: #4e9a06 } /* Literal.String.Backtick */
 .highlight .sc { color: #4e9a06 } /* Literal.String.Char */
 .highlight .dl { color: #4e9a06 } /* Literal.String.Delimiter */
 .highlight .sd { color: #8f5902; font-style: italic } /* Literal.String.Doc */
 .highlight .s2 { color: #4e9a06 } /* Literal.String.Double */
 .highlight .se { color: #4e9a06 } /* Literal.String.Escape */
 .highlight .sh { color: #4e9a06 } /* Literal.String.Heredoc */
 .highlight .si { color: #4e9a06 } /* Literal.String.Interpol */
 .highlight .sx { color: #4e9a06 } /* Literal.String.Other */
 .highlight .sr { color: #4e9a06 } /* Literal.String.Regex */
 .highlight .s1 { color: #4e9a06 } /* Literal.String.Single */
 .highlight .ss { color: #4e9a06 } /* Literal.String.Symbol */
 .highlight .bp { color: #3465a4 } /* Name.Builtin.Pseudo */
 .highlight .fm { color: #000000 } /* Name.Function.Magic */
 .highlight .vc { color: #000000 } /* Name.Variable.Class */
 .highlight .vg { color: #000000 } /* Name.Variable.Global */
 .highlight .vi { color: #000000 } /* Name.Variable.Instance */
 .highlight .vm { color: #000000 } /* Name.Variable.Magic */
 .highlight .il { color: #0000cf; font-weight: bold } /* Literal.Number.Integer.Long */
--- a/0.2/_static/searchtools.js
+++ b/0.2/_static/searchtools.js
@ -0,0 +1,514 @@
 /*
 * searchtools.js
 * ~~~~~~~~~~~~~~~~
 *
 * Sphinx JavaScript utilities for the full-text search.
 *
 * :copyright: Copyright 2007-2021 by the Sphinx team, see AUTHORS.
 * :license: BSD, see LICENSE for details.
 *
 */
 if (!Scorer) {
  /**
   * Simple result scoring code.
   */
  var Scorer = {
    // Implement the following function to further tweak the score for each result
    // The function takes a result array [filename, title, anchor, descr, score]
    // and returns the new score.
    /*
    score: function(result) {
      return result[4];
    },
    */
    // query matches the full name of an object
    objNameMatch: 11,
    // or matches in the last dotted part of the object name
    objPartialMatch: 6,
    // Additive scores depending on the priority of the object
    objPrio: {0:  15,   // used to be importantResults
              1:  5,   // used to be objectResults
              2: -5},  // used to be unimportantResults
    //  Used when the priority is not in the mapping.
    objPrioDefault: 0,
    // query found in title
    title: 15,
    partialTitle: 7,
    // query found in terms
    term: 5,
    partialTerm: 2
  };
 }
 if (!splitQuery) {
  function splitQuery(query) {
    return query.split(/\s+/);
  }
 }
 /**
 * Search Module
 */
 var Search = {
  _index : null,
  _queued_query : null,
  _pulse_status : -1,
  htmlToText : function(htmlString) {
      var virtualDocument = document.implementation.createHTMLDocument('virtual');
      var htmlElement = $(htmlString, virtualDocument);
      htmlElement.find('.headerlink').remove();
      docContent = htmlElement.find('[role=main]')[0];
      if(docContent === undefined) {
          console.warn("Content block not found. Sphinx search tries to obtain it " +
                       "via '[role=main]'. Could you check your theme or template.");
          return "";
      }
      return docContent.textContent || docContent.innerText;
  },
  init : function() {
      var params = $.getQueryParameters();
      if (params.q) {
          var query = params.q[0];
          $('input[name="q"]')[0].value = query;
          this.performSearch(query);
      }
  },
  loadIndex : function(url) {
    $.ajax({type: "GET", url: url, data: null,
            dataType: "script", cache: true,
            complete: function(jqxhr, textstatus) {
              if (textstatus != "success") {
                document.getElementById("searchindexloader").src = url;
              }
            }});
  },
  setIndex : function(index) {
    var q;
    this._index = index;
    if ((q = this._queued_query) !== null) {
      this._queued_query = null;
      Search.query(q);
    }
  },
  hasIndex : function() {
      return this._index !== null;
  },
  deferQuery : function(query) {
      this._queued_query = query;
  },
  stopPulse : function() {
      this._pulse_status = 0;
  },
  startPulse : function() {
    if (this._pulse_status >= 0)
        return;
    function pulse() {
      var i;
      Search._pulse_status = (Search._pulse_status + 1) % 4;
      var dotString = '';
      for (i = 0; i < Search._pulse_status; i++)
        dotString += '.';
      Search.dots.text(dotString);
      if (Search._pulse_status > -1)
        window.setTimeout(pulse, 500);
    }
    pulse();
  },
  /**
   * perform a search for something (or wait until index is loaded)
   */
  performSearch : function(query) {
    // create the required interface elements
    this.out = $('#search-results');
    this.title = $('<h2>' + _('Searching') + '</h2>').appendTo(this.out);
    this.dots = $('<span></span>').appendTo(this.title);
    this.status = $('<p class="search-summary">&nbsp;</p>').appendTo(this.out);
    this.output = $('<ul class="search"/>').appendTo(this.out);
    $('#search-progress').text(_('Preparing search...'));
    this.startPulse();
    // index already loaded, the browser was quick!
    if (this.hasIndex())
      this.query(query);
    else
      this.deferQuery(query);
  },
  /**
   * execute search (requires search index to be loaded)
   */
  query : function(query) {
    var i;
    // stem the searchterms and add them to the correct list
    var stemmer = new Stemmer();
    var searchterms = [];
    var excluded = [];
    var hlterms = [];
    var tmp = splitQuery(query);
    var objectterms = [];
    for (i = 0; i < tmp.length; i++) {
      if (tmp[i] !== "") {
          objectterms.push(tmp[i].toLowerCase());
      }
      if ($u.indexOf(stopwords, tmp[i].toLowerCase()) != -1 || tmp[i] === "") {
        // skip this "word"
        continue;
      }
      // stem the word
      var word = stemmer.stemWord(tmp[i].toLowerCase());
      // prevent stemmer from cutting word smaller than two chars
      if(word.length < 3 && tmp[i].length >= 3) {
        word = tmp[i];
      }
      var toAppend;
      // select the correct list
      if (word[0] == '-') {
        toAppend = excluded;
        word = word.substr(1);
      }
      else {
        toAppend = searchterms;
        hlterms.push(tmp[i].toLowerCase());
      }
      // only add if not already in the list
      if (!$u.contains(toAppend, word))
        toAppend.push(word);
    }
    var highlightstring = '?highlight=' + $.urlencode(hlterms.join(" "));
    // console.debug('SEARCH: searching for:');
    // console.info('required: ', searchterms);
    // console.info('excluded: ', excluded);
    // prepare search
    var terms = this._index.terms;
    var titleterms = this._index.titleterms;
    // array of [filename, title, anchor, descr, score]
    var results = [];
    $('#search-progress').empty();
    // lookup as object
    for (i = 0; i < objectterms.length; i++) {
      var others = [].concat(objectterms.slice(0, i),
                             objectterms.slice(i+1, objectterms.length));
      results = results.concat(this.performObjectSearch(objectterms[i], others));
    }
    // lookup as search terms in fulltext
    results = results.concat(this.performTermsSearch(searchterms, excluded, terms, titleterms));
    // let the scorer override scores with a custom scoring function
    if (Scorer.score) {
      for (i = 0; i < results.length; i++)
        results[i][4] = Scorer.score(results[i]);
    }
    // now sort the results by score (in opposite order of appearance, since the
    // display function below uses pop() to retrieve items) and then
    // alphabetically
    results.sort(function(a, b) {
      var left = a[4];
      var right = b[4];
      if (left > right) {
        return 1;
      } else if (left < right) {
        return -1;
      } else {
        // same score: sort alphabetically
        left = a[1].toLowerCase();
        right = b[1].toLowerCase();
        return (left > right) ? -1 : ((left < right) ? 1 : 0);
      }
    });
    // for debugging
    //Search.lastresults = results.slice();  // a copy
    //console.info('search results:', Search.lastresults);
    // print the results
    var resultCount = results.length;
    function displayNextItem() {
      // results left, load the summary and display it
      if (results.length) {
        var item = results.pop();
        var listItem = $('<li style="display:none"></li>');
        var requestUrl = "";
        var linkUrl = "";
        if (DOCUMENTATION_OPTIONS.BUILDER === 'dirhtml') {
          // dirhtml builder
          var dirname = item[0] + '/';
          if (dirname.match(/\/index\/$/)) {
            dirname = dirname.substring(0, dirname.length-6);
          } else if (dirname == 'index/') {
            dirname = '';
          }
          requestUrl = DOCUMENTATION_OPTIONS.URL_ROOT + dirname;
          linkUrl = requestUrl;
        } else {
          // normal html builders
          requestUrl = DOCUMENTATION_OPTIONS.URL_ROOT + item[0] + DOCUMENTATION_OPTIONS.FILE_SUFFIX;
          linkUrl = item[0] + DOCUMENTATION_OPTIONS.LINK_SUFFIX;
        }
        listItem.append($('<a/>').attr('href',
            linkUrl +
            highlightstring + item[2]).html(item[1]));
        if (item[3]) {
          listItem.append($('<span> (' + item[3] + ')</span>'));
          Search.output.append(listItem);
          listItem.slideDown(5, function() {
            displayNextItem();
          });
        } else if (DOCUMENTATION_OPTIONS.HAS_SOURCE) {
          $.ajax({url: requestUrl,
                  dataType: "text",
                  complete: function(jqxhr, textstatus) {
                    var data = jqxhr.responseText;
                    if (data !== '' && data !== undefined) {
                      listItem.append(Search.makeSearchSummary(data, searchterms, hlterms));
                    }
                    Search.output.append(listItem);
                    listItem.slideDown(5, function() {
                      displayNextItem();
                    });
                  }});
        } else {
          // no source available, just display title
          Search.output.append(listItem);
          listItem.slideDown(5, function() {
            displayNextItem();
          });
        }
      }
      // search finished, update title and status message
      else {
        Search.stopPulse();
        Search.title.text(_('Search Results'));
        if (!resultCount)
          Search.status.text(_('Your search did not match any documents. Please make sure that all words are spelled correctly and that you\'ve selected enough categories.'));
        else
            Search.status.text(_('Search finished, found %s page(s) matching the search query.').replace('%s', resultCount));
        Search.status.fadeIn(500);
      }
    }
    displayNextItem();
  },
  /**
   * search for object names
   */
  performObjectSearch : function(object, otherterms) {
    var filenames = this._index.filenames;
    var docnames = this._index.docnames;
    var objects = this._index.objects;
    var objnames = this._index.objnames;
    var titles = this._index.titles;
    var i;
    var results = [];
    for (var prefix in objects) {
      for (var name in objects[prefix]) {
        var fullname = (prefix ? prefix + '.' : '') + name;
        var fullnameLower = fullname.toLowerCase()
        if (fullnameLower.indexOf(object) > -1) {
          var score = 0;
          var parts = fullnameLower.split('.');
          // check for different match types: exact matches of full name or
          // "last name" (i.e. last dotted part)
          if (fullnameLower == object || parts[parts.length - 1] == object) {
            score += Scorer.objNameMatch;
          // matches in last name
          } else if (parts[parts.length - 1].indexOf(object) > -1) {
            score += Scorer.objPartialMatch;
          }
          var match = objects[prefix][name];
          var objname = objnames[match[1]][2];
          var title = titles[match[0]];
          // If more than one term searched for, we require other words to be
          // found in the name/title/description
          if (otherterms.length > 0) {
            var haystack = (prefix + ' ' + name + ' ' +
                            objname + ' ' + title).toLowerCase();
            var allfound = true;
            for (i = 0; i < otherterms.length; i++) {
              if (haystack.indexOf(otherterms[i]) == -1) {
                allfound = false;
                break;
              }
            }
            if (!allfound) {
              continue;
            }
          }
          var descr = objname + _(', in ') + title;
          var anchor = match[3];
          if (anchor === '')
            anchor = fullname;
          else if (anchor == '-')
            anchor = objnames[match[1]][1] + '-' + fullname;
          // add custom score for some objects according to scorer
          if (Scorer.objPrio.hasOwnProperty(match[2])) {
            score += Scorer.objPrio[match[2]];
          } else {
            score += Scorer.objPrioDefault;
          }
          results.push([docnames[match[0]], fullname, '#'+anchor, descr, score, filenames[match[0]]]);
        }
      }
    }
    return results;
  },
  /**
   * search for full-text terms in the index
   */
  performTermsSearch : function(searchterms, excluded, terms, titleterms) {
    var docnames = this._index.docnames;
    var filenames = this._index.filenames;
    var titles = this._index.titles;
    var i, j, file;
    var fileMap = {};
    var scoreMap = {};
    var results = [];
    // perform the search on the required terms
    for (i = 0; i < searchterms.length; i++) {
      var word = searchterms[i];
      var files = [];
      var _o = [
        {files: terms[word], score: Scorer.term},
        {files: titleterms[word], score: Scorer.title}
      ];
      // add support for partial matches
      if (word.length > 2) {
        for (var w in terms) {
          if (w.match(word) && !terms[word]) {
            _o.push({files: terms[w], score: Scorer.partialTerm})
          }
        }
        for (var w in titleterms) {
          if (w.match(word) && !titleterms[word]) {
              _o.push({files: titleterms[w], score: Scorer.partialTitle})
          }
        }
      }
      // no match but word was a required one
      if ($u.every(_o, function(o){return o.files === undefined;})) {
        break;
      }
      // found search word in contents
      $u.each(_o, function(o) {
        var _files = o.files;
        if (_files === undefined)
          return
        if (_files.length === undefined)
          _files = [_files];
        files = files.concat(_files);
        // set score for the word in each file to Scorer.term
        for (j = 0; j < _files.length; j++) {
          file = _files[j];
          if (!(file in scoreMap))
            scoreMap[file] = {};
          scoreMap[file][word] = o.score;
        }
      });
      // create the mapping
      for (j = 0; j < files.length; j++) {
        file = files[j];
        if (file in fileMap && fileMap[file].indexOf(word) === -1)
          fileMap[file].push(word);
        else
          fileMap[file] = [word];
      }
    }
    // now check if the files don't contain excluded terms
    for (file in fileMap) {
      var valid = true;
      // check if all requirements are matched
      var filteredTermCount = // as search terms with length < 3 are discarded: ignore
        searchterms.filter(function(term){return term.length > 2}).length
      if (
        fileMap[file].length != searchterms.length &&
        fileMap[file].length != filteredTermCount
      ) continue;
      // ensure that none of the excluded terms is in the search result
      for (i = 0; i < excluded.length; i++) {
        if (terms[excluded[i]] == file ||
            titleterms[excluded[i]] == file ||
            $u.contains(terms[excluded[i]] || [], file) ||
            $u.contains(titleterms[excluded[i]] || [], file)) {
          valid = false;
          break;
        }
      }
      // if we have still a valid result we can add it to the result list
      if (valid) {
        // select one (max) score for the file.
        // for better ranking, we should calculate ranking by using words statistics like basic tf-idf...
        var score = $u.max($u.map(fileMap[file], function(w){return scoreMap[file][w]}));
        results.push([docnames[file], titles[file], '', null, score, filenames[file]]);
      }
    }
    return results;
  },
  /**
   * helper function to return a node containing the
   * search summary for a given text. keywords is a list
   * of stemmed words, hlwords is the list of normal, unstemmed
   * words. the first one is used to find the occurrence, the
   * latter for highlighting it.
   */
  makeSearchSummary : function(htmlText, keywords, hlwords) {
    var text = Search.htmlToText(htmlText);
    var textLower = text.toLowerCase();
    var start = 0;
    $.each(keywords, function() {
      var i = textLower.indexOf(this.toLowerCase());
      if (i > -1)
        start = i;
    });
    start = Math.max(start - 120, 0);
    var excerpt = ((start > 0) ? '...' : '') +
      $.trim(text.substr(start, 240)) +
      ((start + 240 - text.length) ? '...' : '');
    var rv = $('<div class="context"></div>').text(excerpt);
    $.each(hlwords, function() {
      rv = rv.highlightText(this, 'highlighted');
    });
    return rv;
  }
 };
 $(document).ready(function() {
  Search.init();
 });
--- a/0.2/_static/sphinx-book-theme.12a9622fbb08dcb3a2a40b2c02b83a57.js
+++ b/0.2/_static/sphinx-book-theme.12a9622fbb08dcb3a2a40b2c02b83a57.js
@ -0,0 +1,18 @@
 var initTriggerNavBar=()=>{if($(window).width()<768){$("#navbar-toggler").trigger("click")}}
 var scrollToActive=()=>{var navbar=document.getElementById('site-navigation')
 var active_pages=navbar.querySelectorAll(".active")
 var active_page=active_pages[active_pages.length-1]
 if(active_page!==undefined&&active_page.offsetTop>($(window).height()*.5)){navbar.scrollTop=active_page.offsetTop-($(window).height()*.2)}}
 var sbRunWhenDOMLoaded=cb=>{if(document.readyState!='loading'){cb()}else if(document.addEventListener){document.addEventListener('DOMContentLoaded',cb)}else{document.attachEvent('onreadystatechange',function(){if(document.readyState=='complete')cb()})}}
 function toggleFullScreen(){var navToggler=$("#navbar-toggler");if(!document.fullscreenElement){document.documentElement.requestFullscreen();if(!navToggler.hasClass("collapsed")){navToggler.click();}}else{if(document.exitFullscreen){document.exitFullscreen();if(navToggler.hasClass("collapsed")){navToggler.click();}}}}
 var initTooltips=()=>{$(document).ready(function(){$('[data-toggle="tooltip"]').tooltip();});}
 var initTocHide=()=>{var scrollTimeout;var throttle=200;var tocHeight=$("#bd-toc-nav").outerHeight(true)+$(".bd-toc").outerHeight(true);var hideTocAfter=tocHeight+200;var checkTocScroll=function(){var margin_content=$(".margin, .tag_margin, .full-width, .full_width, .tag_full-width, .tag_full_width, .sidebar, .tag_sidebar, .popout, .tag_popout");margin_content.each((index,item)=>{var topOffset=$(item).offset().top-$(window).scrollTop();var bottomOffset=topOffset+$(item).outerHeight(true);var topOverlaps=((topOffset>=0)&&(topOffset<hideTocAfter));var bottomOverlaps=((bottomOffset>=0)&&(bottomOffset<hideTocAfter));var removeToc=(topOverlaps||bottomOverlaps);if(removeToc&&window.pageYOffset>20){$("div.bd-toc").removeClass("show")
 return false}else{$("div.bd-toc").addClass("show")};})};var manageScrolledClassOnBody=function(){if(window.scrollY>0){document.body.classList.add("scrolled");}else{document.body.classList.remove("scrolled");}}
 $(window).on('scroll',function(){if(!scrollTimeout){scrollTimeout=setTimeout(function(){checkTocScroll();manageScrolledClassOnBody();scrollTimeout=null;},throttle);}});}
 var initThebeSBT=()=>{var title=$("div.section h1")[0]
 if(!$(title).next().hasClass("thebe-launch-button")){$("<button class='thebe-launch-button'></button>").insertAfter($(title))}
 initThebe();}
 sbRunWhenDOMLoaded(initTooltips)
 sbRunWhenDOMLoaded(initTriggerNavBar)
 sbRunWhenDOMLoaded(scrollToActive)
 sbRunWhenDOMLoaded(initTocHide)
--- a/0.2/_static/sphinx-book-theme.acff12b8f9c144ce68a297486a2fa670.css
+++ b/0.2/_static/sphinx-book-theme.acff12b8f9c144ce68a297486a2fa670.css
--- a/0.2/_static/sphinx-book-theme.css
+++ b/0.2/_static/sphinx-book-theme.css
--- a/0.2/_static/underscore-1.3.1.js
+++ b/0.2/_static/underscore-1.3.1.js
@ -0,0 +1,999 @@
 //     Underscore.js 1.3.1
 //     (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
 //     Underscore is freely distributable under the MIT license.
 //     Portions of Underscore are inspired or borrowed from Prototype,
 //     Oliver Steele's Functional, and John Resig's Micro-Templating.
 //     For all details and documentation:
 //     http://documentcloud.github.com/underscore
 (function() {
  // Baseline setup
  // --------------
  // Establish the root object, `window` in the browser, or `global` on the server.
  var root = this;
  // Save the previous value of the `_` variable.
  var previousUnderscore = root._;
  // Establish the object that gets returned to break out of a loop iteration.
  var breaker = {};
  // Save bytes in the minified (but not gzipped) version:
  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
  // Create quick reference variables for speed access to core prototypes.
  var slice            = ArrayProto.slice,
      unshift          = ArrayProto.unshift,
      toString         = ObjProto.toString,
      hasOwnProperty   = ObjProto.hasOwnProperty;
  // All **ECMAScript 5** native function implementations that we hope to use
  // are declared here.
  var
    nativeForEach      = ArrayProto.forEach,
    nativeMap          = ArrayProto.map,
    nativeReduce       = ArrayProto.reduce,
    nativeReduceRight  = ArrayProto.reduceRight,
    nativeFilter       = ArrayProto.filter,
    nativeEvery        = ArrayProto.every,
    nativeSome         = ArrayProto.some,
    nativeIndexOf      = ArrayProto.indexOf,
    nativeLastIndexOf  = ArrayProto.lastIndexOf,
    nativeIsArray      = Array.isArray,
    nativeKeys         = Object.keys,
    nativeBind         = FuncProto.bind;
  // Create a safe reference to the Underscore object for use below.
  var _ = function(obj) { return new wrapper(obj); };
  // Export the Underscore object for **Node.js**, with
  // backwards-compatibility for the old `require()` API. If we're in
  // the browser, add `_` as a global object via a string identifier,
  // for Closure Compiler "advanced" mode.
  if (typeof exports !== 'undefined') {
    if (typeof module !== 'undefined' && module.exports) {
      exports = module.exports = _;
    }
    exports._ = _;
  } else {
    root['_'] = _;
  }
  // Current version.
  _.VERSION = '1.3.1';
  // Collection Functions
  // --------------------
  // The cornerstone, an `each` implementation, aka `forEach`.
  // Handles objects with the built-in `forEach`, arrays, and raw objects.
  // Delegates to **ECMAScript 5**'s native `forEach` if available.
  var each = _.each = _.forEach = function(obj, iterator, context) {
    if (obj == null) return;
    if (nativeForEach && obj.forEach === nativeForEach) {
      obj.forEach(iterator, context);
    } else if (obj.length === +obj.length) {
      for (var i = 0, l = obj.length; i < l; i++) {
        if (i in obj && iterator.call(context, obj[i], i, obj) === breaker) return;
      }
    } else {
      for (var key in obj) {
        if (_.has(obj, key)) {
          if (iterator.call(context, obj[key], key, obj) === breaker) return;
        }
      }
    }
  };
  // Return the results of applying the iterator to each element.
  // Delegates to **ECMAScript 5**'s native `map` if available.
  _.map = _.collect = function(obj, iterator, context) {
    var results = [];
    if (obj == null) return results;
    if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
    each(obj, function(value, index, list) {
      results[results.length] = iterator.call(context, value, index, list);
    });
    if (obj.length === +obj.length) results.length = obj.length;
    return results;
  };
  // **Reduce** builds up a single result from a list of values, aka `inject`,
  // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
  _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
    var initial = arguments.length > 2;
    if (obj == null) obj = [];
    if (nativeReduce && obj.reduce === nativeReduce) {
      if (context) iterator = _.bind(iterator, context);
      return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
    }
    each(obj, function(value, index, list) {
      if (!initial) {
        memo = value;
        initial = true;
      } else {
        memo = iterator.call(context, memo, value, index, list);
      }
    });
    if (!initial) throw new TypeError('Reduce of empty array with no initial value');
    return memo;
  };
  // The right-associative version of reduce, also known as `foldr`.
  // Delegates to **ECMAScript 5**'s native `reduceRight` if available.
  _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
    var initial = arguments.length > 2;
    if (obj == null) obj = [];
    if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
      if (context) iterator = _.bind(iterator, context);
      return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
    }
    var reversed = _.toArray(obj).reverse();
    if (context && !initial) iterator = _.bind(iterator, context);
    return initial ? _.reduce(reversed, iterator, memo, context) : _.reduce(reversed, iterator);
  };
  // Return the first value which passes a truth test. Aliased as `detect`.
  _.find = _.detect = function(obj, iterator, context) {
    var result;
    any(obj, function(value, index, list) {
      if (iterator.call(context, value, index, list)) {
        result = value;
        return true;
      }
    });
    return result;
  };
  // Return all the elements that pass a truth test.
  // Delegates to **ECMAScript 5**'s native `filter` if available.
  // Aliased as `select`.
  _.filter = _.select = function(obj, iterator, context) {
    var results = [];
    if (obj == null) return results;
    if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
    each(obj, function(value, index, list) {
      if (iterator.call(context, value, index, list)) results[results.length] = value;
    });
    return results;
  };
  // Return all the elements for which a truth test fails.
  _.reject = function(obj, iterator, context) {
    var results = [];
    if (obj == null) return results;
    each(obj, function(value, index, list) {
      if (!iterator.call(context, value, index, list)) results[results.length] = value;
    });
    return results;
  };
  // Determine whether all of the elements match a truth test.
  // Delegates to **ECMAScript 5**'s native `every` if available.
  // Aliased as `all`.
  _.every = _.all = function(obj, iterator, context) {
    var result = true;
    if (obj == null) return result;
    if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
    each(obj, function(value, index, list) {
      if (!(result = result && iterator.call(context, value, index, list))) return breaker;
    });
    return result;
  };
  // Determine if at least one element in the object matches a truth test.
  // Delegates to **ECMAScript 5**'s native `some` if available.
  // Aliased as `any`.
  var any = _.some = _.any = function(obj, iterator, context) {
    iterator || (iterator = _.identity);
    var result = false;
    if (obj == null) return result;
    if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
    each(obj, function(value, index, list) {
      if (result || (result = iterator.call(context, value, index, list))) return breaker;
    });
    return !!result;
  };
  // Determine if a given value is included in the array or object using `===`.
  // Aliased as `contains`.
  _.include = _.contains = function(obj, target) {
    var found = false;
    if (obj == null) return found;
    if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
    found = any(obj, function(value) {
      return value === target;
    });
    return found;
  };
  // Invoke a method (with arguments) on every item in a collection.
  _.invoke = function(obj, method) {
    var args = slice.call(arguments, 2);
    return _.map(obj, function(value) {
      return (_.isFunction(method) ? method || value : value[method]).apply(value, args);
    });
  };
  // Convenience version of a common use case of `map`: fetching a property.
  _.pluck = function(obj, key) {
    return _.map(obj, function(value){ return value[key]; });
  };
  // Return the maximum element or (element-based computation).
  _.max = function(obj, iterator, context) {
    if (!iterator && _.isArray(obj)) return Math.max.apply(Math, obj);
    if (!iterator && _.isEmpty(obj)) return -Infinity;
    var result = {computed : -Infinity};
    each(obj, function(value, index, list) {
      var computed = iterator ? iterator.call(context, value, index, list) : value;
      computed >= result.computed && (result = {value : value, computed : computed});
    });
    return result.value;
  };
  // Return the minimum element (or element-based computation).
  _.min = function(obj, iterator, context) {
    if (!iterator && _.isArray(obj)) return Math.min.apply(Math, obj);
    if (!iterator && _.isEmpty(obj)) return Infinity;
    var result = {computed : Infinity};
    each(obj, function(value, index, list) {
      var computed = iterator ? iterator.call(context, value, index, list) : value;
      computed < result.computed && (result = {value : value, computed : computed});
    });
    return result.value;
  };
  // Shuffle an array.
  _.shuffle = function(obj) {
    var shuffled = [], rand;
    each(obj, function(value, index, list) {
      if (index == 0) {
        shuffled[0] = value;
      } else {
        rand = Math.floor(Math.random() * (index + 1));
        shuffled[index] = shuffled[rand];
        shuffled[rand] = value;
      }
    });
    return shuffled;
  };
  // Sort the object's values by a criterion produced by an iterator.
  _.sortBy = function(obj, iterator, context) {
    return _.pluck(_.map(obj, function(value, index, list) {
      return {
        value : value,
        criteria : iterator.call(context, value, index, list)
      };
    }).sort(function(left, right) {
      var a = left.criteria, b = right.criteria;
      return a < b ? -1 : a > b ? 1 : 0;
    }), 'value');
  };
  // Groups the object's values by a criterion. Pass either a string attribute
  // to group by, or a function that returns the criterion.
  _.groupBy = function(obj, val) {
    var result = {};
    var iterator = _.isFunction(val) ? val : function(obj) { return obj[val]; };
    each(obj, function(value, index) {
      var key = iterator(value, index);
      (result[key] || (result[key] = [])).push(value);
    });
    return result;
  };
  // Use a comparator function to figure out at what index an object should
  // be inserted so as to maintain order. Uses binary search.
  _.sortedIndex = function(array, obj, iterator) {
    iterator || (iterator = _.identity);
    var low = 0, high = array.length;
    while (low < high) {
      var mid = (low + high) >> 1;
      iterator(array[mid]) < iterator(obj) ? low = mid + 1 : high = mid;
    }
    return low;
  };
  // Safely convert anything iterable into a real, live array.
  _.toArray = function(iterable) {
    if (!iterable)                return [];
    if (iterable.toArray)         return iterable.toArray();
    if (_.isArray(iterable))      return slice.call(iterable);
    if (_.isArguments(iterable))  return slice.call(iterable);
    return _.values(iterable);
  };
  // Return the number of elements in an object.
  _.size = function(obj) {
    return _.toArray(obj).length;
  };
  // Array Functions
  // ---------------
  // Get the first element of an array. Passing **n** will return the first N
  // values in the array. Aliased as `head`. The **guard** check allows it to work
  // with `_.map`.
  _.first = _.head = function(array, n, guard) {
    return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
  };
  // Returns everything but the last entry of the array. Especcialy useful on
  // the arguments object. Passing **n** will return all the values in
  // the array, excluding the last N. The **guard** check allows it to work with
  // `_.map`.
  _.initial = function(array, n, guard) {
    return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
  };
  // Get the last element of an array. Passing **n** will return the last N
  // values in the array. The **guard** check allows it to work with `_.map`.
  _.last = function(array, n, guard) {
    if ((n != null) && !guard) {
      return slice.call(array, Math.max(array.length - n, 0));
    } else {
      return array[array.length - 1];
    }
  };
  // Returns everything but the first entry of the array. Aliased as `tail`.
  // Especially useful on the arguments object. Passing an **index** will return
  // the rest of the values in the array from that index onward. The **guard**
  // check allows it to work with `_.map`.
  _.rest = _.tail = function(array, index, guard) {
    return slice.call(array, (index == null) || guard ? 1 : index);
  };
  // Trim out all falsy values from an array.
  _.compact = function(array) {
    return _.filter(array, function(value){ return !!value; });
  };
  // Return a completely flattened version of an array.
  _.flatten = function(array, shallow) {
    return _.reduce(array, function(memo, value) {
      if (_.isArray(value)) return memo.concat(shallow ? value : _.flatten(value));
      memo[memo.length] = value;
      return memo;
    }, []);
  };
  // Return a version of the array that does not contain the specified value(s).
  _.without = function(array) {
    return _.difference(array, slice.call(arguments, 1));
  };
  // Produce a duplicate-free version of the array. If the array has already
  // been sorted, you have the option of using a faster algorithm.
  // Aliased as `unique`.
  _.uniq = _.unique = function(array, isSorted, iterator) {
    var initial = iterator ? _.map(array, iterator) : array;
    var result = [];
    _.reduce(initial, function(memo, el, i) {
      if (0 == i || (isSorted === true ? _.last(memo) != el : !_.include(memo, el))) {
        memo[memo.length] = el;
        result[result.length] = array[i];
      }
      return memo;
    }, []);
    return result;
  };
  // Produce an array that contains the union: each distinct element from all of
  // the passed-in arrays.
  _.union = function() {
    return _.uniq(_.flatten(arguments, true));
  };
  // Produce an array that contains every item shared between all the
  // passed-in arrays. (Aliased as "intersect" for back-compat.)
  _.intersection = _.intersect = function(array) {
    var rest = slice.call(arguments, 1);
    return _.filter(_.uniq(array), function(item) {
      return _.every(rest, function(other) {
        return _.indexOf(other, item) >= 0;
      });
    });
  };
  // Take the difference between one array and a number of other arrays.
  // Only the elements present in just the first array will remain.
  _.difference = function(array) {
    var rest = _.flatten(slice.call(arguments, 1));
    return _.filter(array, function(value){ return !_.include(rest, value); });
  };
  // Zip together multiple lists into a single array -- elements that share
  // an index go together.
  _.zip = function() {
    var args = slice.call(arguments);
    var length = _.max(_.pluck(args, 'length'));
    var results = new Array(length);
    for (var i = 0; i < length; i++) results[i] = _.pluck(args, "" + i);
    return results;
  };
  // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
  // we need this function. Return the position of the first occurrence of an
  // item in an array, or -1 if the item is not included in the array.
  // Delegates to **ECMAScript 5**'s native `indexOf` if available.
  // If the array is large and already in sort order, pass `true`
  // for **isSorted** to use binary search.
  _.indexOf = function(array, item, isSorted) {
    if (array == null) return -1;
    var i, l;
    if (isSorted) {
      i = _.sortedIndex(array, item);
      return array[i] === item ? i : -1;
    }
    if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item);
    for (i = 0, l = array.length; i < l; i++) if (i in array && array[i] === item) return i;
    return -1;
  };
  // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
  _.lastIndexOf = function(array, item) {
    if (array == null) return -1;
    if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) return array.lastIndexOf(item);
    var i = array.length;
    while (i--) if (i in array && array[i] === item) return i;
    return -1;
  };
  // Generate an integer Array containing an arithmetic progression. A port of
  // the native Python `range()` function. See
  // [the Python documentation](http://docs.python.org/library/functions.html#range).
  _.range = function(start, stop, step) {
    if (arguments.length <= 1) {
      stop = start || 0;
      start = 0;
    }
    step = arguments[2] || 1;
    var len = Math.max(Math.ceil((stop - start) / step), 0);
    var idx = 0;
    var range = new Array(len);
    while(idx < len) {
      range[idx++] = start;
      start += step;
    }
    return range;
  };
  // Function (ahem) Functions
  // ------------------
  // Reusable constructor function for prototype setting.
  var ctor = function(){};
  // Create a function bound to a given object (assigning `this`, and arguments,
  // optionally). Binding with arguments is also known as `curry`.
  // Delegates to **ECMAScript 5**'s native `Function.bind` if available.
  // We check for `func.bind` first, to fail fast when `func` is undefined.
  _.bind = function bind(func, context) {
    var bound, args;
    if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
    if (!_.isFunction(func)) throw new TypeError;
    args = slice.call(arguments, 2);
    return bound = function() {
      if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
      ctor.prototype = func.prototype;
      var self = new ctor;
      var result = func.apply(self, args.concat(slice.call(arguments)));
      if (Object(result) === result) return result;
      return self;
    };
  };
  // Bind all of an object's methods to that object. Useful for ensuring that
  // all callbacks defined on an object belong to it.
  _.bindAll = function(obj) {
    var funcs = slice.call(arguments, 1);
    if (funcs.length == 0) funcs = _.functions(obj);
    each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
    return obj;
  };
  // Memoize an expensive function by storing its results.
  _.memoize = function(func, hasher) {
    var memo = {};
    hasher || (hasher = _.identity);
    return function() {
      var key = hasher.apply(this, arguments);
      return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
    };
  };
  // Delays a function for the given number of milliseconds, and then calls
  // it with the arguments supplied.
  _.delay = function(func, wait) {
    var args = slice.call(arguments, 2);
    return setTimeout(function(){ return func.apply(func, args); }, wait);
  };
  // Defers a function, scheduling it to run after the current call stack has
  // cleared.
  _.defer = function(func) {
    return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
  };
  // Returns a function, that, when invoked, will only be triggered at most once
  // during a given window of time.
  _.throttle = function(func, wait) {
    var context, args, timeout, throttling, more;
    var whenDone = _.debounce(function(){ more = throttling = false; }, wait);
    return function() {
      context = this; args = arguments;
      var later = function() {
        timeout = null;
        if (more) func.apply(context, args);
        whenDone();
      };
      if (!timeout) timeout = setTimeout(later, wait);
      if (throttling) {
        more = true;
      } else {
        func.apply(context, args);
      }
      whenDone();
      throttling = true;
    };
  };
  // Returns a function, that, as long as it continues to be invoked, will not
  // be triggered. The function will be called after it stops being called for
  // N milliseconds.
  _.debounce = function(func, wait) {
    var timeout;
    return function() {
      var context = this, args = arguments;
      var later = function() {
        timeout = null;
        func.apply(context, args);
      };
      clearTimeout(timeout);
      timeout = setTimeout(later, wait);
    };
  };
  // Returns a function that will be executed at most one time, no matter how
  // often you call it. Useful for lazy initialization.
  _.once = function(func) {
    var ran = false, memo;
    return function() {
      if (ran) return memo;
      ran = true;
      return memo = func.apply(this, arguments);
    };
  };
  // Returns the first function passed as an argument to the second,
  // allowing you to adjust arguments, run code before and after, and
  // conditionally execute the original function.
  _.wrap = function(func, wrapper) {
    return function() {
      var args = [func].concat(slice.call(arguments, 0));
      return wrapper.apply(this, args);
    };
  };
  // Returns a function that is the composition of a list of functions, each
  // consuming the return value of the function that follows.
  _.compose = function() {
    var funcs = arguments;
    return function() {
      var args = arguments;
      for (var i = funcs.length - 1; i >= 0; i--) {
        args = [funcs[i].apply(this, args)];
      }
      return args[0];
    };
  };
  // Returns a function that will only be executed after being called N times.
  _.after = function(times, func) {
    if (times <= 0) return func();
    return function() {
      if (--times < 1) { return func.apply(this, arguments); }
    };
  };
  // Object Functions
  // ----------------
  // Retrieve the names of an object's properties.
  // Delegates to **ECMAScript 5**'s native `Object.keys`
  _.keys = nativeKeys || function(obj) {
    if (obj !== Object(obj)) throw new TypeError('Invalid object');
    var keys = [];
    for (var key in obj) if (_.has(obj, key)) keys[keys.length] = key;
    return keys;
  };
  // Retrieve the values of an object's properties.
  _.values = function(obj) {
    return _.map(obj, _.identity);
  };
  // Return a sorted list of the function names available on the object.
  // Aliased as `methods`
  _.functions = _.methods = function(obj) {
    var names = [];
    for (var key in obj) {
      if (_.isFunction(obj[key])) names.push(key);
    }
    return names.sort();
  };
  // Extend a given object with all the properties in passed-in object(s).
  _.extend = function(obj) {
    each(slice.call(arguments, 1), function(source) {
      for (var prop in source) {
        obj[prop] = source[prop];
      }
    });
    return obj;
  };
  // Fill in a given object with default properties.
  _.defaults = function(obj) {
    each(slice.call(arguments, 1), function(source) {
      for (var prop in source) {
        if (obj[prop] == null) obj[prop] = source[prop];
      }
    });
    return obj;
  };
  // Create a (shallow-cloned) duplicate of an object.
  _.clone = function(obj) {
    if (!_.isObject(obj)) return obj;
    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
  };
  // Invokes interceptor with the obj, and then returns obj.
  // The primary purpose of this method is to "tap into" a method chain, in
  // order to perform operations on intermediate results within the chain.
  _.tap = function(obj, interceptor) {
    interceptor(obj);
    return obj;
  };
  // Internal recursive comparison function.
  function eq(a, b, stack) {
    // Identical objects are equal. `0 === -0`, but they aren't identical.
    // See the Harmony `egal` proposal: http://wiki.ecmascript.org/doku.php?id=harmony:egal.
    if (a === b) return a !== 0 || 1 / a == 1 / b;
    // A strict comparison is necessary because `null == undefined`.
    if (a == null || b == null) return a === b;
    // Unwrap any wrapped objects.
    if (a._chain) a = a._wrapped;
    if (b._chain) b = b._wrapped;
    // Invoke a custom `isEqual` method if one is provided.
    if (a.isEqual && _.isFunction(a.isEqual)) return a.isEqual(b);
    if (b.isEqual && _.isFunction(b.isEqual)) return b.isEqual(a);
    // Compare `[[Class]]` names.
    var className = toString.call(a);
    if (className != toString.call(b)) return false;
    switch (className) {
      // Strings, numbers, dates, and booleans are compared by value.
      case '[object String]':
        // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
        // equivalent to `new String("5")`.
        return a == String(b);
      case '[object Number]':
        // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
        // other numeric values.
        return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
      case '[object Date]':
      case '[object Boolean]':
        // Coerce dates and booleans to numeric primitive values. Dates are compared by their
        // millisecond representations. Note that invalid dates with millisecond representations
        // of `NaN` are not equivalent.
        return +a == +b;
      // RegExps are compared by their source patterns and flags.
      case '[object RegExp]':
        return a.source == b.source &&
               a.global == b.global &&
               a.multiline == b.multiline &&
               a.ignoreCase == b.ignoreCase;
    }
    if (typeof a != 'object' || typeof b != 'object') return false;
    // Assume equality for cyclic structures. The algorithm for detecting cyclic
    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
    var length = stack.length;
    while (length--) {
      // Linear search. Performance is inversely proportional to the number of
      // unique nested structures.
      if (stack[length] == a) return true;
    }
    // Add the first object to the stack of traversed objects.
    stack.push(a);
    var size = 0, result = true;
    // Recursively compare objects and arrays.
    if (className == '[object Array]') {
      // Compare array lengths to determine if a deep comparison is necessary.
      size = a.length;
      result = size == b.length;
      if (result) {
        // Deep compare the contents, ignoring non-numeric properties.
        while (size--) {
          // Ensure commutative equality for sparse arrays.
          if (!(result = size in a == size in b && eq(a[size], b[size], stack))) break;
        }
      }
    } else {
      // Objects with different constructors are not equivalent.
      if ('constructor' in a != 'constructor' in b || a.constructor != b.constructor) return false;
      // Deep compare objects.
      for (var key in a) {
        if (_.has(a, key)) {
          // Count the expected number of properties.
          size++;
          // Deep compare each member.
          if (!(result = _.has(b, key) && eq(a[key], b[key], stack))) break;
        }
      }
      // Ensure that both objects contain the same number of properties.
      if (result) {
        for (key in b) {
          if (_.has(b, key) && !(size--)) break;
        }
        result = !size;
      }
    }
    // Remove the first object from the stack of traversed objects.
    stack.pop();
    return result;
  }
  // Perform a deep comparison to check if two objects are equal.
  _.isEqual = function(a, b) {
    return eq(a, b, []);
  };
  // Is a given array, string, or object empty?
  // An "empty" object has no enumerable own-properties.
  _.isEmpty = function(obj) {
    if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
    for (var key in obj) if (_.has(obj, key)) return false;
    return true;
  };
  // Is a given value a DOM element?
  _.isElement = function(obj) {
    return !!(obj && obj.nodeType == 1);
  };
  // Is a given value an array?
  // Delegates to ECMA5's native Array.isArray
  _.isArray = nativeIsArray || function(obj) {
    return toString.call(obj) == '[object Array]';
  };
  // Is a given variable an object?
  _.isObject = function(obj) {
    return obj === Object(obj);
  };
  // Is a given variable an arguments object?
  _.isArguments = function(obj) {
    return toString.call(obj) == '[object Arguments]';
  };
  if (!_.isArguments(arguments)) {
    _.isArguments = function(obj) {
      return !!(obj && _.has(obj, 'callee'));
    };
  }
  // Is a given value a function?
  _.isFunction = function(obj) {
    return toString.call(obj) == '[object Function]';
  };
  // Is a given value a string?
  _.isString = function(obj) {
    return toString.call(obj) == '[object String]';
  };
  // Is a given value a number?
  _.isNumber = function(obj) {
    return toString.call(obj) == '[object Number]';
  };
  // Is the given value `NaN`?
  _.isNaN = function(obj) {
    // `NaN` is the only value for which `===` is not reflexive.
    return obj !== obj;
  };
  // Is a given value a boolean?
  _.isBoolean = function(obj) {
    return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
  };
  // Is a given value a date?
  _.isDate = function(obj) {
    return toString.call(obj) == '[object Date]';
  };
  // Is the given value a regular expression?
  _.isRegExp = function(obj) {
    return toString.call(obj) == '[object RegExp]';
  };
  // Is a given value equal to null?
  _.isNull = function(obj) {
    return obj === null;
  };
  // Is a given variable undefined?
  _.isUndefined = function(obj) {
    return obj === void 0;
  };
  // Has own property?
  _.has = function(obj, key) {
    return hasOwnProperty.call(obj, key);
  };
  // Utility Functions
  // -----------------
  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
  // previous owner. Returns a reference to the Underscore object.
  _.noConflict = function() {
    root._ = previousUnderscore;
    return this;
  };
  // Keep the identity function around for default iterators.
  _.identity = function(value) {
    return value;
  };
  // Run a function **n** times.
  _.times = function (n, iterator, context) {
    for (var i = 0; i < n; i++) iterator.call(context, i);
  };
  // Escape a string for HTML interpolation.
  _.escape = function(string) {
    return (''+string).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#x27;').replace(/\//g,'&#x2F;');
  };
  // Add your own custom functions to the Underscore object, ensuring that
  // they're correctly added to the OOP wrapper as well.
  _.mixin = function(obj) {
    each(_.functions(obj), function(name){
      addToWrapper(name, _[name] = obj[name]);
    });
  };
  // Generate a unique integer id (unique within the entire client session).
  // Useful for temporary DOM ids.
  var idCounter = 0;
  _.uniqueId = function(prefix) {
    var id = idCounter++;
    return prefix ? prefix + id : id;
  };
  // By default, Underscore uses ERB-style template delimiters, change the
  // following template settings to use alternative delimiters.
  _.templateSettings = {
    evaluate    : /<%([\s\S]+?)%>/g,
    interpolate : /<%=([\s\S]+?)%>/g,
    escape      : /<%-([\s\S]+?)%>/g
  };
  // When customizing `templateSettings`, if you don't want to define an
  // interpolation, evaluation or escaping regex, we need one that is
  // guaranteed not to match.
  var noMatch = /.^/;
  // Within an interpolation, evaluation, or escaping, remove HTML escaping
  // that had been previously added.
  var unescape = function(code) {
    return code.replace(/\\\\/g, '\\').replace(/\\'/g, "'");
  };
  // JavaScript micro-templating, similar to John Resig's implementation.
  // Underscore templating handles arbitrary delimiters, preserves whitespace,
  // and correctly escapes quotes within interpolated code.
  _.template = function(str, data) {
    var c  = _.templateSettings;
    var tmpl = 'var __p=[],print=function(){__p.push.apply(__p,arguments);};' +
      'with(obj||{}){__p.push(\'' +
      str.replace(/\\/g, '\\\\')
         .replace(/'/g, "\\'")
         .replace(c.escape || noMatch, function(match, code) {
           return "',_.escape(" + unescape(code) + "),'";
         })
         .replace(c.interpolate || noMatch, function(match, code) {
           return "'," + unescape(code) + ",'";
         })
         .replace(c.evaluate || noMatch, function(match, code) {
           return "');" + unescape(code).replace(/[\r\n\t]/g, ' ') + ";__p.push('";
         })
         .replace(/\r/g, '\\r')
         .replace(/\n/g, '\\n')
         .replace(/\t/g, '\\t')
         + "');}return __p.join('');";
    var func = new Function('obj', '_', tmpl);
    if (data) return func(data, _);
    return function(data) {
      return func.call(this, data, _);
    };
  };
  // Add a "chain" function, which will delegate to the wrapper.
  _.chain = function(obj) {
    return _(obj).chain();
  };
  // The OOP Wrapper
  // ---------------
  // If Underscore is called as a function, it returns a wrapped object that
  // can be used OO-style. This wrapper holds altered versions of all the
  // underscore functions. Wrapped objects may be chained.
  var wrapper = function(obj) { this._wrapped = obj; };
  // Expose `wrapper.prototype` as `_.prototype`
  _.prototype = wrapper.prototype;
  // Helper function to continue chaining intermediate results.
  var result = function(obj, chain) {
    return chain ? _(obj).chain() : obj;
  };
  // A method to easily add functions to the OOP wrapper.
  var addToWrapper = function(name, func) {
    wrapper.prototype[name] = function() {
      var args = slice.call(arguments);
      unshift.call(args, this._wrapped);
      return result(func.apply(_, args), this._chain);
    };
  };
  // Add all of the Underscore functions to the wrapper object.
  _.mixin(_);
  // Add all mutator Array functions to the wrapper.
  each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
    var method = ArrayProto[name];
    wrapper.prototype[name] = function() {
      var wrapped = this._wrapped;
      method.apply(wrapped, arguments);
      var length = wrapped.length;
      if ((name == 'shift' || name == 'splice') && length === 0) delete wrapped[0];
      return result(wrapped, this._chain);
    };
  });
  // Add all accessor Array functions to the wrapper.
  each(['concat', 'join', 'slice'], function(name) {
    var method = ArrayProto[name];
    wrapper.prototype[name] = function() {
      return result(method.apply(this._wrapped, arguments), this._chain);
    };
  });
  // Start chaining a wrapped Underscore object.
  wrapper.prototype.chain = function() {
    this._chain = true;
    return this;
  };
  // Extracts the result from a wrapped and chained object.
  wrapper.prototype.value = function() {
    return this._wrapped;
  };
 }).call(this);
--- a/0.2/_static/underscore.js
+++ b/0.2/_static/underscore.js
@ -0,0 +1,31 @@
 // Underscore.js 1.3.1
 // (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
 // Underscore is freely distributable under the MIT license.
 // Portions of Underscore are inspired or borrowed from Prototype,
 // Oliver Steele's Functional, and John Resig's Micro-Templating.
 // For all details and documentation:
 // http://documentcloud.github.com/underscore
 (function(){function q(a,c,d){if(a===c)return a!==0||1/a==1/c;if(a==null||c==null)return a===c;if(a._chain)a=a._wrapped;if(c._chain)c=c._wrapped;if(a.isEqual&&b.isFunction(a.isEqual))return a.isEqual(c);if(c.isEqual&&b.isFunction(c.isEqual))return c.isEqual(a);var e=l.call(a);if(e!=l.call(c))return false;switch(e){case "[object String]":return a==String(c);case "[object Number]":return a!=+a?c!=+c:a==0?1/a==1/c:a==+c;case "[object Date]":case "[object Boolean]":return+a==+c;case "[object RegExp]":return a.source==
 c.source&&a.global==c.global&&a.multiline==c.multiline&&a.ignoreCase==c.ignoreCase}if(typeof a!="object"||typeof c!="object")return false;for(var f=d.length;f--;)if(d[f]==a)return true;d.push(a);var f=0,g=true;if(e=="[object Array]"){if(f=a.length,g=f==c.length)for(;f--;)if(!(g=f in a==f in c&&q(a[f],c[f],d)))break}else{if("constructor"in a!="constructor"in c||a.constructor!=c.constructor)return false;for(var h in a)if(b.has(a,h)&&(f++,!(g=b.has(c,h)&&q(a[h],c[h],d))))break;if(g){for(h in c)if(b.has(c,
 h)&&!f--)break;g=!f}}d.pop();return g}var r=this,G=r._,n={},k=Array.prototype,o=Object.prototype,i=k.slice,H=k.unshift,l=o.toString,I=o.hasOwnProperty,w=k.forEach,x=k.map,y=k.reduce,z=k.reduceRight,A=k.filter,B=k.every,C=k.some,p=k.indexOf,D=k.lastIndexOf,o=Array.isArray,J=Object.keys,s=Function.prototype.bind,b=function(a){return new m(a)};if(typeof exports!=="undefined"){if(typeof module!=="undefined"&&module.exports)exports=module.exports=b;exports._=b}else r._=b;b.VERSION="1.3.1";var j=b.each=
 b.forEach=function(a,c,d){if(a!=null)if(w&&a.forEach===w)a.forEach(c,d);else if(a.length===+a.length)for(var e=0,f=a.length;e<f;e++){if(e in a&&c.call(d,a[e],e,a)===n)break}else for(e in a)if(b.has(a,e)&&c.call(d,a[e],e,a)===n)break};b.map=b.collect=function(a,c,b){var e=[];if(a==null)return e;if(x&&a.map===x)return a.map(c,b);j(a,function(a,g,h){e[e.length]=c.call(b,a,g,h)});if(a.length===+a.length)e.length=a.length;return e};b.reduce=b.foldl=b.inject=function(a,c,d,e){var f=arguments.length>2;a==
 null&&(a=[]);if(y&&a.reduce===y)return e&&(c=b.bind(c,e)),f?a.reduce(c,d):a.reduce(c);j(a,function(a,b,i){f?d=c.call(e,d,a,b,i):(d=a,f=true)});if(!f)throw new TypeError("Reduce of empty array with no initial value");return d};b.reduceRight=b.foldr=function(a,c,d,e){var f=arguments.length>2;a==null&&(a=[]);if(z&&a.reduceRight===z)return e&&(c=b.bind(c,e)),f?a.reduceRight(c,d):a.reduceRight(c);var g=b.toArray(a).reverse();e&&!f&&(c=b.bind(c,e));return f?b.reduce(g,c,d,e):b.reduce(g,c)};b.find=b.detect=
 function(a,c,b){var e;E(a,function(a,g,h){if(c.call(b,a,g,h))return e=a,true});return e};b.filter=b.select=function(a,c,b){var e=[];if(a==null)return e;if(A&&a.filter===A)return a.filter(c,b);j(a,function(a,g,h){c.call(b,a,g,h)&&(e[e.length]=a)});return e};b.reject=function(a,c,b){var e=[];if(a==null)return e;j(a,function(a,g,h){c.call(b,a,g,h)||(e[e.length]=a)});return e};b.every=b.all=function(a,c,b){var e=true;if(a==null)return e;if(B&&a.every===B)return a.every(c,b);j(a,function(a,g,h){if(!(e=
 e&&c.call(b,a,g,h)))return n});return e};var E=b.some=b.any=function(a,c,d){c||(c=b.identity);var e=false;if(a==null)return e;if(C&&a.some===C)return a.some(c,d);j(a,function(a,b,h){if(e||(e=c.call(d,a,b,h)))return n});return!!e};b.include=b.contains=function(a,c){var b=false;if(a==null)return b;return p&&a.indexOf===p?a.indexOf(c)!=-1:b=E(a,function(a){return a===c})};b.invoke=function(a,c){var d=i.call(arguments,2);return b.map(a,function(a){return(b.isFunction(c)?c||a:a[c]).apply(a,d)})};b.pluck=
 function(a,c){return b.map(a,function(a){return a[c]})};b.max=function(a,c,d){if(!c&&b.isArray(a))return Math.max.apply(Math,a);if(!c&&b.isEmpty(a))return-Infinity;var e={computed:-Infinity};j(a,function(a,b,h){b=c?c.call(d,a,b,h):a;b>=e.computed&&(e={value:a,computed:b})});return e.value};b.min=function(a,c,d){if(!c&&b.isArray(a))return Math.min.apply(Math,a);if(!c&&b.isEmpty(a))return Infinity;var e={computed:Infinity};j(a,function(a,b,h){b=c?c.call(d,a,b,h):a;b<e.computed&&(e={value:a,computed:b})});
 return e.value};b.shuffle=function(a){var b=[],d;j(a,function(a,f){f==0?b[0]=a:(d=Math.floor(Math.random()*(f+1)),b[f]=b[d],b[d]=a)});return b};b.sortBy=function(a,c,d){return b.pluck(b.map(a,function(a,b,g){return{value:a,criteria:c.call(d,a,b,g)}}).sort(function(a,b){var c=a.criteria,d=b.criteria;return c<d?-1:c>d?1:0}),"value")};b.groupBy=function(a,c){var d={},e=b.isFunction(c)?c:function(a){return a[c]};j(a,function(a,b){var c=e(a,b);(d[c]||(d[c]=[])).push(a)});return d};b.sortedIndex=function(a,
 c,d){d||(d=b.identity);for(var e=0,f=a.length;e<f;){var g=e+f>>1;d(a[g])<d(c)?e=g+1:f=g}return e};b.toArray=function(a){return!a?[]:a.toArray?a.toArray():b.isArray(a)?i.call(a):b.isArguments(a)?i.call(a):b.values(a)};b.size=function(a){return b.toArray(a).length};b.first=b.head=function(a,b,d){return b!=null&&!d?i.call(a,0,b):a[0]};b.initial=function(a,b,d){return i.call(a,0,a.length-(b==null||d?1:b))};b.last=function(a,b,d){return b!=null&&!d?i.call(a,Math.max(a.length-b,0)):a[a.length-1]};b.rest=
 b.tail=function(a,b,d){return i.call(a,b==null||d?1:b)};b.compact=function(a){return b.filter(a,function(a){return!!a})};b.flatten=function(a,c){return b.reduce(a,function(a,e){if(b.isArray(e))return a.concat(c?e:b.flatten(e));a[a.length]=e;return a},[])};b.without=function(a){return b.difference(a,i.call(arguments,1))};b.uniq=b.unique=function(a,c,d){var d=d?b.map(a,d):a,e=[];b.reduce(d,function(d,g,h){if(0==h||(c===true?b.last(d)!=g:!b.include(d,g)))d[d.length]=g,e[e.length]=a[h];return d},[]);
 return e};b.union=function(){return b.uniq(b.flatten(arguments,true))};b.intersection=b.intersect=function(a){var c=i.call(arguments,1);return b.filter(b.uniq(a),function(a){return b.every(c,function(c){return b.indexOf(c,a)>=0})})};b.difference=function(a){var c=b.flatten(i.call(arguments,1));return b.filter(a,function(a){return!b.include(c,a)})};b.zip=function(){for(var a=i.call(arguments),c=b.max(b.pluck(a,"length")),d=Array(c),e=0;e<c;e++)d[e]=b.pluck(a,""+e);return d};b.indexOf=function(a,c,
 d){if(a==null)return-1;var e;if(d)return d=b.sortedIndex(a,c),a[d]===c?d:-1;if(p&&a.indexOf===p)return a.indexOf(c);for(d=0,e=a.length;d<e;d++)if(d in a&&a[d]===c)return d;return-1};b.lastIndexOf=function(a,b){if(a==null)return-1;if(D&&a.lastIndexOf===D)return a.lastIndexOf(b);for(var d=a.length;d--;)if(d in a&&a[d]===b)return d;return-1};b.range=function(a,b,d){arguments.length<=1&&(b=a||0,a=0);for(var d=arguments[2]||1,e=Math.max(Math.ceil((b-a)/d),0),f=0,g=Array(e);f<e;)g[f++]=a,a+=d;return g};
 var F=function(){};b.bind=function(a,c){var d,e;if(a.bind===s&&s)return s.apply(a,i.call(arguments,1));if(!b.isFunction(a))throw new TypeError;e=i.call(arguments,2);return d=function(){if(!(this instanceof d))return a.apply(c,e.concat(i.call(arguments)));F.prototype=a.prototype;var b=new F,g=a.apply(b,e.concat(i.call(arguments)));return Object(g)===g?g:b}};b.bindAll=function(a){var c=i.call(arguments,1);c.length==0&&(c=b.functions(a));j(c,function(c){a[c]=b.bind(a[c],a)});return a};b.memoize=function(a,
 c){var d={};c||(c=b.identity);return function(){var e=c.apply(this,arguments);return b.has(d,e)?d[e]:d[e]=a.apply(this,arguments)}};b.delay=function(a,b){var d=i.call(arguments,2);return setTimeout(function(){return a.apply(a,d)},b)};b.defer=function(a){return b.delay.apply(b,[a,1].concat(i.call(arguments,1)))};b.throttle=function(a,c){var d,e,f,g,h,i=b.debounce(function(){h=g=false},c);return function(){d=this;e=arguments;var b;f||(f=setTimeout(function(){f=null;h&&a.apply(d,e);i()},c));g?h=true:
 a.apply(d,e);i();g=true}};b.debounce=function(a,b){var d;return function(){var e=this,f=arguments;clearTimeout(d);d=setTimeout(function(){d=null;a.apply(e,f)},b)}};b.once=function(a){var b=false,d;return function(){if(b)return d;b=true;return d=a.apply(this,arguments)}};b.wrap=function(a,b){return function(){var d=[a].concat(i.call(arguments,0));return b.apply(this,d)}};b.compose=function(){var a=arguments;return function(){for(var b=arguments,d=a.length-1;d>=0;d--)b=[a[d].apply(this,b)];return b[0]}};
 b.after=function(a,b){return a<=0?b():function(){if(--a<1)return b.apply(this,arguments)}};b.keys=J||function(a){if(a!==Object(a))throw new TypeError("Invalid object");var c=[],d;for(d in a)b.has(a,d)&&(c[c.length]=d);return c};b.values=function(a){return b.map(a,b.identity)};b.functions=b.methods=function(a){var c=[],d;for(d in a)b.isFunction(a[d])&&c.push(d);return c.sort()};b.extend=function(a){j(i.call(arguments,1),function(b){for(var d in b)a[d]=b[d]});return a};b.defaults=function(a){j(i.call(arguments,
 1),function(b){for(var d in b)a[d]==null&&(a[d]=b[d])});return a};b.clone=function(a){return!b.isObject(a)?a:b.isArray(a)?a.slice():b.extend({},a)};b.tap=function(a,b){b(a);return a};b.isEqual=function(a,b){return q(a,b,[])};b.isEmpty=function(a){if(b.isArray(a)||b.isString(a))return a.length===0;for(var c in a)if(b.has(a,c))return false;return true};b.isElement=function(a){return!!(a&&a.nodeType==1)};b.isArray=o||function(a){return l.call(a)=="[object Array]"};b.isObject=function(a){return a===Object(a)};
 b.isArguments=function(a){return l.call(a)=="[object Arguments]"};if(!b.isArguments(arguments))b.isArguments=function(a){return!(!a||!b.has(a,"callee"))};b.isFunction=function(a){return l.call(a)=="[object Function]"};b.isString=function(a){return l.call(a)=="[object String]"};b.isNumber=function(a){return l.call(a)=="[object Number]"};b.isNaN=function(a){return a!==a};b.isBoolean=function(a){return a===true||a===false||l.call(a)=="[object Boolean]"};b.isDate=function(a){return l.call(a)=="[object Date]"};
 b.isRegExp=function(a){return l.call(a)=="[object RegExp]"};b.isNull=function(a){return a===null};b.isUndefined=function(a){return a===void 0};b.has=function(a,b){return I.call(a,b)};b.noConflict=function(){r._=G;return this};b.identity=function(a){return a};b.times=function(a,b,d){for(var e=0;e<a;e++)b.call(d,e)};b.escape=function(a){return(""+a).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&#x27;").replace(/\//g,"&#x2F;")};b.mixin=function(a){j(b.functions(a),
 function(c){K(c,b[c]=a[c])})};var L=0;b.uniqueId=function(a){var b=L++;return a?a+b:b};b.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g};var t=/.^/,u=function(a){return a.replace(/\\\\/g,"\\").replace(/\\'/g,"'")};b.template=function(a,c){var d=b.templateSettings,d="var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('"+a.replace(/\\/g,"\\\\").replace(/'/g,"\\'").replace(d.escape||t,function(a,b){return"',_.escape("+
 u(b)+"),'"}).replace(d.interpolate||t,function(a,b){return"',"+u(b)+",'"}).replace(d.evaluate||t,function(a,b){return"');"+u(b).replace(/[\r\n\t]/g," ")+";__p.push('"}).replace(/\r/g,"\\r").replace(/\n/g,"\\n").replace(/\t/g,"\\t")+"');}return __p.join('');",e=new Function("obj","_",d);return c?e(c,b):function(a){return e.call(this,a,b)}};b.chain=function(a){return b(a).chain()};var m=function(a){this._wrapped=a};b.prototype=m.prototype;var v=function(a,c){return c?b(a).chain():a},K=function(a,c){m.prototype[a]=
 function(){var a=i.call(arguments);H.call(a,this._wrapped);return v(c.apply(b,a),this._chain)}};b.mixin(b);j("pop,push,reverse,shift,sort,splice,unshift".split(","),function(a){var b=k[a];m.prototype[a]=function(){var d=this._wrapped;b.apply(d,arguments);var e=d.length;(a=="shift"||a=="splice")&&e===0&&delete d[0];return v(d,this._chain)}});j(["concat","join","slice"],function(a){var b=k[a];m.prototype[a]=function(){return v(b.apply(this._wrapped,arguments),this._chain)}});m.prototype.chain=function(){this._chain=
 true;return this};m.prototype.value=function(){return this._wrapped}}).call(this);
--- a/0.2/_static/vendor/fontawesome/5.13.0/LICENSE.txt
+++ b/0.2/_static/vendor/fontawesome/5.13.0/LICENSE.txt
@ -0,0 +1,34 @@
 Font Awesome Free License
 -------------------------
 Font Awesome Free is free, open source, and GPL friendly. You can use it for
 commercial projects, open source projects, or really almost whatever you want.
 Full Font Awesome Free license: https://fontawesome.com/license/free.
 # Icons: CC BY 4.0 License (https://creativecommons.org/licenses/by/4.0/)
 In the Font Awesome Free download, the CC BY 4.0 license applies to all icons
 packaged as SVG and JS file types.
 # Fonts: SIL OFL 1.1 License (https://scripts.sil.org/OFL)
 In the Font Awesome Free download, the SIL OFL license applies to all icons
 packaged as web and desktop font files.
 # Code: MIT License (https://opensource.org/licenses/MIT)
 In the Font Awesome Free download, the MIT license applies to all non-font and
 non-icon files.
 # Attribution
 Attribution is required by MIT, SIL OFL, and CC BY licenses. Downloaded Font
 Awesome Free files already contain embedded comments with sufficient
 attribution, so you shouldn't need to do anything additional when using these
 files normally.
 We've kept attribution comments terse, so we ask that you do not actively work
 to remove them from files, especially code. They're a great way for folks to
 learn about Font Awesome.
 # Brand Icons
 All brand icons are trademarks of their respective owners. The use of these
 trademarks does not indicate endorsement of the trademark holder by Font
 Awesome, nor vice versa. **Please do not use brand logos for any purpose except
 to represent the company, product, or service to which they refer.**
--- a/0.2/_static/vendor/fontawesome/5.13.0/css/all.min.css
+++ b/0.2/_static/vendor/fontawesome/5.13.0/css/all.min.css
--- a/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-brands-400.eot
+++ b/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-brands-400.eot
--- a/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-brands-400.svg
+++ b/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-brands-400.svg
--- a/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-brands-400.ttf
+++ b/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-brands-400.ttf
--- a/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-brands-400.woff
+++ b/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-brands-400.woff
--- a/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-brands-400.woff2
+++ b/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-brands-400.woff2
--- a/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-regular-400.eot
+++ b/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-regular-400.eot
--- a/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-regular-400.svg
+++ b/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-regular-400.svg
@ -0,0 +1,803 @@
 <?xml version="1.0" standalone="no"?>
 <!--
 Font Awesome Free 5.13.0 by @fontawesome - https://fontawesome.com
 License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License)
 -->
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" >
 <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1">
 <metadata>
 Created by FontForge 20190801 at Mon Mar 23 10:45:51 2020
 By Robert Madole
 Copyright (c) Font Awesome
 </metadata>
 <defs>
 <font id="FontAwesome5Free-Regular" horiz-adv-x="512" >
  <font-face 
    font-family="Font Awesome 5 Free Regular"
    font-weight="400"
    font-stretch="normal"
    units-per-em="512"
    panose-1="2 0 5 3 0 0 0 0 0 0"
    ascent="448"
    descent="-64"
    bbox="-0.0663408 -64.0662 640.01 448.1"
    underline-thickness="25"
    underline-position="-50"
    unicode-range="U+0020-F5C8"
  />
    <missing-glyph />
    <glyph glyph-name="heart" unicode="&#xf004;" 
 d="M458.4 383.7c75.2998 -63.4004 64.0996 -166.601 10.5996 -221.3l-175.4 -178.7c-10 -10.2002 -23.2998 -15.7998 -37.5996 -15.7998c-14.2002 0 -27.5996 5.69922 -37.5996 15.8994l-175.4 178.7c-53.5996 54.7002 -64.5996 157.9 10.5996 221.2
 c57.8008 48.7002 147.101 41.2998 202.4 -15c55.2998 56.2998 144.6 63.5996 202.4 15zM434.8 196.2c36.2002 36.8994 43.7998 107.7 -7.2998 150.8c-38.7002 32.5996 -98.7002 27.9004 -136.5 -10.5996l-35 -35.7002l-35 35.7002
 c-37.5996 38.2998 -97.5996 43.1992 -136.5 10.5c-51.2002 -43.1006 -43.7998 -113.5 -7.2998 -150.7l175.399 -178.7c2.40039 -2.40039 4.40039 -2.40039 6.80078 0z" />
    <glyph glyph-name="star" unicode="&#xf005;" horiz-adv-x="576" 
 d="M528.1 276.5c26.2002 -3.7998 36.7002 -36.0996 17.7002 -54.5996l-105.7 -103l25 -145.5c4.5 -26.3008 -23.1992 -45.9004 -46.3994 -33.7002l-130.7 68.7002l-130.7 -68.7002c-23.2002 -12.2998 -50.8994 7.39941 -46.3994 33.7002l25 145.5l-105.7 103
 c-19 18.5 -8.5 50.7998 17.7002 54.5996l146.1 21.2998l65.2998 132.4c11.7998 23.8994 45.7002 23.5996 57.4004 0l65.2998 -132.4zM388.6 135.7l100.601 98l-139 20.2002l-62.2002 126l-62.2002 -126l-139 -20.2002l100.601 -98l-23.7002 -138.4l124.3 65.2998
 l124.3 -65.2998z" />
    <glyph glyph-name="user" unicode="&#xf007;" horiz-adv-x="448" 
 d="M313.6 144c74.2002 0 134.4 -60.2002 134.4 -134.4v-25.5996c0 -26.5 -21.5 -48 -48 -48h-352c-26.5 0 -48 21.5 -48 48v25.5996c0 74.2002 60.2002 134.4 134.4 134.4c28.7998 0 42.5 -16 89.5996 -16s60.9004 16 89.5996 16zM400 -16v25.5996
 c0 47.6006 -38.7998 86.4004 -86.4004 86.4004c-14.6992 0 -37.8994 -16 -89.5996 -16c-51.2998 0 -75 16 -89.5996 16c-47.6006 0 -86.4004 -38.7998 -86.4004 -86.4004v-25.5996h352zM224 160c-79.5 0 -144 64.5 -144 144s64.5 144 144 144s144 -64.5 144 -144
 s-64.5 -144 -144 -144zM224 400c-52.9004 0 -96 -43.0996 -96 -96s43.0996 -96 96 -96s96 43.0996 96 96s-43.0996 96 -96 96z" />
    <glyph glyph-name="clock" unicode="&#xf017;" 
 d="M256 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM256 -8c110.5 0 200 89.5 200 200s-89.5 200 -200 200s-200 -89.5 -200 -200s89.5 -200 200 -200zM317.8 96.4004l-84.8994 61.6992
 c-3.10059 2.30078 -4.90039 5.90039 -4.90039 9.7002v164.2c0 6.59961 5.40039 12 12 12h32c6.59961 0 12 -5.40039 12 -12v-141.7l66.7998 -48.5996c5.40039 -3.90039 6.5 -11.4004 2.60059 -16.7998l-18.8008 -25.9004c-3.89941 -5.2998 -11.3994 -6.5 -16.7998 -2.59961z
 " />
    <glyph glyph-name="list-alt" unicode="&#xf022;" 
 d="M464 416c26.5098 0 48 -21.4902 48 -48v-352c0 -26.5098 -21.4902 -48 -48 -48h-416c-26.5098 0 -48 21.4902 -48 48v352c0 26.5098 21.4902 48 48 48h416zM458 16c3.31152 0 6 2.68848 6 6v340c0 3.31152 -2.68848 6 -6 6h-404c-3.31152 0 -6 -2.68848 -6 -6v-340
 c0 -3.31152 2.68848 -6 6 -6h404zM416 108v-24c0 -6.62695 -5.37305 -12 -12 -12h-200c-6.62695 0 -12 5.37305 -12 12v24c0 6.62695 5.37305 12 12 12h200c6.62695 0 12 -5.37305 12 -12zM416 204v-24c0 -6.62695 -5.37305 -12 -12 -12h-200c-6.62695 0 -12 5.37305 -12 12
 v24c0 6.62695 5.37305 12 12 12h200c6.62695 0 12 -5.37305 12 -12zM416 300v-24c0 -6.62695 -5.37305 -12 -12 -12h-200c-6.62695 0 -12 5.37305 -12 12v24c0 6.62695 5.37305 12 12 12h200c6.62695 0 12 -5.37305 12 -12zM164 288c0 -19.8818 -16.1182 -36 -36 -36
 s-36 16.1182 -36 36s16.1182 36 36 36s36 -16.1182 36 -36zM164 192c0 -19.8818 -16.1182 -36 -36 -36s-36 16.1182 -36 36s16.1182 36 36 36s36 -16.1182 36 -36zM164 96c0 -19.8818 -16.1182 -36 -36 -36s-36 16.1182 -36 36s16.1182 36 36 36s36 -16.1182 36 -36z" />
    <glyph glyph-name="flag" unicode="&#xf024;" 
 d="M336.174 368c35.4668 0 73.0195 12.6914 108.922 28.1797c31.6406 13.6514 66.9043 -9.65723 66.9043 -44.1162v-239.919c0 -16.1953 -8.1543 -31.3057 -21.7129 -40.1631c-26.5762 -17.3643 -70.0693 -39.9814 -128.548 -39.9814c-68.6084 0 -112.781 32 -161.913 32
 c-56.5674 0 -89.957 -11.2803 -127.826 -28.5566v-83.4434c0 -8.83691 -7.16309 -16 -16 -16h-16c-8.83691 0 -16 7.16309 -16 16v406.438c-14.3428 8.2998 -24 23.7979 -24 41.5615c0 27.5693 23.2422 49.71 51.2012 47.8965
 c22.9658 -1.49023 41.8662 -19.4717 44.4805 -42.3379c0.177734 -1.52441 0.321289 -4.00781 0.321289 -5.54199c0 -4.30176 -1.10352 -11.1035 -2.46289 -15.1846c22.418 8.68555 49.4199 15.168 80.7207 15.168c68.6084 0 112.781 -32 161.913 -32zM464 112v240
 c-31.5059 -14.6338 -84.5547 -32 -127.826 -32c-59.9111 0 -101.968 32 -161.913 32c-41.4365 0 -80.4766 -16.5879 -102.261 -32v-232c31.4473 14.5967 84.4648 24 127.826 24c59.9111 0 101.968 -32 161.913 -32c41.4365 0 80.4775 16.5879 102.261 32z" />
    <glyph glyph-name="bookmark" unicode="&#xf02e;" horiz-adv-x="384" 
 d="M336 448c26.5098 0 48 -21.4902 48 -48v-464l-192 112l-192 -112v464c0 26.5098 21.4902 48 48 48h288zM336 19.5703v374.434c0 3.31348 -2.68555 5.99609 -6 5.99609h-276c-3.31152 0 -6 -2.68848 -6 -6v-374.43l144 84z" />
    <glyph glyph-name="image" unicode="&#xf03e;" 
 d="M464 384c26.5098 0 48 -21.4902 48 -48v-288c0 -26.5098 -21.4902 -48 -48 -48h-416c-26.5098 0 -48 21.4902 -48 48v288c0 26.5098 21.4902 48 48 48h416zM458 48c3.31152 0 6 2.68848 6 6v276c0 3.31152 -2.68848 6 -6 6h-404c-3.31152 0 -6 -2.68848 -6 -6v-276
 c0 -3.31152 2.68848 -6 6 -6h404zM128 296c22.0908 0 40 -17.9092 40 -40s-17.9092 -40 -40 -40s-40 17.9092 -40 40s17.9092 40 40 40zM96 96v48l39.5137 39.5146c4.6875 4.68652 12.2852 4.68652 16.9717 0l39.5146 -39.5146l119.514 119.515
 c4.6875 4.68652 12.2852 4.68652 16.9717 0l87.5146 -87.5146v-80h-320z" />
    <glyph glyph-name="edit" unicode="&#xf044;" horiz-adv-x="576" 
 d="M402.3 103.1l32 32c5 5 13.7002 1.5 13.7002 -5.69922v-145.4c0 -26.5 -21.5 -48 -48 -48h-352c-26.5 0 -48 21.5 -48 48v352c0 26.5 21.5 48 48 48h273.5c7.09961 0 10.7002 -8.59961 5.7002 -13.7002l-32 -32c-1.5 -1.5 -3.5 -2.2998 -5.7002 -2.2998h-241.5v-352h352
 v113.5c0 2.09961 0.799805 4.09961 2.2998 5.59961zM558.9 304.9l-262.601 -262.601l-90.3994 -10c-26.2002 -2.89941 -48.5 19.2002 -45.6006 45.6006l10 90.3994l262.601 262.601c22.8994 22.8994 59.8994 22.8994 82.6992 0l43.2002 -43.2002
 c22.9004 -22.9004 22.9004 -60 0.100586 -82.7998zM460.1 274l-58.0996 58.0996l-185.8 -185.899l-7.2998 -65.2998l65.2998 7.2998zM524.9 353.7l-43.2002 43.2002c-4.10059 4.09961 -10.7998 4.09961 -14.7998 0l-30.9004 -30.9004l58.0996 -58.0996l30.9004 30.8994
 c4 4.2002 4 10.7998 -0.0996094 14.9004z" />
    <glyph glyph-name="times-circle" unicode="&#xf057;" 
 d="M256 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM256 -8c110.5 0 200 89.5 200 200s-89.5 200 -200 200s-200 -89.5 -200 -200s89.5 -200 200 -200zM357.8 254.2l-62.2002 -62.2002l62.2002 -62.2002
 c4.7002 -4.7002 4.7002 -12.2998 0 -17l-22.5996 -22.5996c-4.7002 -4.7002 -12.2998 -4.7002 -17 0l-62.2002 62.2002l-62.2002 -62.2002c-4.7002 -4.7002 -12.2998 -4.7002 -17 0l-22.5996 22.5996c-4.7002 4.7002 -4.7002 12.2998 0 17l62.2002 62.2002l-62.2002 62.2002
 c-4.7002 4.7002 -4.7002 12.2998 0 17l22.5996 22.5996c4.7002 4.7002 12.2998 4.7002 17 0l62.2002 -62.2002l62.2002 62.2002c4.7002 4.7002 12.2998 4.7002 17 0l22.5996 -22.5996c4.7002 -4.7002 4.7002 -12.2998 0 -17z" />
    <glyph glyph-name="check-circle" unicode="&#xf058;" 
 d="M256 440c136.967 0 248 -111.033 248 -248s-111.033 -248 -248 -248s-248 111.033 -248 248s111.033 248 248 248zM256 392c-110.549 0 -200 -89.4678 -200 -200c0 -110.549 89.4678 -200 200 -200c110.549 0 200 89.4678 200 200c0 110.549 -89.4678 200 -200 200z
 M396.204 261.733c4.66699 -4.70508 4.63672 -12.3037 -0.0673828 -16.9717l-172.589 -171.204c-4.70508 -4.66797 -12.3027 -4.63672 -16.9697 0.0683594l-90.7812 91.5156c-4.66797 4.70605 -4.63672 12.3047 0.0683594 16.9717l22.7188 22.5361
 c4.70508 4.66699 12.3027 4.63574 16.9697 -0.0693359l59.792 -60.2773l141.353 140.216c4.70508 4.66797 12.3027 4.6377 16.9697 -0.0673828z" />
    <glyph glyph-name="question-circle" unicode="&#xf059;" 
 d="M256 440c136.957 0 248 -111.083 248 -248c0 -136.997 -111.043 -248 -248 -248s-248 111.003 -248 248c0 136.917 111.043 248 248 248zM256 -8c110.569 0 200 89.4697 200 200c0 110.529 -89.5088 200 -200 200c-110.528 0 -200 -89.5049 -200 -200
 c0 -110.569 89.4678 -200 200 -200zM363.244 247.2c0 -67.0518 -72.4209 -68.084 -72.4209 -92.8633v-6.33691c0 -6.62695 -5.37305 -12 -12 -12h-45.6475c-6.62695 0 -12 5.37305 -12 12v8.65918c0 35.7451 27.1006 50.0342 47.5791 61.5156
 c17.5615 9.84473 28.3242 16.541 28.3242 29.5791c0 17.2461 -21.999 28.6934 -39.7842 28.6934c-23.1885 0 -33.8936 -10.9775 -48.9424 -29.9697c-4.05664 -5.11914 -11.46 -6.07031 -16.666 -2.12402l-27.8232 21.0986
 c-5.10742 3.87207 -6.25098 11.0654 -2.64453 16.3633c23.627 34.6934 53.7217 54.1846 100.575 54.1846c49.0713 0 101.45 -38.3037 101.45 -88.7998zM298 80c0 -23.1592 -18.8408 -42 -42 -42s-42 18.8408 -42 42s18.8408 42 42 42s42 -18.8408 42 -42z" />
    <glyph glyph-name="eye" unicode="&#xf06e;" horiz-adv-x="576" 
 d="M288 304c0.0927734 0 0.244141 0.000976562 0.336914 0.000976562c61.6641 0 111.71 -50.0469 111.71 -111.711c0 -61.6631 -50.0459 -111.71 -111.71 -111.71s-111.71 50.0469 -111.71 111.71c0 8.71289 1.95898 22.5781 4.37305 30.9502
 c6.93066 -3.94141 19.0273 -7.18457 27 -7.24023c30.9121 0 56 25.0879 56 56c-0.0556641 7.97266 -3.29883 20.0693 -7.24023 27c8.42383 2.62207 22.4189 4.8623 31.2402 5zM572.52 206.6c1.9209 -3.79883 3.47949 -10.3379 3.47949 -14.5947
 s-1.55859 -10.7959 -3.47949 -14.5947c-54.1992 -105.771 -161.59 -177.41 -284.52 -177.41s-230.29 71.5898 -284.52 177.4c-1.9209 3.79883 -3.47949 10.3379 -3.47949 14.5947s1.55859 10.7959 3.47949 14.5947c54.1992 105.771 161.59 177.41 284.52 177.41
 s230.29 -71.5898 284.52 -177.4zM288 48c98.6602 0 189.1 55 237.93 144c-48.8398 89 -139.27 144 -237.93 144s-189.09 -55 -237.93 -144c48.8398 -89 139.279 -144 237.93 -144z" />
    <glyph glyph-name="eye-slash" unicode="&#xf070;" horiz-adv-x="640" 
 d="M634 -23c3.31738 -2.65137 6.00977 -8.25098 6.00977 -12.498c0 -3.10449 -1.57715 -7.58984 -3.51953 -10.0117l-10 -12.4902c-2.65234 -3.31152 -8.24707 -6 -12.4902 -6c-3.09961 0 -7.58008 1.57227 -10 3.50977l-598 467.49
 c-3.31738 2.65137 -6.00977 8.25098 -6.00977 12.498c0 3.10449 1.57715 7.58984 3.51953 10.0117l10 12.4902c2.65234 3.31152 8.24707 6 12.4902 6c3.09961 0 7.58008 -1.57227 10 -3.50977zM296.79 301.53c6.33496 1.35059 16.7324 2.45801 23.21 2.46973
 c60.4805 0 109.36 -47.9102 111.58 -107.85zM343.21 82.46c-6.33496 -1.34375 -16.7334 -2.44629 -23.21 -2.45996c-60.4697 0 -109.35 47.9102 -111.58 107.84zM320 336c-19.8799 0 -39.2803 -2.7998 -58.2197 -7.09961l-46.4102 36.29
 c32.9199 11.8096 67.9297 18.8096 104.63 18.8096c122.93 0 230.29 -71.5898 284.57 -177.4c1.91992 -3.79883 3.47949 -10.3379 3.47949 -14.5947s-1.55957 -10.7959 -3.47949 -14.5947c-11.7197 -22.7598 -35.4189 -56.4092 -52.9004 -75.1104l-37.7402 29.5
 c14.333 15.0156 34.0449 41.9854 44 60.2002c-48.8398 89 -139.279 144 -237.93 144zM320 48c19.8896 0 39.2803 2.7998 58.2197 7.08984l46.4102 -36.2803c-32.9199 -11.7598 -67.9297 -18.8096 -104.63 -18.8096c-122.92 0 -230.28 71.5898 -284.51 177.4
 c-1.9209 3.79883 -3.47949 10.3379 -3.47949 14.5947s1.55859 10.7959 3.47949 14.5947c11.7168 22.7568 35.4111 56.4014 52.8896 75.1006l37.7402 -29.5c-14.3467 -15.0107 -34.0811 -41.9756 -44.0498 -60.1904c48.8496 -89 139.279 -144 237.93 -144z" />
    <glyph glyph-name="calendar-alt" unicode="&#xf073;" horiz-adv-x="448" 
 d="M148 160h-40c-6.59961 0 -12 5.40039 -12 12v40c0 6.59961 5.40039 12 12 12h40c6.59961 0 12 -5.40039 12 -12v-40c0 -6.59961 -5.40039 -12 -12 -12zM256 172c0 -6.59961 -5.40039 -12 -12 -12h-40c-6.59961 0 -12 5.40039 -12 12v40c0 6.59961 5.40039 12 12 12h40
 c6.59961 0 12 -5.40039 12 -12v-40zM352 172c0 -6.59961 -5.40039 -12 -12 -12h-40c-6.59961 0 -12 5.40039 -12 12v40c0 6.59961 5.40039 12 12 12h40c6.59961 0 12 -5.40039 12 -12v-40zM256 76c0 -6.59961 -5.40039 -12 -12 -12h-40c-6.59961 0 -12 5.40039 -12 12v40
 c0 6.59961 5.40039 12 12 12h40c6.59961 0 12 -5.40039 12 -12v-40zM160 76c0 -6.59961 -5.40039 -12 -12 -12h-40c-6.59961 0 -12 5.40039 -12 12v40c0 6.59961 5.40039 12 12 12h40c6.59961 0 12 -5.40039 12 -12v-40zM352 76c0 -6.59961 -5.40039 -12 -12 -12h-40
 c-6.59961 0 -12 5.40039 -12 12v40c0 6.59961 5.40039 12 12 12h40c6.59961 0 12 -5.40039 12 -12v-40zM448 336v-352c0 -26.5 -21.5 -48 -48 -48h-352c-26.5 0 -48 21.5 -48 48v352c0 26.5 21.5 48 48 48h48v52c0 6.59961 5.40039 12 12 12h40
 c6.59961 0 12 -5.40039 12 -12v-52h128v52c0 6.59961 5.40039 12 12 12h40c6.59961 0 12 -5.40039 12 -12v-52h48c26.5 0 48 -21.5 48 -48zM400 -10v298h-352v-298c0 -3.2998 2.7002 -6 6 -6h340c3.2998 0 6 2.7002 6 6z" />
    <glyph glyph-name="comment" unicode="&#xf075;" 
 d="M256 416c141.4 0 256 -93.0996 256 -208s-114.6 -208 -256 -208c-32.7998 0 -64 5.2002 -92.9004 14.2998c-29.0996 -20.5996 -77.5996 -46.2998 -139.1 -46.2998c-9.59961 0 -18.2998 5.7002 -22.0996 14.5c-3.80078 8.7998 -2 19 4.59961 26
 c0.5 0.400391 31.5 33.7998 46.4004 73.2002c-33 35.0996 -52.9004 78.7002 -52.9004 126.3c0 114.9 114.6 208 256 208zM256 48c114.7 0 208 71.7998 208 160s-93.2998 160 -208 160s-208 -71.7998 -208 -160c0 -42.2002 21.7002 -74.0996 39.7998 -93.4004
 l20.6006 -21.7998l-10.6006 -28.0996c-5.5 -14.5 -12.5996 -28.1006 -19.8994 -40.2002c23.5996 7.59961 43.1992 18.9004 57.5 29l19.5 13.7998l22.6992 -7.2002c25.3008 -8 51.7002 -12.0996 78.4004 -12.0996z" />
    <glyph glyph-name="folder" unicode="&#xf07b;" 
 d="M464 320c26.5098 0 48 -21.4902 48 -48v-224c0 -26.5098 -21.4902 -48 -48 -48h-416c-26.5098 0 -48 21.4902 -48 48v288c0 26.5098 21.4902 48 48 48h146.74c8.49023 0 16.6299 -3.37012 22.6299 -9.37012l54.6299 -54.6299h192zM464 48v224h-198.62
 c-8.49023 0 -16.6299 3.37012 -22.6299 9.37012l-54.6299 54.6299h-140.12v-288h416z" />
    <glyph glyph-name="folder-open" unicode="&#xf07c;" horiz-adv-x="576" 
 d="M527.9 224c37.6992 0 60.6992 -41.5 40.6992 -73.4004l-79.8994 -128c-8.7998 -14.0996 -24.2002 -22.5996 -40.7002 -22.5996h-400c-26.5 0 -48 21.5 -48 48v288c0 26.5 21.5 48 48 48h160l64 -64h160c26.5 0 48 -21.5 48 -48v-48h47.9004zM48 330v-233.4l62.9004 104.2
 c8.69922 14.4004 24.2998 23.2002 41.0996 23.2002h280v42c0 3.2998 -2.7002 6 -6 6h-173.9l-64 64h-134.1c-3.2998 0 -6 -2.7002 -6 -6zM448 48l80 128h-378.8l-77.2002 -128h376z" />
    <glyph glyph-name="chart-bar" unicode="&#xf080;" 
 d="M396.8 96c-6.39941 0 -12.7998 6.40039 -12.7998 12.7998v230.4c0 6.39941 6.40039 12.7998 12.7998 12.7998h22.4004c6.39941 0 12.7998 -6.40039 12.7998 -12.7998v-230.4c0 -6.39941 -6.40039 -12.7998 -12.7998 -12.7998h-22.4004zM204.8 96
 c-6.39941 0 -12.7998 6.40039 -12.7998 12.7998v198.4c0 6.39941 6.40039 12.7998 12.7998 12.7998h22.4004c6.39941 0 12.7998 -6.40039 12.7998 -12.7998v-198.4c0 -6.39941 -6.40039 -12.7998 -12.7998 -12.7998h-22.4004zM300.8 96
 c-6.39941 0 -12.7998 6.40039 -12.7998 12.7998v134.4c0 6.39941 6.40039 12.7998 12.7998 12.7998h22.4004c6.39941 0 12.7998 -6.40039 12.7998 -12.7998v-134.4c0 -6.39941 -6.40039 -12.7998 -12.7998 -12.7998h-22.4004zM496 48c8.83984 0 16 -7.16016 16 -16v-16
 c0 -8.83984 -7.16016 -16 -16 -16h-464c-17.6699 0 -32 14.3301 -32 32v336c0 8.83984 7.16016 16 16 16h16c8.83984 0 16 -7.16016 16 -16v-320h448zM108.8 96c-6.39941 0 -12.7998 6.40039 -12.7998 12.7998v70.4004c0 6.39941 6.40039 12.7998 12.7998 12.7998h22.4004
 c6.39941 0 12.7998 -6.40039 12.7998 -12.7998v-70.4004c0 -6.39941 -6.40039 -12.7998 -12.7998 -12.7998h-22.4004z" />
    <glyph glyph-name="comments" unicode="&#xf086;" horiz-adv-x="576" 
 d="M532 61.7998c15.2998 -30.7002 37.4004 -54.5 37.7998 -54.7998c6.2998 -6.7002 8 -16.5 4.40039 -25c-3.7002 -8.5 -12 -14 -21.2002 -14c-53.5996 0 -96.7002 20.2998 -125.2 38.7998c-19 -4.39941 -39 -6.7998 -59.7998 -6.7998
 c-86.2002 0 -159.9 40.4004 -191.3 97.7998c-9.7002 1.2002 -19.2002 2.7998 -28.4004 4.90039c-28.5 -18.6006 -71.7002 -38.7998 -125.2 -38.7998c-9.19922 0 -17.5996 5.5 -21.1992 14c-3.7002 8.5 -1.90039 18.2998 4.39941 25
 c0.400391 0.399414 22.4004 24.1992 37.7002 54.8994c-27.5 27.2002 -44 61.2002 -44 98.2002c0 88.4004 93.0996 160 208 160c86.2998 0 160.3 -40.5 191.8 -98.0996c99.7002 -11.8008 176.2 -77.9004 176.2 -157.9c0 -37.0996 -16.5 -71.0996 -44 -98.2002zM139.2 154.1
 l19.7998 -4.5c16 -3.69922 32.5 -5.59961 49 -5.59961c86.7002 0 160 51.2998 160 112s-73.2998 112 -160 112s-160 -51.2998 -160 -112c0 -28.7002 16.2002 -50.5996 29.7002 -64l24.7998 -24.5l-15.5 -31.0996c-2.59961 -5.10059 -5.2998 -10.1006 -8 -14.8008
 c14.5996 5.10059 29 12.3008 43.0996 21.4004zM498.3 96c13.5 13.4004 29.7002 35.2998 29.7002 64c0 49.2002 -48.2998 91.5 -112.7 106c0.299805 -3.2998 0.700195 -6.59961 0.700195 -10c0 -80.9004 -78 -147.5 -179.3 -158.3
 c29.0996 -29.6006 77.2998 -49.7002 131.3 -49.7002c16.5 0 33 1.90039 49 5.59961l19.9004 4.60059l17.0996 -11.1006c14.0996 -9.09961 28.5 -16.2998 43.0996 -21.3994c-2.69922 4.7002 -5.39941 9.7002 -8 14.7998l-15.5 31.0996z" />
    <glyph glyph-name="star-half" unicode="&#xf089;" horiz-adv-x="576" 
 d="M288 62.7002v-54.2998l-130.7 -68.6006c-23.3994 -12.2998 -50.8994 7.60059 -46.3994 33.7002l25 145.5l-105.7 103c-19 18.5 -8.5 50.7998 17.7002 54.5996l146.1 21.2002l65.2998 132.4c5.90039 11.8994 17.2998 17.7998 28.7002 17.7998v-68.0996l-62.2002 -126
 l-139 -20.2002l100.601 -98l-23.7002 -138.4z" />
    <glyph glyph-name="lemon" unicode="&#xf094;" 
 d="M484.112 420.111c28.1221 -28.123 35.9434 -68.0039 19.0215 -97.0547c-23.0576 -39.584 50.1436 -163.384 -82.3311 -295.86c-132.301 -132.298 -256.435 -59.3594 -295.857 -82.3291c-29.0459 -16.917 -68.9219 -9.11426 -97.0576 19.0205
 c-28.1221 28.1221 -35.9434 68.0029 -19.0215 97.0547c23.0566 39.5859 -50.1436 163.386 82.3301 295.86c132.308 132.309 256.407 59.3496 295.862 82.332c29.0498 16.9219 68.9307 9.09863 97.0537 -19.0234zM461.707 347.217
 c13.5166 23.2031 -27.7578 63.7314 -50.4883 50.4912c-66.6025 -38.7939 -165.646 45.5898 -286.081 -74.8457c-120.444 -120.445 -36.0449 -219.472 -74.8447 -286.08c-13.542 -23.2471 27.8145 -63.6953 50.4932 -50.4883
 c66.6006 38.7949 165.636 -45.5996 286.076 74.8428c120.444 120.445 36.0449 219.472 74.8447 286.08zM291.846 338.481c1.37012 -10.96 -6.40332 -20.957 -17.3643 -22.3271c-54.8467 -6.85547 -135.779 -87.7871 -142.636 -142.636
 c-1.37305 -10.9883 -11.3984 -18.7334 -22.3262 -17.3643c-10.9609 1.37012 -18.7344 11.3652 -17.3643 22.3262c9.16211 73.2852 104.167 168.215 177.364 177.364c10.9531 1.36816 20.9561 -6.40234 22.3262 -17.3633z" />
    <glyph glyph-name="credit-card" unicode="&#xf09d;" horiz-adv-x="576" 
 d="M527.9 416c26.5996 0 48.0996 -21.5 48.0996 -48v-352c0 -26.5 -21.5 -48 -48.0996 -48h-479.801c-26.5996 0 -48.0996 21.5 -48.0996 48v352c0 26.5 21.5 48 48.0996 48h479.801zM54.0996 368c-3.2998 0 -6 -2.7002 -6 -6v-42h479.801v42c0 3.2998 -2.7002 6 -6 6
 h-467.801zM521.9 16c3.2998 0 6 2.7002 6 6v170h-479.801v-170c0 -3.2998 2.7002 -6 6 -6h467.801zM192 116v-40c0 -6.59961 -5.40039 -12 -12 -12h-72c-6.59961 0 -12 5.40039 -12 12v40c0 6.59961 5.40039 12 12 12h72c6.59961 0 12 -5.40039 12 -12zM384 116v-40
 c0 -6.59961 -5.40039 -12 -12 -12h-136c-6.59961 0 -12 5.40039 -12 12v40c0 6.59961 5.40039 12 12 12h136c6.59961 0 12 -5.40039 12 -12z" />
    <glyph glyph-name="hdd" unicode="&#xf0a0;" horiz-adv-x="576" 
 d="M567.403 212.358c5.59668 -8.04688 8.59668 -17.6113 8.59668 -27.4121v-136.946c0 -26.5098 -21.4902 -48 -48 -48h-480c-26.5098 0 -48 21.4902 -48 48v136.946c0 8.30957 3.85156 20.5898 8.59668 27.4121l105.08 151.053
 c7.90625 11.3652 25.5596 20.5889 39.4033 20.5889h0.000976562h269.838h0.000976562c13.8438 0 31.4971 -9.22363 39.4033 -20.5889zM153.081 336l-77.9131 -112h425.664l-77.9131 112h-269.838zM528 48v128h-480v-128h480zM496 112c0 -17.6729 -14.3271 -32 -32 -32
 s-32 14.3271 -32 32s14.3271 32 32 32s32 -14.3271 32 -32zM400 112c0 -17.6729 -14.3271 -32 -32 -32s-32 14.3271 -32 32s14.3271 32 32 32s32 -14.3271 32 -32z" />
    <glyph glyph-name="hand-point-right" unicode="&#xf0a4;" 
 d="M428.8 310.4c45.0996 0 83.2002 -38.1016 83.2002 -83.2002c0 -45.6162 -37.7646 -83.2002 -83.2002 -83.2002h-35.6475c-1.41602 -6.36719 -4.96875 -16.252 -7.92969 -22.0645c2.50586 -22.0059 -3.50293 -44.9775 -15.9844 -62.791
 c-1.14062 -52.4863 -37.3984 -91.1445 -99.9404 -91.1445h-21.2988c-60.0635 0 -98.5117 40 -127.2 40h-2.67871c-5.74707 -4.95215 -13.5361 -8 -22.1201 -8h-64c-17.6729 0 -32 12.8936 -32 28.7998v230.4c0 15.9062 14.3271 28.7998 32 28.7998h64.001
 c8.58398 0 16.373 -3.04785 22.1201 -8h2.67871c6.96387 0 14.8623 6.19336 30.1816 23.6689l0.128906 0.148438l0.130859 0.145508c8.85645 9.93652 18.1162 20.8398 25.8506 33.2529c18.7051 30.2471 30.3936 78.7842 75.707 78.7842c56.9277 0 92 -35.2861 92 -83.2002
 v-0.0839844c0 -6.21777 -0.974609 -16.2148 -2.17578 -22.3154h86.1768zM428.8 192c18.9756 0 35.2002 16.2246 35.2002 35.2002c0 18.7002 -16.7754 35.2002 -35.2002 35.2002h-158.399c0 17.3242 26.3994 35.1992 26.3994 70.3994c0 26.4004 -20.625 35.2002 -44 35.2002
 c-8.79395 0 -20.4443 -32.7119 -34.9258 -56.0996c-9.07422 -14.5752 -19.5244 -27.2256 -30.7988 -39.875c-16.1094 -18.374 -33.8359 -36.6328 -59.0752 -39.5967v-176.753c42.79 -3.7627 74.5088 -39.6758 120 -39.6758h21.2988
 c40.5244 0 57.124 22.1973 50.6006 61.3252c14.6113 8.00098 24.1514 33.9785 12.9248 53.625c19.3652 18.2246 17.7871 46.3809 4.9502 61.0498h91.0254zM88 64c0 13.2549 -10.7451 24 -24 24s-24 -10.7451 -24 -24s10.7451 -24 24 -24s24 10.7451 24 24z" />
    <glyph glyph-name="hand-point-left" unicode="&#xf0a5;" 
 d="M0 227.2c0 45.0986 38.1006 83.2002 83.2002 83.2002h86.1758c-1.3623 6.91016 -2.17578 14.374 -2.17578 22.3994c0 47.9141 35.0723 83.2002 92 83.2002c45.3135 0 57.002 -48.5371 75.7061 -78.7852c7.73438 -12.4121 16.9951 -23.3154 25.8506 -33.2529
 l0.130859 -0.145508l0.128906 -0.148438c15.3213 -17.4746 23.2197 -23.668 30.1836 -23.668h2.67871c5.74707 4.95215 13.5361 8 22.1201 8h64c17.6729 0 32 -12.8936 32 -28.7998v-230.4c0 -15.9062 -14.3271 -28.7998 -32 -28.7998h-64
 c-8.58398 0 -16.373 3.04785 -22.1201 8h-2.67871c-28.6885 0 -67.1367 -40 -127.2 -40h-21.2988c-62.542 0 -98.8008 38.6582 -99.9404 91.1445c-12.4814 17.8135 -18.4922 40.7852 -15.9844 62.791c-2.96094 5.8125 -6.51367 15.6973 -7.92969 22.0645h-35.6465
 c-45.4355 0 -83.2002 37.584 -83.2002 83.2002zM48 227.2c0 -18.9756 16.2246 -35.2002 35.2002 -35.2002h91.0244c-12.8369 -14.6689 -14.415 -42.8252 4.9502 -61.0498c-11.2256 -19.6465 -1.68652 -45.624 12.9248 -53.625
 c-6.52246 -39.1279 10.0771 -61.3252 50.6016 -61.3252h21.2988c45.4912 0 77.21 35.9131 120 39.6768v176.752c-25.2393 2.96289 -42.9658 21.2227 -59.0752 39.5967c-11.2744 12.6494 -21.7246 25.2998 -30.7988 39.875
 c-14.4814 23.3877 -26.1318 56.0996 -34.9258 56.0996c-23.375 0 -44 -8.7998 -44 -35.2002c0 -35.2002 26.3994 -53.0752 26.3994 -70.3994h-158.399c-18.4248 0 -35.2002 -16.5 -35.2002 -35.2002zM448 88c-13.2549 0 -24 -10.7451 -24 -24s10.7451 -24 24 -24
 s24 10.7451 24 24s-10.7451 24 -24 24z" />
    <glyph glyph-name="hand-point-up" unicode="&#xf0a6;" horiz-adv-x="448" 
 d="M105.6 364.8c0 45.0996 38.1016 83.2002 83.2002 83.2002c45.6162 0 83.2002 -37.7646 83.2002 -83.2002v-35.6465c6.36719 -1.41602 16.252 -4.96875 22.0645 -7.92969c22.0059 2.50684 44.9775 -3.50293 62.791 -15.9844
 c52.4863 -1.14062 91.1445 -37.3984 91.1445 -99.9404v-21.2988c0 -60.0635 -40 -98.5117 -40 -127.2v-2.67871c4.95215 -5.74707 8 -13.5361 8 -22.1201v-64c0 -17.6729 -12.8936 -32 -28.7998 -32h-230.4c-15.9062 0 -28.7998 14.3271 -28.7998 32v64
 c0 8.58398 3.04785 16.373 8 22.1201v2.67871c0 6.96387 -6.19336 14.8623 -23.6689 30.1816l-0.148438 0.128906l-0.145508 0.130859c-9.93652 8.85645 -20.8398 18.1162 -33.2529 25.8506c-30.2471 18.7051 -78.7842 30.3936 -78.7842 75.707
 c0 56.9277 35.2861 92 83.2002 92h0.0839844c6.21777 0 16.2148 -0.974609 22.3154 -2.17578v86.1768zM224 364.8c0 18.9756 -16.2246 35.2002 -35.2002 35.2002c-18.7002 0 -35.2002 -16.7754 -35.2002 -35.2002v-158.399c-17.3242 0 -35.1992 26.3994 -70.3994 26.3994
 c-26.4004 0 -35.2002 -20.625 -35.2002 -44c0 -8.79395 32.7119 -20.4443 56.0996 -34.9258c14.5752 -9.07422 27.2256 -19.5244 39.875 -30.7988c18.374 -16.1094 36.6328 -33.8359 39.5967 -59.0752h176.753c3.7627 42.79 39.6758 74.5088 39.6758 120v21.2988
 c0 40.5244 -22.1973 57.124 -61.3252 50.6006c-8.00098 14.6113 -33.9785 24.1514 -53.625 12.9248c-18.2246 19.3652 -46.3809 17.7871 -61.0498 4.9502v91.0254zM352 24c-13.2549 0 -24 -10.7451 -24 -24s10.7451 -24 24 -24s24 10.7451 24 24s-10.7451 24 -24 24z" />
    <glyph glyph-name="hand-point-down" unicode="&#xf0a7;" horiz-adv-x="448" 
 d="M188.8 -64c-45.0986 0 -83.2002 38.1006 -83.2002 83.2002v86.1758c-6.91016 -1.3623 -14.374 -2.17578 -22.3994 -2.17578c-47.9141 0 -83.2002 35.0723 -83.2002 92c0 45.3135 48.5371 57.002 78.7852 75.707c12.4121 7.73438 23.3154 16.9951 33.2529 25.8506
 l0.145508 0.130859l0.148438 0.128906c17.4746 15.3213 23.668 23.2197 23.668 30.1836v2.67871c-4.95215 5.74707 -8 13.5361 -8 22.1201v64c0 17.6729 12.8936 32 28.7998 32h230.4c15.9062 0 28.7998 -14.3271 28.7998 -32v-64.001
 c0 -8.58398 -3.04785 -16.373 -8 -22.1201v-2.67871c0 -28.6885 40 -67.1367 40 -127.2v-21.2988c0 -62.542 -38.6582 -98.8008 -91.1445 -99.9404c-17.8135 -12.4814 -40.7852 -18.4922 -62.791 -15.9844c-5.8125 -2.96094 -15.6973 -6.51367 -22.0645 -7.92969v-35.6465
 c0 -45.4355 -37.584 -83.2002 -83.2002 -83.2002zM188.8 -16c18.9756 0 35.2002 16.2246 35.2002 35.2002v91.0244c14.6689 -12.8369 42.8252 -14.415 61.0498 4.9502c19.6465 -11.2256 45.624 -1.68652 53.625 12.9248c39.1279 -6.52246 61.3252 10.0771 61.3252 50.6016
 v21.2988c0 45.4912 -35.9131 77.21 -39.6768 120h-176.752c-2.96289 -25.2393 -21.2227 -42.9658 -39.5967 -59.0752c-12.6494 -11.2744 -25.2998 -21.7246 -39.875 -30.7988c-23.3877 -14.4814 -56.0996 -26.1318 -56.0996 -34.9258c0 -23.375 8.7998 -44 35.2002 -44
 c35.2002 0 53.0752 26.3994 70.3994 26.3994v-158.399c0 -18.4248 16.5 -35.2002 35.2002 -35.2002zM328 384c0 -13.2549 10.7451 -24 24 -24s24 10.7451 24 24s-10.7451 24 -24 24s-24 -10.7451 -24 -24z" />
    <glyph glyph-name="copy" unicode="&#xf0c5;" horiz-adv-x="448" 
 d="M433.941 382.059c7.75977 -7.75977 14.0586 -22.9658 14.0586 -33.9404v-268.118c0 -26.5098 -21.4902 -48 -48 -48h-80v-48c0 -26.5098 -21.4902 -48 -48 -48h-224c-26.5098 0 -48 21.4902 -48 48v320c0 26.5098 21.4902 48 48 48h80v48c0 26.5098 21.4902 48 48 48
 h172.118c10.9746 0 26.1807 -6.29883 33.9404 -14.0586zM266 -16c3.31152 0 6 2.68848 6 6v42h-96c-26.5098 0 -48 21.4902 -48 48v224h-74c-3.31152 0 -6 -2.68848 -6 -6v-308c0 -3.31152 2.68848 -6 6 -6h212zM394 80c3.31152 0 6 2.68848 6 6v202h-88
 c-13.2549 0 -24 10.7451 -24 24v88h-106c-3.31152 0 -6 -2.68848 -6 -6v-308c0 -3.31152 2.68848 -6 6 -6h212zM400 336v9.63184v0.000976562c0 1.37207 -0.787109 3.27246 -1.75684 4.24219l-48.3682 48.3682c-1.12598 1.125 -2.65234 1.75684 -4.24316 1.75684h-9.63184
 v-64h64z" />
    <glyph glyph-name="save" unicode="&#xf0c7;" horiz-adv-x="448" 
 d="M433.941 318.059c7.75977 -7.75977 14.0586 -22.9658 14.0586 -33.9404v-268.118c0 -26.5098 -21.4902 -48 -48 -48h-352c-26.5098 0 -48 21.4902 -48 48v352c0 26.5098 21.4902 48 48 48h268.118c10.9746 0 26.1807 -6.29883 33.9404 -14.0586zM272 368h-128v-80h128v80
 zM394 16c3.31152 0 6 2.68848 6 6v259.632v0.000976562c0 1.37207 -0.787109 3.27246 -1.75684 4.24219l-78.2432 78.2432v-100.118c0 -13.2549 -10.7451 -24 -24 -24h-176c-13.2549 0 -24 10.7451 -24 24v104h-42c-3.31152 0 -6 -2.68848 -6 -6v-340
 c0 -3.31152 2.68848 -6 6 -6h340zM224 216c48.5234 0 88 -39.4766 88 -88s-39.4766 -88 -88 -88s-88 39.4766 -88 88s39.4766 88 88 88zM224 88c22.0557 0 40 17.9443 40 40s-17.9443 40 -40 40s-40 -17.9443 -40 -40s17.9443 -40 40 -40z" />
    <glyph glyph-name="square" unicode="&#xf0c8;" horiz-adv-x="448" 
 d="M400 416c26.5 0 48 -21.5 48 -48v-352c0 -26.5 -21.5 -48 -48 -48h-352c-26.5 0 -48 21.5 -48 48v352c0 26.5 21.5 48 48 48h352zM394 16c3.2998 0 6 2.7002 6 6v340c0 3.2998 -2.7002 6 -6 6h-340c-3.2998 0 -6 -2.7002 -6 -6v-340c0 -3.2998 2.7002 -6 6 -6h340z" />
    <glyph glyph-name="envelope" unicode="&#xf0e0;" 
 d="M464 384c26.5098 0 48 -21.4902 48 -48v-288c0 -26.5098 -21.4902 -48 -48 -48h-416c-26.5098 0 -48 21.4902 -48 48v288c0 26.5098 21.4902 48 48 48h416zM464 336h-416v-40.8047c22.4248 -18.2627 58.1797 -46.6602 134.587 -106.49
 c16.834 -13.2422 50.2051 -45.0762 73.4131 -44.7012c23.2119 -0.371094 56.5723 31.4541 73.4131 44.7012c76.4189 59.8389 112.165 88.2305 134.587 106.49v40.8047zM48 48h416v185.601c-22.915 -18.252 -55.4189 -43.8691 -104.947 -82.6523
 c-22.5439 -17.748 -60.3359 -55.1787 -103.053 -54.9473c-42.9277 -0.231445 -81.2051 37.75 -103.062 54.9551c-49.5293 38.7842 -82.0244 64.3945 -104.938 82.6455v-185.602z" />
    <glyph glyph-name="lightbulb" unicode="&#xf0eb;" horiz-adv-x="352" 
 d="M176 368c8.83984 0 16 -7.16016 16 -16s-7.16016 -16 -16 -16c-35.2803 0 -64 -28.7002 -64 -64c0 -8.83984 -7.16016 -16 -16 -16s-16 7.16016 -16 16c0 52.9404 43.0596 96 96 96zM96.0596 -11.1699l-0.0400391 43.1797h159.961l-0.0507812 -43.1797
 c-0.00976562 -3.13965 -0.939453 -6.21973 -2.67969 -8.83984l-24.5098 -36.8398c-2.95996 -4.45996 -7.95996 -7.14062 -13.3203 -7.14062h-78.8496c-5.35059 0 -10.3506 2.68066 -13.3203 7.14062l-24.5098 36.8398c-1.75 2.62012 -2.68066 5.68945 -2.68066 8.83984z
 M176 448c97.2002 0 176 -78.7998 176 -176c0 -44.3701 -16.4502 -84.8496 -43.5498 -115.79c-16.6406 -18.9795 -42.7402 -58.79 -52.4199 -92.1602v-0.0498047h-48v0.0996094c0.00390625 4.04199 0.999023 10.4482 2.21973 14.3008
 c5.67969 17.9893 22.9902 64.8496 62.0996 109.46c20.4102 23.29 31.6504 53.1699 31.6504 84.1396c0 70.5801 -57.4199 128 -128 128c-68.2803 0 -128.15 -54.3604 -127.95 -128c0.0898438 -30.9902 11.0703 -60.71 31.6104 -84.1396
 c39.3496 -44.9004 56.5801 -91.8604 62.1699 -109.67c1.42969 -4.56055 2.13965 -9.30078 2.15039 -14.0703v-0.120117h-48v0.0595703c-9.68066 33.3604 -35.7803 73.1709 -52.4209 92.1602c-27.1094 30.9307 -43.5596 71.4102 -43.5596 115.78
 c0 93.0303 73.7197 176 176 176z" />
    <glyph glyph-name="bell" unicode="&#xf0f3;" horiz-adv-x="448" 
 d="M439.39 85.71c6 -6.44043 8.66016 -14.1602 8.61035 -21.71c-0.0996094 -16.4004 -12.9805 -32 -32.0996 -32h-383.801c-19.1191 0 -31.9893 15.5996 -32.0996 32c-0.0498047 7.5498 2.61035 15.2598 8.61035 21.71c19.3193 20.7598 55.4697 51.9902 55.4697 154.29
 c0 77.7002 54.4795 139.9 127.939 155.16v20.8398c0 17.6699 14.3203 32 31.9805 32s31.9805 -14.3301 31.9805 -32v-20.8398c73.46 -15.2598 127.939 -77.46 127.939 -155.16c0 -102.3 36.1504 -133.53 55.4697 -154.29zM67.5303 80h312.939
 c-21.2197 27.96 -44.4199 74.3203 -44.5293 159.42c0 0.200195 0.0595703 0.379883 0.0595703 0.580078c0 61.8604 -50.1396 112 -112 112s-112 -50.1396 -112 -112c0 -0.200195 0.0595703 -0.379883 0.0595703 -0.580078
 c-0.109375 -85.0898 -23.3096 -131.45 -44.5293 -159.42zM224 -64c-35.3203 0 -63.9697 28.6504 -63.9697 64h127.939c0 -35.3496 -28.6494 -64 -63.9697 -64z" />
    <glyph glyph-name="hospital" unicode="&#xf0f8;" horiz-adv-x="448" 
 d="M128 204v40c0 6.62695 5.37305 12 12 12h40c6.62695 0 12 -5.37305 12 -12v-40c0 -6.62695 -5.37305 -12 -12 -12h-40c-6.62695 0 -12 5.37305 -12 12zM268 192c-6.62695 0 -12 5.37305 -12 12v40c0 6.62695 5.37305 12 12 12h40c6.62695 0 12 -5.37305 12 -12v-40
 c0 -6.62695 -5.37305 -12 -12 -12h-40zM192 108c0 -6.62695 -5.37305 -12 -12 -12h-40c-6.62695 0 -12 5.37305 -12 12v40c0 6.62695 5.37305 12 12 12h40c6.62695 0 12 -5.37305 12 -12v-40zM268 96c-6.62695 0 -12 5.37305 -12 12v40c0 6.62695 5.37305 12 12 12h40
 c6.62695 0 12 -5.37305 12 -12v-40c0 -6.62695 -5.37305 -12 -12 -12h-40zM448 -28v-36h-448v36c0 6.62695 5.37305 12 12 12h19.5v378.965c0 11.6172 10.7451 21.0352 24 21.0352h88.5v40c0 13.2549 10.7451 24 24 24h112c13.2549 0 24 -10.7451 24 -24v-40h88.5
 c13.2549 0 24 -9.41797 24 -21.0352v-378.965h19.5c6.62695 0 12 -5.37305 12 -12zM79.5 -15h112.5v67c0 6.62695 5.37305 12 12 12h40c6.62695 0 12 -5.37305 12 -12v-67h112.5v351h-64.5v-24c0 -13.2549 -10.7451 -24 -24 -24h-112c-13.2549 0 -24 10.7451 -24 24v24
 h-64.5v-351zM266 384h-26v26c0 3.31152 -2.68848 6 -6 6h-20c-3.31152 0 -6 -2.68848 -6 -6v-26h-26c-3.31152 0 -6 -2.68848 -6 -6v-20c0 -3.31152 2.68848 -6 6 -6h26v-26c0 -3.31152 2.68848 -6 6 -6h20c3.31152 0 6 2.68848 6 6v26h26c3.31152 0 6 2.68848 6 6v20
 c0 3.31152 -2.68848 6 -6 6z" />
    <glyph glyph-name="plus-square" unicode="&#xf0fe;" horiz-adv-x="448" 
 d="M352 208v-32c0 -6.59961 -5.40039 -12 -12 -12h-88v-88c0 -6.59961 -5.40039 -12 -12 -12h-32c-6.59961 0 -12 5.40039 -12 12v88h-88c-6.59961 0 -12 5.40039 -12 12v32c0 6.59961 5.40039 12 12 12h88v88c0 6.59961 5.40039 12 12 12h32c6.59961 0 12 -5.40039 12 -12
 v-88h88c6.59961 0 12 -5.40039 12 -12zM448 368v-352c0 -26.5 -21.5 -48 -48 -48h-352c-26.5 0 -48 21.5 -48 48v352c0 26.5 21.5 48 48 48h352c26.5 0 48 -21.5 48 -48zM400 22v340c0 3.2998 -2.7002 6 -6 6h-340c-3.2998 0 -6 -2.7002 -6 -6v-340
 c0 -3.2998 2.7002 -6 6 -6h340c3.2998 0 6 2.7002 6 6z" />
    <glyph glyph-name="circle" unicode="&#xf111;" 
 d="M256 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM256 -8c110.5 0 200 89.5 200 200s-89.5 200 -200 200s-200 -89.5 -200 -200s89.5 -200 200 -200z" />
    <glyph glyph-name="smile" unicode="&#xf118;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM168 208c-17.7002 0 -32 14.2998 -32 32s14.2998 32 32 32
 s32 -14.2998 32 -32s-14.2998 -32 -32 -32zM328 208c-17.7002 0 -32 14.2998 -32 32s14.2998 32 32 32s32 -14.2998 32 -32s-14.2998 -32 -32 -32zM332 135.4c8.5 10.1992 23.7002 11.5 33.7998 3.09961c10.2002 -8.5 11.6006 -23.5996 3.10059 -33.7998
 c-30 -36 -74.1006 -56.6006 -120.9 -56.6006s-90.9004 20.6006 -120.9 56.6006c-8.39941 10.2002 -7.09961 25.2998 3.10059 33.7998c10.0996 8.40039 25.2998 7.09961 33.7998 -3.09961c20.7998 -25.1006 51.5 -39.4004 84 -39.4004s63.2002 14.4004 84 39.4004z" />
    <glyph glyph-name="frown" unicode="&#xf119;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM168 208c-17.7002 0 -32 14.2998 -32 32s14.2998 32 32 32
 s32 -14.2998 32 -32s-14.2998 -32 -32 -32zM328 272c17.7002 0 32 -14.2998 32 -32s-14.2998 -32 -32 -32s-32 14.2998 -32 32s14.2998 32 32 32zM248 144c40.2002 0 78 -17.7002 103.8 -48.5996c8.40039 -10.2002 7.10059 -25.3008 -3.09961 -33.8008
 c-10.7002 -8.7998 -25.7002 -6.59961 -33.7998 3.10059c-16.6006 20 -41 31.3994 -66.9004 31.3994s-50.2998 -11.5 -66.9004 -31.3994c-8.5 -10.2002 -23.5996 -11.5 -33.7998 -3.10059c-10.2002 8.5 -11.5996 23.6006 -3.09961 33.8008
 c25.7998 30.8994 63.5996 48.5996 103.8 48.5996z" />
    <glyph glyph-name="meh" unicode="&#xf11a;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM168 208c-17.7002 0 -32 14.2998 -32 32s14.2998 32 32 32
 s32 -14.2998 32 -32s-14.2998 -32 -32 -32zM328 272c17.7002 0 32 -14.2998 32 -32s-14.2998 -32 -32 -32s-32 14.2998 -32 32s14.2998 32 32 32zM336 128c13.2002 0 24 -10.7998 24 -24s-10.7998 -24 -24 -24h-176c-13.2002 0 -24 10.7998 -24 24s10.7998 24 24 24h176z
 " />
    <glyph glyph-name="keyboard" unicode="&#xf11c;" horiz-adv-x="576" 
 d="M528 384c26.5098 0 48 -21.4902 48 -48v-288c0 -26.5098 -21.4902 -48 -48 -48h-480c-26.5098 0 -48 21.4902 -48 48v288c0 26.5098 21.4902 48 48 48h480zM536 48v288c0 4.41113 -3.58887 8 -8 8h-480c-4.41113 0 -8 -3.58887 -8 -8v-288c0 -4.41113 3.58887 -8 8 -8
 h480c4.41113 0 8 3.58887 8 8zM170 178c0 -6.62695 -5.37305 -12 -12 -12h-28c-6.62695 0 -12 5.37305 -12 12v28c0 6.62695 5.37305 12 12 12h28c6.62695 0 12 -5.37305 12 -12v-28zM266 178c0 -6.62695 -5.37305 -12 -12 -12h-28c-6.62695 0 -12 5.37305 -12 12v28
 c0 6.62695 5.37305 12 12 12h28c6.62695 0 12 -5.37305 12 -12v-28zM362 178c0 -6.62695 -5.37305 -12 -12 -12h-28c-6.62695 0 -12 5.37305 -12 12v28c0 6.62695 5.37305 12 12 12h28c6.62695 0 12 -5.37305 12 -12v-28zM458 178c0 -6.62695 -5.37305 -12 -12 -12h-28
 c-6.62695 0 -12 5.37305 -12 12v28c0 6.62695 5.37305 12 12 12h28c6.62695 0 12 -5.37305 12 -12v-28zM122 96c0 -6.62695 -5.37305 -12 -12 -12h-28c-6.62695 0 -12 5.37305 -12 12v28c0 6.62695 5.37305 12 12 12h28c6.62695 0 12 -5.37305 12 -12v-28zM506 96
 c0 -6.62695 -5.37305 -12 -12 -12h-28c-6.62695 0 -12 5.37305 -12 12v28c0 6.62695 5.37305 12 12 12h28c6.62695 0 12 -5.37305 12 -12v-28zM122 260c0 -6.62695 -5.37305 -12 -12 -12h-28c-6.62695 0 -12 5.37305 -12 12v28c0 6.62695 5.37305 12 12 12h28
 c6.62695 0 12 -5.37305 12 -12v-28zM218 260c0 -6.62695 -5.37305 -12 -12 -12h-28c-6.62695 0 -12 5.37305 -12 12v28c0 6.62695 5.37305 12 12 12h28c6.62695 0 12 -5.37305 12 -12v-28zM314 260c0 -6.62695 -5.37305 -12 -12 -12h-28c-6.62695 0 -12 5.37305 -12 12v28
 c0 6.62695 5.37305 12 12 12h28c6.62695 0 12 -5.37305 12 -12v-28zM410 260c0 -6.62695 -5.37305 -12 -12 -12h-28c-6.62695 0 -12 5.37305 -12 12v28c0 6.62695 5.37305 12 12 12h28c6.62695 0 12 -5.37305 12 -12v-28zM506 260c0 -6.62695 -5.37305 -12 -12 -12h-28
 c-6.62695 0 -12 5.37305 -12 12v28c0 6.62695 5.37305 12 12 12h28c6.62695 0 12 -5.37305 12 -12v-28zM408 102c0 -6.62695 -5.37305 -12 -12 -12h-216c-6.62695 0 -12 5.37305 -12 12v16c0 6.62695 5.37305 12 12 12h216c6.62695 0 12 -5.37305 12 -12v-16z" />
    <glyph glyph-name="calendar" unicode="&#xf133;" horiz-adv-x="448" 
 d="M400 384c26.5 0 48 -21.5 48 -48v-352c0 -26.5 -21.5 -48 -48 -48h-352c-26.5 0 -48 21.5 -48 48v352c0 26.5 21.5 48 48 48h48v52c0 6.59961 5.40039 12 12 12h40c6.59961 0 12 -5.40039 12 -12v-52h128v52c0 6.59961 5.40039 12 12 12h40c6.59961 0 12 -5.40039 12 -12
 v-52h48zM394 -16c3.2998 0 6 2.7002 6 6v298h-352v-298c0 -3.2998 2.7002 -6 6 -6h340z" />
    <glyph glyph-name="play-circle" unicode="&#xf144;" 
 d="M371.7 210c16.3994 -9.2002 16.3994 -32.9004 0 -42l-176 -101c-15.9004 -8.7998 -35.7002 2.59961 -35.7002 21v208c0 18.5 19.9004 29.7998 35.7002 21zM504 192c0 -137 -111 -248 -248 -248s-248 111 -248 248s111 248 248 248s248 -111 248 -248zM56 192
 c0 -110.5 89.5 -200 200 -200s200 89.5 200 200s-89.5 200 -200 200s-200 -89.5 -200 -200z" />
    <glyph glyph-name="minus-square" unicode="&#xf146;" horiz-adv-x="448" 
 d="M108 164c-6.59961 0 -12 5.40039 -12 12v32c0 6.59961 5.40039 12 12 12h232c6.59961 0 12 -5.40039 12 -12v-32c0 -6.59961 -5.40039 -12 -12 -12h-232zM448 368v-352c0 -26.5 -21.5 -48 -48 -48h-352c-26.5 0 -48 21.5 -48 48v352c0 26.5 21.5 48 48 48h352
 c26.5 0 48 -21.5 48 -48zM400 22v340c0 3.2998 -2.7002 6 -6 6h-340c-3.2998 0 -6 -2.7002 -6 -6v-340c0 -3.2998 2.7002 -6 6 -6h340c3.2998 0 6 2.7002 6 6z" />
    <glyph glyph-name="check-square" unicode="&#xf14a;" horiz-adv-x="448" 
 d="M400 416c26.5098 0 48 -21.4902 48 -48v-352c0 -26.5098 -21.4902 -48 -48 -48h-352c-26.5098 0 -48 21.4902 -48 48v352c0 26.5098 21.4902 48 48 48h352zM400 16v352h-352v-352h352zM364.136 257.724l-172.589 -171.204
 c-4.70508 -4.66699 -12.3027 -4.63672 -16.9697 0.0683594l-90.7812 91.5156c-4.66699 4.70508 -4.63672 12.3037 0.0693359 16.9717l22.7188 22.5361c4.70508 4.66699 12.3027 4.63672 16.9697 -0.0693359l59.792 -60.2773l141.353 140.217
 c4.70508 4.66699 12.3027 4.63672 16.9697 -0.0683594l22.5361 -22.7178c4.66699 -4.70605 4.63672 -12.3047 -0.0683594 -16.9717z" />
    <glyph glyph-name="share-square" unicode="&#xf14d;" horiz-adv-x="576" 
 d="M561.938 289.94c18.75 -18.7402 18.75 -49.1406 0 -67.8809l-143.998 -144c-29.9727 -29.9727 -81.9404 -9.05273 -81.9404 33.9404v53.7998c-101.266 -7.83691 -99.625 -31.6406 -84.1104 -78.7598c14.2285 -43.0889 -33.4736 -79.248 -71.0195 -55.7402
 c-51.6924 32.3057 -84.8701 83.0635 -84.8701 144.76c0 39.3408 12.2197 72.7402 36.3301 99.3008c19.8398 21.8398 47.7402 38.4697 82.9102 49.4199c36.7295 11.4395 78.3096 16.1094 120.76 17.9893v57.1982c0 42.9355 51.9258 63.9541 81.9404 33.9404zM384 112l144 144
 l-144 144v-104.09c-110.86 -0.90332 -240 -10.5166 -240 -119.851c0 -52.1396 32.79 -85.6094 62.3096 -104.06c-39.8174 120.65 48.999 141.918 177.69 143.84v-103.84zM408.74 27.5068c6.14844 1.75684 15.5449 5.92383 20.9736 9.30273
 c7.97656 4.95215 18.2861 -0.825195 18.2861 -10.2139v-42.5957c0 -26.5098 -21.4902 -48 -48 -48h-352c-26.5098 0 -48 21.4902 -48 48v352c0 26.5098 21.4902 48 48 48h132c6.62695 0 12 -5.37305 12 -12v-4.48633c0 -4.91699 -2.9873 -9.36914 -7.56934 -11.1514
 c-13.7021 -5.33105 -26.3955 -11.5371 -38.0498 -18.585c-1.59668 -0.974609 -4.41016 -1.77051 -6.28027 -1.77734h-86.1006c-3.31152 0 -6 -2.68848 -6 -6v-340c0 -3.31152 2.68848 -6 6 -6h340c3.31152 0 6 2.68848 6 6v25.9658c0 5.37012 3.5791 10.0596 8.74023 11.541
 z" />
    <glyph glyph-name="compass" unicode="&#xf14e;" horiz-adv-x="496" 
 d="M347.94 318.14c16.6592 7.61035 33.8096 -9.54004 26.1992 -26.1992l-65.9697 -144.341c-2.73047 -5.97363 -9.7959 -13.0391 -15.7695 -15.7695l-144.341 -65.9697c-16.6592 -7.61035 -33.8096 9.5498 -26.1992 26.1992l65.9697 144.341
 c2.73047 5.97363 9.7959 13.0391 15.7695 15.7695zM270.58 169.42c12.4697 12.4697 12.4697 32.6904 0 45.1602s-32.6904 12.4697 -45.1602 0s-12.4697 -32.6904 0 -45.1602s32.6904 -12.4697 45.1602 0zM248 440c136.97 0 248 -111.03 248 -248s-111.03 -248 -248 -248
 s-248 111.03 -248 248s111.03 248 248 248zM248 -8c110.28 0 200 89.7197 200 200s-89.7197 200 -200 200s-200 -89.7197 -200 -200s89.7197 -200 200 -200z" />
    <glyph glyph-name="caret-square-down" unicode="&#xf150;" horiz-adv-x="448" 
 d="M125.1 240h197.801c10.6992 0 16.0996 -13 8.5 -20.5l-98.9004 -98.2998c-4.7002 -4.7002 -12.2002 -4.7002 -16.9004 0l-98.8994 98.2998c-7.7002 7.5 -2.2998 20.5 8.39941 20.5zM448 368v-352c0 -26.5 -21.5 -48 -48 -48h-352c-26.5 0 -48 21.5 -48 48v352
 c0 26.5 21.5 48 48 48h352c26.5 0 48 -21.5 48 -48zM400 22v340c0 3.2998 -2.7002 6 -6 6h-340c-3.2998 0 -6 -2.7002 -6 -6v-340c0 -3.2998 2.7002 -6 6 -6h340c3.2998 0 6 2.7002 6 6z" />
    <glyph glyph-name="caret-square-up" unicode="&#xf151;" horiz-adv-x="448" 
 d="M322.9 144h-197.801c-10.6992 0 -16.0996 13 -8.5 20.5l98.9004 98.2998c4.7002 4.7002 12.2002 4.7002 16.9004 0l98.8994 -98.2998c7.7002 -7.5 2.2998 -20.5 -8.39941 -20.5zM448 368v-352c0 -26.5 -21.5 -48 -48 -48h-352c-26.5 0 -48 21.5 -48 48v352
 c0 26.5 21.5 48 48 48h352c26.5 0 48 -21.5 48 -48zM400 22v340c0 3.2998 -2.7002 6 -6 6h-340c-3.2998 0 -6 -2.7002 -6 -6v-340c0 -3.2998 2.7002 -6 6 -6h340c3.2998 0 6 2.7002 6 6z" />
    <glyph glyph-name="caret-square-right" unicode="&#xf152;" horiz-adv-x="448" 
 d="M176 93.0996v197.801c0 10.6992 13 16.0996 20.5 8.5l98.2998 -98.9004c4.7002 -4.7002 4.7002 -12.2002 0 -16.9004l-98.2998 -98.8994c-7.5 -7.7002 -20.5 -2.2998 -20.5 8.39941zM448 368v-352c0 -26.5 -21.5 -48 -48 -48h-352c-26.5 0 -48 21.5 -48 48v352
 c0 26.5 21.5 48 48 48h352c26.5 0 48 -21.5 48 -48zM400 22v340c0 3.2998 -2.7002 6 -6 6h-340c-3.2998 0 -6 -2.7002 -6 -6v-340c0 -3.2998 2.7002 -6 6 -6h340c3.2998 0 6 2.7002 6 6z" />
    <glyph glyph-name="file" unicode="&#xf15b;" horiz-adv-x="384" 
 d="M369.9 350.1c9 -9 14.0996 -21.2998 14.0996 -34v-332.1c0 -26.5 -21.5 -48 -48 -48h-288c-26.5 0 -48 21.5 -48 48v416c0 26.5 21.5 48 48 48.0996h204.1c12.7002 0 24.9004 -5.09961 33.9004 -14.0996zM332.1 320l-76.0996 76.0996v-76.0996h76.0996zM48 -16h288v288
 h-104c-13.2998 0 -24 10.7002 -24 24v104h-160v-416z" />
    <glyph glyph-name="file-alt" unicode="&#xf15c;" horiz-adv-x="384" 
 d="M288 200v-28c0 -6.59961 -5.40039 -12 -12 -12h-168c-6.59961 0 -12 5.40039 -12 12v28c0 6.59961 5.40039 12 12 12h168c6.59961 0 12 -5.40039 12 -12zM276 128c6.59961 0 12 -5.40039 12 -12v-28c0 -6.59961 -5.40039 -12 -12 -12h-168c-6.59961 0 -12 5.40039 -12 12
 v28c0 6.59961 5.40039 12 12 12h168zM384 316.1v-332.1c0 -26.5 -21.5 -48 -48 -48h-288c-26.5 0 -48 21.5 -48 48v416c0 26.5 21.5 48 48 48h204.1c12.7002 0 24.9004 -5.09961 33.9004 -14.0996l83.9004 -83.9004c9 -8.90039 14.0996 -21.2002 14.0996 -33.9004z
 M256 396.1v-76.0996h76.0996zM336 -16v288h-104c-13.2998 0 -24 10.7002 -24 24v104h-160v-416h288z" />
    <glyph glyph-name="thumbs-up" unicode="&#xf164;" 
 d="M466.27 161.31c4.6748 -22.6465 0.864258 -44.5371 -8.98926 -62.9893c2.95898 -23.8682 -4.02148 -48.5654 -17.3398 -66.9902c-0.954102 -55.9072 -35.8232 -95.3301 -112.94 -95.3301c-7 0 -15 0.00976562 -22.2197 0.00976562
 c-102.742 0 -133.293 38.9395 -177.803 39.9404c-3.56934 -13.7764 -16.085 -23.9502 -30.9775 -23.9502h-64c-17.6729 0 -32 14.3271 -32 32v240c0 17.6729 14.3271 32 32 32h98.7598c19.1455 16.9531 46.0137 60.6533 68.7598 83.4004
 c13.667 13.667 10.1533 108.6 71.7607 108.6c57.5801 0 95.2695 -31.9355 95.2695 -104.73c0 -18.4092 -3.92969 -33.7295 -8.84961 -46.5391h36.4795c48.6025 0 85.8203 -41.5654 85.8203 -85.5801c0 -19.1504 -4.95996 -34.9902 -13.7305 -49.8408zM404.52 107.48
 c21.5811 20.3838 18.6992 51.0645 5.21094 65.6191c9.44922 0 22.3594 18.9102 22.2695 37.8105c-0.0898438 18.9102 -16.71 37.8203 -37.8203 37.8203h-103.989c0 37.8193 28.3594 55.3691 28.3594 94.5391c0 23.75 0 56.7305 -47.2695 56.7305
 c-18.9102 -18.9102 -9.45996 -66.1797 -37.8203 -94.54c-26.5596 -26.5703 -66.1797 -97.46 -94.54 -97.46h-10.9199v-186.17c53.6113 0 100.001 -37.8203 171.64 -37.8203h37.8203c35.5117 0 60.8203 17.1201 53.1201 65.9004
 c15.2002 8.16016 26.5 36.4395 13.9395 57.5703zM88 16c0 13.2549 -10.7451 24 -24 24s-24 -10.7451 -24 -24s10.7451 -24 24 -24s24 10.7451 24 24z" />
    <glyph glyph-name="thumbs-down" unicode="&#xf165;" 
 d="M466.27 222.69c8.77051 -14.8506 13.7305 -30.6904 13.7305 -49.8408c0 -44.0146 -37.2178 -85.5801 -85.8203 -85.5801h-36.4795c4.91992 -12.8096 8.84961 -28.1299 8.84961 -46.5391c0 -72.7949 -37.6895 -104.73 -95.2695 -104.73
 c-61.6074 0 -58.0938 94.9326 -71.7607 108.6c-22.7461 22.7471 -49.6133 66.4473 -68.7598 83.4004h-7.05176c-5.5332 -9.56152 -15.8662 -16 -27.708 -16h-64c-17.6729 0 -32 14.3271 -32 32v240c0 17.6729 14.3271 32 32 32h64c8.11328 0 15.5146 -3.02539 21.1553 -8
 h10.8447c40.9971 0 73.1953 39.9902 176.78 39.9902c7.21973 0 15.2197 0.00976562 22.2197 0.00976562c77.1172 0 111.986 -39.4229 112.94 -95.3301c13.3184 -18.4248 20.2979 -43.1221 17.3398 -66.9902c9.85352 -18.4521 13.6641 -40.3428 8.98926 -62.9893zM64 152
 c13.2549 0 24 10.7451 24 24s-10.7451 24 -24 24s-24 -10.7451 -24 -24s10.7451 -24 24 -24zM394.18 135.27c21.1104 0 37.7305 18.9102 37.8203 37.8203c0.0898438 18.9004 -12.8203 37.8105 -22.2695 37.8105c13.4883 14.5547 16.3701 45.2354 -5.21094 65.6191
 c12.5605 21.1309 1.26074 49.4102 -13.9395 57.5703c7.7002 48.7803 -17.6084 65.9004 -53.1201 65.9004h-37.8203c-71.6387 0 -118.028 -37.8203 -171.64 -37.8203v-186.17h10.9199c28.3604 0 67.9805 -70.8896 94.54 -97.46
 c28.3604 -28.3604 18.9102 -75.6299 37.8203 -94.54c47.2695 0 47.2695 32.9805 47.2695 56.7305c0 39.1699 -28.3594 56.7197 -28.3594 94.5391h103.989z" />
    <glyph glyph-name="sun" unicode="&#xf185;" 
 d="M494.2 226.1c11.2002 -7.59961 17.7998 -20.0996 17.8994 -33.6992c0 -13.4004 -6.69922 -26 -17.7998 -33.5l-59.7998 -40.5l13.7002 -71c2.5 -13.2002 -1.60059 -26.8008 -11.1006 -36.3008s-22.8994 -13.7998 -36.2998 -11.0996l-70.8994 13.7002l-40.4004 -59.9004
 c-7.5 -11.0996 -20.0996 -17.7998 -33.5 -17.7998s-26 6.7002 -33.5 17.9004l-40.4004 59.8994l-70.7998 -13.7002c-13.3994 -2.59961 -26.7998 1.60059 -36.2998 11.1006s-13.7002 23.0996 -11.0996 36.2998l13.6992 71l-59.7998 40.5
 c-11.0996 7.5 -17.7998 20 -17.7998 33.5s6.59961 26 17.7998 33.5996l59.7998 40.5l-13.6992 71c-2.60059 13.2002 1.59961 26.7002 11.0996 36.3008c9.5 9.59961 23 13.6992 36.2998 11.1992l70.7998 -13.6992l40.4004 59.8994c15.0996 22.2998 51.9004 22.2998 67 0
 l40.4004 -59.8994l70.8994 13.6992c13 2.60059 26.6006 -1.59961 36.2002 -11.0996c9.5 -9.59961 13.7002 -23.2002 11.0996 -36.4004l-13.6992 -71zM381.3 140.5l76.7998 52.0996l-76.7998 52l17.6006 91.1006l-91 -17.6006l-51.9004 76.9004l-51.7998 -76.7998
 l-91 17.5996l17.5996 -91.2002l-76.7998 -52l76.7998 -52l-17.5996 -91.1992l90.8994 17.5996l51.9004 -77l51.9004 76.9004l91 -17.6006zM256 296c57.2998 0 104 -46.7002 104 -104s-46.7002 -104 -104 -104s-104 46.7002 -104 104s46.7002 104 104 104zM256 136
 c30.9004 0 56 25.0996 56 56s-25.0996 56 -56 56s-56 -25.0996 -56 -56s25.0996 -56 56 -56z" />
    <glyph glyph-name="moon" unicode="&#xf186;" 
 d="M279.135 -64c-141.424 0 -256 114.64 -256 256c0 141.425 114.641 256 256 256c13.0068 -0.00195312 33.9443 -1.91797 46.7354 -4.27734c44.0205 -8.13086 53.7666 -66.8691 15.0215 -88.9189c-41.374 -23.5439 -67.4336 -67.4121 -67.4336 -115.836
 c0 -83.5234 75.9238 -146.475 158.272 -130.792c43.6904 8.32129 74.5186 -42.5693 46.248 -77.4004c-47.8613 -58.9717 -120.088 -94.7754 -198.844 -94.7754zM279.135 400c-114.875 0 -208 -93.125 -208 -208s93.125 -208 208 -208
 c65.2314 0 123.439 30.0361 161.575 77.0244c-111.611 -21.2568 -215.252 64.0957 -215.252 177.943c0 67.5127 36.9326 126.392 91.6934 157.555c-12.3271 2.27637 -25.0312 3.47754 -38.0166 3.47754z" />
    <glyph glyph-name="caret-square-left" unicode="&#xf191;" horiz-adv-x="448" 
 d="M272 290.9v-197.801c0 -10.6992 -13 -16.0996 -20.5 -8.5l-98.2998 98.9004c-4.7002 4.7002 -4.7002 12.2002 0 16.9004l98.2998 98.8994c7.5 7.7002 20.5 2.2998 20.5 -8.39941zM448 368v-352c0 -26.5 -21.5 -48 -48 -48h-352c-26.5 0 -48 21.5 -48 48v352
 c0 26.5 21.5 48 48 48h352c26.5 0 48 -21.5 48 -48zM400 22v340c0 3.2998 -2.7002 6 -6 6h-340c-3.2998 0 -6 -2.7002 -6 -6v-340c0 -3.2998 2.7002 -6 6 -6h340c3.2998 0 6 2.7002 6 6z" />
    <glyph glyph-name="dot-circle" unicode="&#xf192;" 
 d="M256 392c-110.549 0 -200 -89.4678 -200 -200c0 -110.549 89.4678 -200 200 -200c110.549 0 200 89.4678 200 200c0 110.549 -89.4678 200 -200 200zM256 440c136.967 0 248 -111.033 248 -248s-111.033 -248 -248 -248s-248 111.033 -248 248s111.033 248 248 248z
 M256 272c44.1826 0 80 -35.8174 80 -80s-35.8174 -80 -80 -80s-80 35.8174 -80 80s35.8174 80 80 80z" />
    <glyph glyph-name="building" unicode="&#xf1ad;" horiz-adv-x="448" 
 d="M128 300v40c0 6.59961 5.40039 12 12 12h40c6.59961 0 12 -5.40039 12 -12v-40c0 -6.59961 -5.40039 -12 -12 -12h-40c-6.59961 0 -12 5.40039 -12 12zM268 288c-6.59961 0 -12 5.40039 -12 12v40c0 6.59961 5.40039 12 12 12h40c6.59961 0 12 -5.40039 12 -12v-40
 c0 -6.59961 -5.40039 -12 -12 -12h-40zM140 192c-6.59961 0 -12 5.40039 -12 12v40c0 6.59961 5.40039 12 12 12h40c6.59961 0 12 -5.40039 12 -12v-40c0 -6.59961 -5.40039 -12 -12 -12h-40zM268 192c-6.59961 0 -12 5.40039 -12 12v40c0 6.59961 5.40039 12 12 12h40
 c6.59961 0 12 -5.40039 12 -12v-40c0 -6.59961 -5.40039 -12 -12 -12h-40zM192 108c0 -6.59961 -5.40039 -12 -12 -12h-40c-6.59961 0 -12 5.40039 -12 12v40c0 6.59961 5.40039 12 12 12h40c6.59961 0 12 -5.40039 12 -12v-40zM268 96c-6.59961 0 -12 5.40039 -12 12v40
 c0 6.59961 5.40039 12 12 12h40c6.59961 0 12 -5.40039 12 -12v-40c0 -6.59961 -5.40039 -12 -12 -12h-40zM448 -28v-36h-448v36c0 6.59961 5.40039 12 12 12h19.5v440c0 13.2998 10.7002 24 24 24h337c13.2998 0 24 -10.7002 24 -24v-440h19.5
 c6.59961 0 12 -5.40039 12 -12zM79.5 -15h112.5v67c0 6.59961 5.40039 12 12 12h40c6.59961 0 12 -5.40039 12 -12v-67h112.5v414l-288.5 1z" />
    <glyph glyph-name="file-pdf" unicode="&#xf1c1;" horiz-adv-x="384" 
 d="M369.9 350.1c9 -9 14.0996 -21.2998 14.0996 -34v-332.1c0 -26.5 -21.5 -48 -48 -48h-288c-26.5 0 -48 21.5 -48 48v416c0 26.5 21.5 48 48 48.0996h204.1c12.7002 0 24.9004 -5.09961 33.9004 -14.0996zM332.1 320l-76.0996 76.0996v-76.0996h76.0996zM48 -16h288v288
 h-104c-13.2998 0 -24 10.7002 -24 24v104h-160v-416zM298.2 127.7c10.5 -10.5 8 -38.7002 -17.5 -38.7002c-14.7998 0 -36.9004 6.7998 -55.7998 17c-21.6006 -3.59961 -46 -12.7002 -68.4004 -20.0996c-50.0996 -86.4004 -79.4004 -47 -76.0996 -31.2002
 c4 20 31 35.8994 51 46.2002c10.5 18.3994 25.3994 50.5 35.3994 74.3994c-7.39941 28.6006 -11.3994 51 -7 67.1006c4.7998 17.6992 38.4004 20.2998 42.6006 -5.90039c4.69922 -15.4004 -1.5 -39.9004 -5.40039 -56c8.09961 -21.2998 19.5996 -35.7998 36.7998 -46.2998
 c17.4004 2.2002 52.2002 5.5 64.4004 -6.5zM100.1 49.9004c0 -0.700195 11.4004 4.69922 30.4004 35c-5.90039 -5.5 -25.2998 -21.3008 -30.4004 -35zM181.7 240.5c-2.5 0 -2.60059 -26.9004 1.7998 -40.7998c4.90039 8.7002 5.59961 40.7998 -1.7998 40.7998zM157.3 103.9
 c15.9004 6.09961 34 14.8994 54.7998 19.1992c-11.1992 8.30078 -21.7998 20.4004 -30.0996 35.5c-6.7002 -17.6992 -15 -37.7998 -24.7002 -54.6992zM288.9 108.9c3.59961 2.39941 -2.2002 10.3994 -37.3008 7.7998c32.3008 -13.7998 37.3008 -7.7998 37.3008 -7.7998z" />
    <glyph glyph-name="file-word" unicode="&#xf1c2;" horiz-adv-x="384" 
 d="M369.9 350.1c9 -9 14.0996 -21.2998 14.0996 -34v-332.1c0 -26.5 -21.5 -48 -48 -48h-288c-26.5 0 -48 21.5 -48 48v416c0 26.5 21.5 48 48 48.0996h204.1c12.7002 0 24.9004 -5.09961 33.9004 -14.0996zM332.1 320l-76.0996 76.0996v-76.0996h76.0996zM48 -16h288v288
 h-104c-13.2998 0 -24 10.7002 -24 24v104h-160v-416zM268.1 192v0.200195h15.8008c7.7998 0 13.5 -7.2998 11.5996 -14.9004c-4.2998 -17 -13.7002 -54.0996 -34.5 -136c-1.2998 -5.39941 -6.09961 -9.09961 -11.5996 -9.09961h-24.7002
 c-5.5 0 -10.2998 3.7998 -11.6006 9.09961c-5.2998 20.9004 -17.7998 71 -17.8994 71.4004l-2.90039 17.2998c-0.5 -5.2998 -1.5 -11.0996 -3 -17.2998l-17.8994 -71.4004c-1.30078 -5.39941 -6.10059 -9.09961 -11.6006 -9.09961h-25.2002
 c-5.59961 0 -10.3994 3.7002 -11.6992 9.09961c-6.5 26.5 -25.2002 103.4 -33.2002 136c-1.7998 7.5 3.89941 14.7998 11.7002 14.7998h16.7998c5.7998 0 10.7002 -4.09961 11.7998 -9.69922c5 -25.7002 18.4004 -93.8008 19.0996 -99
 c0.300781 -1.7002 0.400391 -3.10059 0.5 -4.2002c0.800781 7.5 0.400391 4.7002 24.8008 103.7c1.39941 5.2998 6.19922 9.09961 11.6992 9.09961h13.3008c5.59961 0 10.3994 -3.7998 11.6992 -9.2002c23.9004 -99.7002 22.8008 -94.3994 23.6006 -99.5
 c0.299805 -1.7002 0.5 -3.09961 0.700195 -4.2998c0.599609 8.09961 0.399414 5.7998 21 103.5c1.09961 5.5 6 9.5 11.6992 9.5z" />
    <glyph glyph-name="file-excel" unicode="&#xf1c3;" horiz-adv-x="384" 
 d="M369.9 350.1c9 -9 14.0996 -21.2998 14.0996 -34v-332.1c0 -26.5 -21.5 -48 -48 -48h-288c-26.5 0 -48 21.5 -48 48v416c0 26.5 21.5 48 48 48.0996h204.1c12.7002 0 24.9004 -5.09961 33.9004 -14.0996zM332.1 320l-76.0996 76.0996v-76.0996h76.0996zM48 -16h288v288
 h-104c-13.2998 0 -24 10.7002 -24 24v104h-160v-416zM260 224c9.2002 0 15 -10 10.2998 -18c-16 -27.5 -45.5996 -76.9004 -46.2998 -78l46.4004 -78c4.59961 -8 -1.10059 -18 -10.4004 -18h-28.7998c-4.40039 0 -8.5 2.40039 -10.6006 6.2998
 c-22.6992 41.7998 -13.6992 27.5 -28.5996 57.7002c-5.59961 -12.7002 -6.90039 -17.7002 -28.5996 -57.7002c-2.10059 -3.89941 -6.10059 -6.2998 -10.5 -6.2998h-28.9004c-9.2998 0 -15.0996 10 -10.4004 18l46.3008 78l-46.3008 78c-4.59961 8 1.10059 18 10.4004 18
 h28.9004c4.39941 0 8.5 -2.40039 10.5996 -6.2998c21.7002 -40.4004 14.7002 -28.6006 28.5996 -57.7002c6.40039 15.2998 10.6006 24.5996 28.6006 57.7002c2.09961 3.89941 6.09961 6.2998 10.5 6.2998h28.7998z" />
    <glyph glyph-name="file-powerpoint" unicode="&#xf1c4;" horiz-adv-x="384" 
 d="M369.9 350.1c9 -9 14.0996 -21.2998 14.0996 -34v-332.1c0 -26.5 -21.5 -48 -48 -48h-288c-26.5 0 -48 21.5 -48 48v416c0 26.5 21.5 48 48 48.0996h204.1c12.7002 0 24.9004 -5.09961 33.9004 -14.0996zM332.1 320l-76.0996 76.0996v-76.0996h76.0996zM48 -16h288v288
 h-104c-13.2998 0 -24 10.7002 -24 24v104h-160v-416zM120 44v168c0 6.59961 5.40039 12 12 12h69.2002c36.7002 0 62.7998 -27 62.7998 -66.2998c0 -74.2998 -68.7002 -66.5 -95.5 -66.5v-47.2002c0 -6.59961 -5.40039 -12 -12 -12h-24.5c-6.59961 0 -12 5.40039 -12 12z
 M168.5 131.4h23c7.90039 0 13.9004 2.39941 18.0996 7.19922c8.5 9.80078 8.40039 28.5 0.100586 37.8008c-4.10059 4.59961 -9.90039 7 -17.4004 7h-23.8994v-52h0.0996094z" />
    <glyph glyph-name="file-image" unicode="&#xf1c5;" horiz-adv-x="384" 
 d="M369.9 350.1c9 -9 14.0996 -21.2998 14.0996 -34v-332.1c0 -26.5 -21.5 -48 -48 -48h-288c-26.5 0 -48 21.5 -48 48v416c0 26.5 21.5 48 48 48.0996h204.1c12.7002 0 24.9004 -5.09961 33.9004 -14.0996zM332.1 320l-76.0996 76.0996v-76.0996h76.0996zM48 -16h288v288
 h-104c-13.2998 0 -24 10.7002 -24 24v104h-160v-416zM80 32v64l39.5 39.5c4.7002 4.7002 12.2998 4.7002 17 0l39.5 -39.5l87.5 87.5c4.7002 4.7002 12.2998 4.7002 17 0l23.5 -23.5v-128h-224zM128 272c26.5 0 48 -21.5 48 -48s-21.5 -48 -48 -48s-48 21.5 -48 48
 s21.5 48 48 48z" />
    <glyph glyph-name="file-archive" unicode="&#xf1c6;" horiz-adv-x="384" 
 d="M128.3 288h32v-32h-32v32zM192.3 384v-32h-32v32h32zM128.3 352h32v-32h-32v32zM192.3 320v-32h-32v32h32zM369.9 350.1c9 -9 14.0996 -21.2998 14.0996 -34v-332.1c0 -26.5 -21.5 -48 -48 -48h-288c-26.5 0 -48 21.5 -48 48v416c0 26.5 21.5 48 48 48.0996h204.1
 c12.7002 0 24.9004 -5.09961 33.9004 -14.0996zM256 396.1v-76.0996h76.0996zM336 -16v288h-104c-13.2998 0 -24 10.7002 -24 24v104h-48.2998v-16h-32v16h-79.7002v-416h288zM194.2 182.3l17.2998 -87.7002c6.40039 -32.3994 -18.4004 -62.5996 -51.5 -62.5996
 c-33.2002 0 -58 30.4004 -51.4004 62.9004l19.7002 97.0996v32h32v-32h22.1006c5.7998 0 10.6992 -4.09961 11.7998 -9.7002zM160.3 57.9004c17.9004 0 32.4004 12.0996 32.4004 27c0 14.8994 -14.5 27 -32.4004 27c-17.8994 0 -32.3994 -12.1006 -32.3994 -27
 c0 -14.9004 14.5 -27 32.3994 -27zM192.3 256v-32h-32v32h32z" />
    <glyph glyph-name="file-audio" unicode="&#xf1c7;" horiz-adv-x="384" 
 d="M369.941 350.059c7.75977 -7.75977 14.0586 -22.9658 14.0586 -33.9404v-332.118c0 -26.5098 -21.4902 -48 -48 -48h-288c-26.5098 0 -48 21.4902 -48 48v416c0 26.5098 21.4902 48 48 48h204.118c10.9746 0 26.1807 -6.29883 33.9404 -14.0586zM332.118 320
 l-76.1182 76.1182v-76.1182h76.1182zM48 -16h288v288h-104c-13.2549 0 -24 10.7451 -24 24v104h-160v-416zM192 60.0244c0 -10.6914 -12.9258 -16.0459 -20.4854 -8.48535l-35.5146 35.9746h-28c-6.62695 0 -12 5.37305 -12 12v56c0 6.62695 5.37305 12 12 12h28
 l35.5146 36.9473c7.56055 7.56055 20.4854 2.20605 20.4854 -8.48535v-135.951zM233.201 107.154c9.05078 9.29688 9.05957 24.1328 0.000976562 33.4385c-22.1494 22.752 12.2344 56.2461 34.3945 33.4814c27.1982 -27.9404 27.2119 -72.4443 0.000976562 -100.401
 c-21.793 -22.3857 -56.9463 10.3154 -34.3965 33.4814z" />
    <glyph glyph-name="file-video" unicode="&#xf1c8;" horiz-adv-x="384" 
 d="M369.941 350.059c7.75977 -7.75977 14.0586 -22.9658 14.0586 -33.9404v-332.118c0 -26.5098 -21.4902 -48 -48 -48h-288c-26.5098 0 -48 21.4902 -48 48v416c0 26.5098 21.4902 48 48 48h204.118c10.9746 0 26.1807 -6.29883 33.9404 -14.0586zM332.118 320
 l-76.1182 76.1182v-76.1182h76.1182zM48 -16h288v288h-104c-13.2549 0 -24 10.7451 -24 24v104h-160v-416zM276.687 195.303c10.0049 10.0049 27.3135 2.99707 27.3135 -11.3135v-111.976c0 -14.2939 -17.2959 -21.332 -27.3135 -11.3135l-52.6865 52.6738v-37.374
 c0 -11.0459 -8.9541 -20 -20 -20h-104c-11.0459 0 -20 8.9541 -20 20v104c0 11.0459 8.9541 20 20 20h104c11.0459 0 20 -8.9541 20 -20v-37.374z" />
    <glyph glyph-name="file-code" unicode="&#xf1c9;" horiz-adv-x="384" 
 d="M149.9 98.9004c3.5 -3.30078 3.69922 -8.90039 0.399414 -12.4004l-17.3994 -18.5996c-1.60059 -1.80078 -4 -2.80078 -6.40039 -2.80078c-2.2002 0 -4.40039 0.900391 -6 2.40039l-57.7002 54.0996c-3.7002 3.40039 -3.7002 9.30078 0 12.8008l57.7002 54.0996
 c3.40039 3.2998 9 3.2002 12.4004 -0.400391l17.3994 -18.5996l0.200195 -0.200195c3.2002 -3.59961 2.7998 -9.2002 -0.799805 -12.3994l-32.7998 -28.9004l32.7998 -28.9004zM369.9 350.1c9 -9 14.0996 -21.2998 14.0996 -34v-332.1c0 -26.5 -21.5 -48 -48 -48h-288
 c-26.5 0 -48 21.5 -48 48v416c0 26.5 21.5 48 48 48.0996h204.1c12.7002 0 24.9004 -5.09961 33.9004 -14.0996zM256 396.1v-76.0996h76.0996zM336 -16v288h-104c-13.2998 0 -24 10.7002 -24 24v104h-160v-416h288zM209.6 234l24.4004 -7
 c4.7002 -1.2998 7.40039 -6.2002 6 -10.9004l-54.7002 -188.199c-1.2998 -4.60059 -6.2002 -7.40039 -10.8994 -6l-24.4004 7.09961c-4.7002 1.2998 -7.40039 6.2002 -6 10.9004l54.7002 188.1c1.39941 4.7002 6.2002 7.40039 10.8994 6zM234.1 157.1
 c-3.5 3.30078 -3.69922 8.90039 -0.399414 12.4004l17.3994 18.5996c3.30078 3.60059 8.90039 3.7002 12.4004 0.400391l57.7002 -54.0996c3.7002 -3.40039 3.7002 -9.30078 0 -12.8008l-57.7002 -54.0996c-3.5 -3.2998 -9.09961 -3.09961 -12.4004 0.400391
 l-17.3994 18.5996l-0.200195 0.200195c-3.2002 3.59961 -2.7998 9.2002 0.799805 12.3994l32.7998 28.9004l-32.7998 28.9004z" />
    <glyph glyph-name="life-ring" unicode="&#xf1cd;" 
 d="M256 -56c-136.967 0 -248 111.033 -248 248s111.033 248 248 248s248 -111.033 248 -248s-111.033 -248 -248 -248zM152.602 20.7197c63.2178 -38.3184 143.579 -38.3184 206.797 0l-53.4111 53.4111c-31.8467 -13.5215 -68.168 -13.5059 -99.9746 0zM336 192
 c0 44.1123 -35.8877 80 -80 80s-80 -35.8877 -80 -80s35.8877 -80 80 -80s80 35.8877 80 80zM427.28 88.6016c38.3184 63.2178 38.3184 143.579 0 206.797l-53.4111 -53.4111c13.5215 -31.8467 13.5049 -68.168 0 -99.9746zM359.397 363.28
 c-63.2168 38.3184 -143.578 38.3184 -206.796 0l53.4111 -53.4111c31.8457 13.5215 68.167 13.5049 99.9736 0zM84.7197 295.398c-38.3184 -63.2178 -38.3184 -143.579 0 -206.797l53.4111 53.4111c-13.5215 31.8467 -13.5059 68.168 0 99.9746z" />
    <glyph glyph-name="paper-plane" unicode="&#xf1d8;" 
 d="M440 441.5c34.5996 19.9004 77.5996 -8.7998 71.5 -48.9004l-59.4004 -387.199c-2.2998 -14.5 -11.0996 -27.3008 -23.8994 -34.5c-7.2998 -4.10059 -15.4004 -6.2002 -23.6006 -6.2002c-6.19922 0 -12.3994 1.2002 -18.2998 3.59961l-111.899 46.2002l-43.8008 -59.0996
 c-27.3994 -36.9004 -86.5996 -17.8008 -86.5996 28.5996v84.4004l-114.3 47.2998c-36.7998 15.0996 -40.1006 66 -5.7002 85.8994zM192 -16l36.5996 49.5l-36.5996 15.0996v-64.5996zM404.6 12.7002l59.4004 387.3l-416 -240l107.8 -44.5996l211.5 184.3
 c14.2002 12.2998 34.4004 -5.7002 23.7002 -21.2002l-140.2 -202.3z" />
    <glyph glyph-name="futbol" unicode="&#xf1e3;" horiz-adv-x="496" 
 d="M483.8 268.6c42.2998 -130.199 -29 -270.1 -159.2 -312.399c-25.5 -8.2998 -51.2998 -12.2002 -76.6992 -12.2002c-104.5 0 -201.7 66.5996 -235.7 171.4c-42.2998 130.199 29 270.1 159.2 312.399c25.5 8.2998 51.2998 12.2002 76.6992 12.2002
 c104.5 0 201.7 -66.5996 235.7 -171.4zM409.3 74.9004c6.10059 8.39941 12.1006 16.8994 16.7998 26.1992c14.3008 28.1006 21.5 58.5 21.7002 89.2002l-38.8994 36.4004l-71.1006 -22.1006l-24.3994 -75.1992l43.6992 -60.9004zM409.3 310.3
 c-24.5 33.4004 -58.7002 58.4004 -97.8994 71.4004l-47.4004 -26.2002v-73.7998l64.2002 -46.5l70.7002 22zM184.9 381.6c-39.9004 -13.2998 -73.5 -38.5 -97.8008 -71.8994l10.1006 -52.5l70.5996 -22l64.2002 46.5v73.7998zM139 68.5l43.5 61.7002l-24.2998 74.2998
 l-71.1006 22.2002l-39 -36.4004c0.5 -55.7002 23.4004 -95.2002 37.8008 -115.3zM187.2 1.5c64.0996 -20.4004 115.5 -1.7998 121.7 0l22.3994 48.0996l-44.2998 61.7002h-78.5996l-43.6006 -61.7002z" />
    <glyph glyph-name="newspaper" unicode="&#xf1ea;" horiz-adv-x="576" 
 d="M552 384c13.2549 0 24 -10.7451 24 -24v-336c0 -13.2549 -10.7451 -24 -24 -24h-496c-30.9277 0 -56 25.0723 -56 56v272c0 13.2549 10.7451 24 24 24h42.752c6.60547 18.623 24.3896 32 45.248 32h440zM48 56c0 -4.41113 3.58887 -8 8 -8s8 3.58887 8 8v248h-16v-248z
 M528 48v288h-416v-280c0 -2.7168 -0.204102 -5.38574 -0.578125 -8h416.578zM172 168c-6.62695 0 -12 5.37305 -12 12v96c0 6.62695 5.37305 12 12 12h136c6.62695 0 12 -5.37305 12 -12v-96c0 -6.62695 -5.37305 -12 -12 -12h-136zM200 248v-40h80v40h-80zM160 108v24
 c0 6.62695 5.37305 12 12 12h136c6.62695 0 12 -5.37305 12 -12v-24c0 -6.62695 -5.37305 -12 -12 -12h-136c-6.62695 0 -12 5.37305 -12 12zM352 108v24c0 6.62695 5.37305 12 12 12h104c6.62695 0 12 -5.37305 12 -12v-24c0 -6.62695 -5.37305 -12 -12 -12h-104
 c-6.62695 0 -12 5.37305 -12 12zM352 252v24c0 6.62695 5.37305 12 12 12h104c6.62695 0 12 -5.37305 12 -12v-24c0 -6.62695 -5.37305 -12 -12 -12h-104c-6.62695 0 -12 5.37305 -12 12zM352 180v24c0 6.62695 5.37305 12 12 12h104c6.62695 0 12 -5.37305 12 -12v-24
 c0 -6.62695 -5.37305 -12 -12 -12h-104c-6.62695 0 -12 5.37305 -12 12z" />
    <glyph glyph-name="bell-slash" unicode="&#xf1f6;" horiz-adv-x="640" 
 d="M633.99 -23.0195c6.91016 -5.52051 8.01953 -15.5908 2.5 -22.4902l-10 -12.4902c-5.53027 -6.88965 -15.5898 -8.00977 -22.4902 -2.49023l-598 467.51c-6.90039 5.52051 -8.01953 15.5908 -2.49023 22.4902l10 12.4902
 c5.52051 6.90039 15.5898 8.00977 22.4902 2.49023zM163.53 80h182.84l61.3994 -48h-279.659c-19.1201 0 -31.9902 15.5996 -32.1006 32c-0.0498047 7.5498 2.61035 15.2598 8.61035 21.71c18.3701 19.7402 51.5703 49.6904 54.8398 140.42l45.4697 -35.5498
 c-6.91992 -54.7803 -24.6895 -88.5498 -41.3994 -110.58zM320 352c-23.3496 0 -45 -7.17969 -62.9404 -19.4004l-38.1699 29.8408c19.6807 15.7793 43.1104 27.3096 69.1299 32.7197v20.8398c0 17.6699 14.3203 32 31.9805 32s31.9805 -14.3301 31.9805 -32v-20.8398
 c73.46 -15.2598 127.939 -77.46 127.939 -155.16c0 -41.3604 6.03027 -70.7197 14.3398 -92.8496l-59.5293 46.54c-1.63086 13.96 -2.77051 28.8896 -2.79004 45.7295c0 0.200195 0.0595703 0.379883 0.0595703 0.580078c0 61.8604 -50.1396 112 -112 112zM320 -64
 c-35.3203 0 -63.9697 28.6504 -63.9697 64h127.939c0 -35.3496 -28.6494 -64 -63.9697 -64z" />
    <glyph glyph-name="copyright" unicode="&#xf1f9;" 
 d="M256 440c136.967 0 248 -111.033 248 -248s-111.033 -248 -248 -248s-248 111.033 -248 248s111.033 248 248 248zM256 -8c110.549 0 200 89.4678 200 200c0 110.549 -89.4678 200 -200 200c-110.549 0 -200 -89.4688 -200 -200c0 -110.549 89.4678 -200 200 -200z
 M363.351 93.0645c-9.61328 -9.71289 -45.5293 -41.3965 -104.064 -41.3965c-82.4297 0 -140.484 61.4248 -140.484 141.567c0 79.1514 60.2754 139.4 139.763 139.4c55.5303 0 88.7373 -26.6201 97.5928 -34.7783c2.13379 -1.96289 3.86523 -5.9082 3.86523 -8.80762
 c0 -1.95508 -0.864258 -4.87402 -1.92969 -6.51465l-18.1543 -28.1133c-3.8418 -5.9502 -11.9668 -7.28223 -17.499 -2.9209c-8.5957 6.77637 -31.8145 22.5381 -61.708 22.5381c-48.3037 0 -77.916 -35.3301 -77.916 -80.082c0 -41.5889 26.8877 -83.6924 78.2764 -83.6924
 c32.6572 0 56.8428 19.0391 65.7266 27.2256c5.26953 4.85645 13.5957 4.03906 17.8193 -1.73828l19.8652 -27.1699c1.28613 -1.74512 2.33008 -4.91992 2.33008 -7.08789c0 -2.72363 -1.56055 -6.5 -3.48242 -8.42969z" />
    <glyph glyph-name="closed-captioning" unicode="&#xf20a;" 
 d="M464 384c26.5 0 48 -21.5 48 -48v-288c0 -26.5 -21.5 -48 -48 -48h-416c-26.5 0 -48 21.5 -48 48v288c0 26.5 21.5 48 48 48h416zM458 48c3.2998 0 6 2.7002 6 6v276c0 3.2998 -2.7002 6 -6 6h-404c-3.2998 0 -6 -2.7002 -6 -6v-276c0 -3.2998 2.7002 -6 6 -6h404z
 M246.9 133.7c1.69922 -2.40039 1.5 -5.60059 -0.5 -7.7002c-53.6006 -56.7998 -172.801 -32.0996 -172.801 67.9004c0 97.2998 121.7 119.5 172.5 70.0996c2.10059 -2 2.5 -3.2002 1 -5.7002l-17.5 -30.5c-1.89941 -3.09961 -6.19922 -4 -9.09961 -1.7002
 c-40.7998 32 -94.5996 14.9004 -94.5996 -31.1992c0 -48 51 -70.5 92.1992 -32.6006c2.80078 2.5 7.10059 2.10059 9.2002 -0.899414zM437.3 133.7c1.7002 -2.40039 1.5 -5.60059 -0.5 -7.7002c-53.5996 -56.9004 -172.8 -32.0996 -172.8 67.9004
 c0 97.2998 121.7 119.5 172.5 70.0996c2.09961 -2 2.5 -3.2002 1 -5.7002l-17.5 -30.5c-1.90039 -3.09961 -6.2002 -4 -9.09961 -1.7002c-40.8008 32 -94.6006 14.9004 -94.6006 -31.1992c0 -48 51 -70.5 92.2002 -32.6006c2.7998 2.5 7.09961 2.10059 9.2002 -0.899414z
 " />
    <glyph glyph-name="object-group" unicode="&#xf247;" 
 d="M500 320h-12v-256h12c6.62695 0 12 -5.37305 12 -12v-72c0 -6.62695 -5.37305 -12 -12 -12h-72c-6.62695 0 -12 5.37305 -12 12v12h-320v-12c0 -6.62695 -5.37305 -12 -12 -12h-72c-6.62695 0 -12 5.37305 -12 12v72c0 6.62695 5.37305 12 12 12h12v256h-12
 c-6.62695 0 -12 5.37305 -12 12v72c0 6.62695 5.37305 12 12 12h72c6.62695 0 12 -5.37305 12 -12v-12h320v12c0 6.62695 5.37305 12 12 12h72c6.62695 0 12 -5.37305 12 -12v-72c0 -6.62695 -5.37305 -12 -12 -12zM448 384v-32h32v32h-32zM32 384v-32h32v32h-32zM64 0v32
 h-32v-32h32zM480 0v32h-32v-32h32zM440 64v256h-12c-6.62695 0 -12 5.37305 -12 12v12h-320v-12c0 -6.62695 -5.37305 -12 -12 -12h-12v-256h12c6.62695 0 12 -5.37305 12 -12v-12h320v12c0 6.62695 5.37305 12 12 12h12zM404 256c6.62695 0 12 -5.37207 12 -12v-168
 c0 -6.62793 -5.37305 -12 -12 -12h-200c-6.62695 0 -12 5.37207 -12 12v52h-84c-6.62695 0 -12 5.37207 -12 12v168c0 6.62793 5.37305 12 12 12h200c6.62695 0 12 -5.37207 12 -12v-52h84zM136 280v-112h144v112h-144zM376 104v112h-56v-76
 c0 -6.62793 -5.37305 -12 -12 -12h-76v-24h144z" />
    <glyph glyph-name="object-ungroup" unicode="&#xf248;" horiz-adv-x="576" 
 d="M564 224h-12v-160h12c6.62695 0 12 -5.37305 12 -12v-72c0 -6.62695 -5.37305 -12 -12 -12h-72c-6.62695 0 -12 5.37305 -12 12v12h-224v-12c0 -6.62695 -5.37305 -12 -12 -12h-72c-6.62695 0 -12 5.37305 -12 12v72c0 6.62695 5.37305 12 12 12h12v24h-88v-12
 c0 -6.62695 -5.37305 -12 -12 -12h-72c-6.62695 0 -12 5.37305 -12 12v72c0 6.62695 5.37305 12 12 12h12v160h-12c-6.62695 0 -12 5.37305 -12 12v72c0 6.62695 5.37305 12 12 12h72c6.62695 0 12 -5.37305 12 -12v-12h224v12c0 6.62695 5.37305 12 12 12h72
 c6.62695 0 12 -5.37305 12 -12v-72c0 -6.62695 -5.37305 -12 -12 -12h-12v-24h88v12c0 6.62695 5.37305 12 12 12h72c6.62695 0 12 -5.37305 12 -12v-72c0 -6.62695 -5.37305 -12 -12 -12zM352 384v-32h32v32h-32zM352 128v-32h32v32h-32zM64 96v32h-32v-32h32zM64 352v32
 h-32v-32h32zM96 136h224v12c0 6.62695 5.37305 12 12 12h12v160h-12c-6.62695 0 -12 5.37305 -12 12v12h-224v-12c0 -6.62695 -5.37305 -12 -12 -12h-12v-160h12c6.62695 0 12 -5.37305 12 -12v-12zM224 0v32h-32v-32h32zM504 64v160h-12c-6.62695 0 -12 5.37305 -12 12v12
 h-88v-88h12c6.62695 0 12 -5.37305 12 -12v-72c0 -6.62695 -5.37305 -12 -12 -12h-72c-6.62695 0 -12 5.37305 -12 12v12h-88v-24h12c6.62695 0 12 -5.37305 12 -12v-12h224v12c0 6.62695 5.37305 12 12 12h12zM544 0v32h-32v-32h32zM544 256v32h-32v-32h32z" />
    <glyph glyph-name="sticky-note" unicode="&#xf249;" horiz-adv-x="448" 
 d="M448 99.8936c0 -10.9746 -6.29883 -26.1797 -14.0586 -33.9404l-83.8828 -83.8818c-7.75977 -7.76074 -22.9658 -14.0596 -33.9404 -14.0596h-268.118c-26.5098 0 -48 21.4902 -48 48v351.988c0 26.5098 21.4902 48 48 48h352c26.5098 0 48 -21.4902 48 -48v-268.106z
 M320 19.8936l76.1182 76.1182h-76.1182v-76.1182zM400 368h-352v-351.988h224v104c0 13.2549 10.7451 24 24 24h104v223.988z" />
    <glyph glyph-name="clone" unicode="&#xf24d;" 
 d="M464 448c26.5098 0 48 -21.4902 48 -48v-320c0 -26.5098 -21.4902 -48 -48 -48h-48v-48c0 -26.5098 -21.4902 -48 -48 -48h-320c-26.5098 0 -48 21.4902 -48 48v320c0 26.5098 21.4902 48 48 48h48v48c0 26.5098 21.4902 48 48 48h320zM362 -16c3.31152 0 6 2.68848 6 6
 v42h-224c-26.5098 0 -48 21.4902 -48 48v224h-42c-3.31152 0 -6 -2.68848 -6 -6v-308c0 -3.31152 2.68848 -6 6 -6h308zM458 80c3.31152 0 6 2.68848 6 6v308c0 3.31152 -2.68848 6 -6 6h-308c-3.31152 0 -6 -2.68848 -6 -6v-308c0 -3.31152 2.68848 -6 6 -6h308z" />
    <glyph glyph-name="hourglass" unicode="&#xf254;" horiz-adv-x="384" 
 d="M368 400c0 -80.0996 -31.8984 -165.619 -97.1797 -208c64.9912 -42.1934 97.1797 -127.436 97.1797 -208h4c6.62695 0 12 -5.37305 12 -12v-24c0 -6.62695 -5.37305 -12 -12 -12h-360c-6.62695 0 -12 5.37305 -12 12v24c0 6.62695 5.37305 12 12 12h4
 c0 80.0996 31.8994 165.619 97.1797 208c-64.9912 42.1934 -97.1797 127.436 -97.1797 208h-4c-6.62695 0 -12 5.37305 -12 12v24c0 6.62695 5.37305 12 12 12h360c6.62695 0 12 -5.37305 12 -12v-24c0 -6.62695 -5.37305 -12 -12 -12h-4zM64 400
 c0 -101.621 57.3066 -184 128 -184s128 82.3799 128 184h-256zM320 -16c0 101.62 -57.3076 184 -128 184s-128 -82.3799 -128 -184h256z" />
    <glyph glyph-name="hand-rock" unicode="&#xf255;" 
 d="M408.864 368.948c48.8213 20.751 103.136 -15.0723 103.136 -67.9111v-114.443c0 -15.3955 -3.08887 -30.3906 -9.18262 -44.5674l-42.835 -99.6562c-4.99707 -11.625 -3.98242 -18.8574 -3.98242 -42.3701c0 -17.6729 -14.3271 -32 -32 -32h-252
 c-17.6729 0 -32 14.3271 -32 32c0 27.3301 1.1416 29.2012 -3.11035 32.9033l-97.71 85.0811c-24.8994 21.6797 -39.1797 52.8926 -39.1797 85.6338v56.9531c0 47.4277 44.8457 82.0215 91.0459 71.1807c1.96094 55.751 63.5107 87.8262 110.671 60.8057
 c29.1895 31.0713 78.8604 31.4473 108.334 -0.0214844c32.7051 18.6846 76.4121 10.3096 98.8135 -23.5879zM464 186.594v114.445c0 34.29 -52 33.8232 -52 0.676758c0 -8.83594 -7.16309 -16 -16 -16h-7c-8.83691 0 -16 7.16406 -16 16v26.751
 c0 34.457 -52 33.707 -52 0.676758v-27.4287c0 -8.83594 -7.16309 -16 -16 -16h-7c-8.83691 0 -16 7.16406 -16 16v40.4658c0 34.3525 -52 33.8115 -52 0.677734v-41.1436c0 -8.83594 -7.16406 -16 -16 -16h-7c-8.83594 0 -16 7.16406 -16 16v26.751
 c0 34.4023 -52 33.7744 -52 0.676758v-116.571c0 -8.83203 -7.16797 -16 -16 -16c-3.30664 0 -8.01367 1.7627 -10.5068 3.93359l-7 6.09473c-3.03223 2.64062 -5.49316 8.04688 -5.49316 12.0674v0v41.2275c0 34.2148 -52 33.8857 -52 0.677734v-56.9531
 c0 -18.8555 8.27441 -36.874 22.7002 -49.4365l97.71 -85.0801c12.4502 -10.8398 19.5898 -26.4463 19.5898 -42.8164v-10.2861h220v7.07617c0 13.21 2.65332 26.0791 7.88281 38.25l42.835 99.6553c2.91602 6.75391 5.28223 18.207 5.28223 25.5635v0.0488281z" />
    <glyph glyph-name="hand-paper" unicode="&#xf256;" horiz-adv-x="448" 
 d="M372.57 335.359c39.9062 5.63281 75.4297 -25.7393 75.4297 -66.3594v-131.564c-0.00195312 -12.7666 -2.33008 -33.2246 -5.19531 -45.666l-30.1836 -130.958c-3.34668 -14.5234 -16.2783 -24.8125 -31.1816 -24.8125h-222.897
 c-9.10352 0 -20.7793 6.01758 -26.0615 13.4316l-119.97 168.415c-21.2441 29.8203 -14.8047 71.3574 14.5498 93.1533c18.7754 13.9395 42.1309 16.2979 62.083 8.87109v126.13c0 44.0547 41.125 75.5439 82.4053 64.9834c23.8926 48.1963 92.3535 50.2471 117.982 0.74707
 c42.5186 11.1445 83.0391 -21.9346 83.0391 -65.5469v-10.8242zM399.997 137.437l-0.00195312 131.563c0 24.9492 -36.5703 25.5508 -36.5703 -0.691406v-76.3086c0 -8.83691 -7.16309 -16 -16 -16h-6.85645c-8.83691 0 -16 7.16309 -16 16v154.184
 c0 25.501 -36.5703 26.3633 -36.5703 0.691406v-154.875c0 -8.83691 -7.16309 -16 -16 -16h-6.85645c-8.83691 0 -16 7.16309 -16 16v188.309c0 25.501 -36.5703 26.3545 -36.5703 0.691406v-189c0 -8.83691 -7.16309 -16 -16 -16h-6.85645c-8.83691 0 -16 7.16309 -16 16
 v153.309c0 25.501 -36.5713 26.3359 -36.5713 0.691406v-206.494c0 -15.5703 -20.0352 -21.9092 -29.0303 -9.2832l-27.1279 38.0791c-14.3711 20.1709 -43.833 -2.33496 -29.3945 -22.6045l115.196 -161.697h201.92l27.3252 118.551
 c2.63086 11.417 3.96484 23.1553 3.96484 34.8857z" />
    <glyph glyph-name="hand-scissors" unicode="&#xf257;" 
 d="M256 -32c-44.9561 0 -77.3428 43.2627 -64.0244 85.8535c-21.6484 13.71 -34.0156 38.7617 -30.3408 65.0068h-87.6348c-40.8037 0 -74 32.8105 -74 73.1406c0 40.3291 33.1963 73.1396 74 73.1396l94 -9.14062l-78.8496 18.6787
 c-38.3076 14.7422 -57.04 57.4707 -41.9424 95.1123c15.0303 37.4736 57.7549 55.7803 95.6416 41.2012l144.929 -55.7568c24.9551 30.5566 57.8086 43.9932 92.2178 24.7324l97.999 -54.8525c20.9746 -11.7393 34.0049 -33.8457 34.0049 -57.6904v-205.702
 c0 -30.7422 -21.4404 -57.5576 -51.7979 -64.5537l-118.999 -27.4268c-4.97168 -1.14648 -10.0889 -1.72949 -15.2031 -1.72949zM256 16.0127l70 -0.000976562c1.23633 0 3.21777 0.225586 4.42285 0.501953l119.001 27.4277
 c8.58203 1.97754 14.5762 9.29102 14.5762 17.7812v205.701c0 6.4873 -3.62109 12.542 -9.44922 15.8047l-98 54.8545c-8.13965 4.55566 -18.668 2.61914 -24.4873 -4.50781l-21.7646 -26.6475c-2.65039 -3.24512 -8.20215 -5.87891 -12.3926 -5.87891
 c-1.64062 0 -4.21484 0.477539 -5.74609 1.06738l-166.549 64.0908c-32.6543 12.5664 -50.7744 -34.5771 -19.2227 -46.7168l155.357 -59.7852c5.66016 -2.17773 10.2539 -8.86816 10.2539 -14.9326v0v-11.6328c0 -8.83691 -7.16309 -16 -16 -16h-182
 c-34.375 0 -34.4297 -50.2803 0 -50.2803h182c8.83691 0 16 -7.16309 16 -16v-6.85645c0 -8.83691 -7.16309 -16 -16 -16h-28c-25.1221 0 -25.1592 -36.5674 0 -36.5674h28c8.83691 0 16 -7.16211 16 -16v-6.85547c0 -8.83691 -7.16309 -16 -16 -16
 c-25.1201 0 -25.1602 -36.5674 0 -36.5674z" />
    <glyph glyph-name="hand-lizard" unicode="&#xf258;" horiz-adv-x="576" 
 d="M556.686 157.458c12.6357 -19.4863 19.3145 -42.0615 19.3145 -65.2871v-124.171h-224v71.582l-99.751 38.7871c-2.7832 1.08203 -5.70996 1.63086 -8.69727 1.63086h-131.552c-30.8789 0 -56 25.1211 -56 56c0 48.5234 39.4766 88 88 88h113.709l18.333 48h-196.042
 c-44.1123 0 -80 35.8877 -80 80v8c0 30.8779 25.1211 56 56 56h293.917c24.5 0 47.084 -12.2725 60.4111 -32.8291zM528 16v76.1709v0.0478516c0 11.7461 -5.19141 29.2734 -11.5879 39.124l-146.358 225.715c-4.44336 6.85254 -11.9707 10.9424 -20.1367 10.9424h-293.917
 c-4.41113 0 -8 -3.58887 -8 -8v-8c0 -17.6445 14.3555 -32 32 -32h213.471c25.2021 0 42.626 -25.293 33.6299 -48.8457l-24.5518 -64.2812c-7.05371 -18.4658 -25.0732 -30.873 -44.8398 -30.873h-113.709c-22.0557 0 -40 -17.9443 -40 -40c0 -4.41113 3.58887 -8 8 -8
 h131.552h0.0517578c7.44141 0 19.1074 -2.19238 26.041 -4.89355l99.752 -38.7881c18.5898 -7.22852 30.6035 -24.7881 30.6035 -44.7363v-23.582h128z" />
    <glyph glyph-name="hand-spock" unicode="&#xf259;" 
 d="M501.03 331.824c6.05762 -9.77832 10.9746 -27.0498 10.9746 -38.5518c0 -4.80664 -0.915039 -12.499 -2.04297 -17.1709l-57.623 -241.963c-12.748 -54.1729 -68.2627 -98.1387 -123.915 -98.1387h-0.345703h-107.455h-0.224609
 c-33.8135 0 -81.2148 18.834 -105.807 42.041l-91.3652 85.9766c-12.8213 12.0469 -23.2266 36.1016 -23.2266 53.6943c0 16.1299 8.97266 38.7529 20.0273 50.499c5.31836 5.66406 29.875 29.3926 68.1152 21.8477l-24.3594 82.1973
 c-1.68164 5.66406 -3.0459 15.0576 -3.0459 20.9668c0 37.5938 30.417 70.502 67.8955 73.4551c-0.204102 2.03125 -0.369141 5.33691 -0.369141 7.37891c0 31.627 24.8594 63.6895 55.4902 71.5684c43.248 10.9785 80.5645 -17.7012 89.6602 -53.0723l13.6836 -53.207
 l4.64648 22.6602c6.76074 32.417 39.123 58.8115 72.2373 58.916c8.73438 0 56.625 -3.26953 70.7383 -54.0801c15.0664 0.710938 46.9199 -3.50977 66.3105 -35.0176zM463.271 287.219c7.86914 32.9844 -42.1211 45.2695 -50.0859 11.9219l-24.8008 -104.146
 c-4.38867 -18.4141 -31.7783 -11.8926 -28.0557 6.2168l28.5479 139.166c7.39844 36.0703 -43.3076 45.0703 -50.1182 11.9629l-31.791 -154.971c-3.54883 -17.3086 -28.2832 -18.0469 -32.7109 -0.804688l-47.3262 184.035
 c-8.43359 32.8105 -58.3691 20.2676 -49.8652 -12.8359l42.4414 -165.039c4.81641 -18.7207 -23.3711 -26.9121 -28.9648 -8.00781l-31.3438 105.779c-9.6875 32.6465 -59.1191 18.2578 -49.3867 -14.625l36.0137 -121.539
 c5.61816 -18.9521 10.1777 -50.377 10.1777 -70.1436v-0.00878906c0 -6.54297 -8.05664 -10.9355 -13.4824 -5.82617l-51.123 48.1074c-24.7852 23.4082 -60.0527 -14.1875 -35.2793 -37.4902l91.3691 -85.9805c16.9629 -16.0068 49.6592 -28.998 72.9824 -28.998h0.154297
 h107.455h0.216797c34.7402 0 69.3936 27.4443 77.3525 61.2598z" />
    <glyph glyph-name="hand-pointer" unicode="&#xf25a;" horiz-adv-x="448" 
 d="M358.182 268.639c43.1934 16.6348 89.8184 -15.7949 89.8184 -62.6387v-84c-0.000976562 -4.25 -0.775391 -11.0615 -1.72754 -15.2041l-27.4297 -118.999c-6.98242 -30.2969 -33.7549 -51.7969 -64.5566 -51.7969h-178.286c-21.2588 0 -41.3682 10.4102 -53.791 27.8457
 l-109.699 154.001c-21.2432 29.8193 -14.8047 71.3574 14.5498 93.1523c18.8115 13.9658 42.1748 16.2822 62.083 8.87207v161.129c0 36.9443 29.7363 67 66.2861 67s66.2861 -30.0557 66.2861 -67v-73.6338c20.4131 2.85742 41.4678 -3.94238 56.5947 -19.6289
 c27.1934 12.8467 60.3799 5.66992 79.8721 -19.0986zM80.9854 168.303c-14.4004 20.2119 -43.8008 -2.38281 -29.3945 -22.6055l109.712 -154c3.43457 -4.81934 8.92871 -7.69727 14.6973 -7.69727h178.285c8.49219 0 15.8037 5.99414 17.7822 14.5762l27.4297 119.001
 c0.333008 1.44629 0.501953 2.93457 0.501953 4.42285v84c0 25.1602 -36.5713 25.1211 -36.5713 0c0 -8.83594 -7.16309 -16 -16 -16h-6.85645c-8.83691 0 -16 7.16406 -16 16v21c0 25.1602 -36.5713 25.1201 -36.5713 0v-21c0 -8.83594 -7.16309 -16 -16 -16h-6.85938
 c-8.83691 0 -16 7.16406 -16 16v35c0 25.1602 -36.5703 25.1201 -36.5703 0v-35c0 -8.83594 -7.16309 -16 -16 -16h-6.85742c-8.83691 0 -16 7.16406 -16 16v175c0 25.1602 -36.5713 25.1201 -36.5713 0v-241.493c0 -15.5703 -20.0352 -21.9092 -29.0303 -9.2832z
 M176.143 48v96c0 8.83691 6.26855 16 14 16h6c7.73242 0 14 -7.16309 14 -16v-96c0 -8.83691 -6.26758 -16 -14 -16h-6c-7.73242 0 -14 7.16309 -14 16zM251.571 48v96c0 8.83691 6.26758 16 14 16h6c7.73145 0 14 -7.16309 14 -16v-96c0 -8.83691 -6.26855 -16 -14 -16h-6
 c-7.73242 0 -14 7.16309 -14 16zM327 48v96c0 8.83691 6.26758 16 14 16h6c7.73242 0 14 -7.16309 14 -16v-96c0 -8.83691 -6.26758 -16 -14 -16h-6c-7.73242 0 -14 7.16309 -14 16z" />
    <glyph glyph-name="hand-peace" unicode="&#xf25b;" horiz-adv-x="448" 
 d="M362.146 256.024c42.5908 13.3184 85.8535 -19.0684 85.8535 -64.0244l-0.0117188 -70.001c-0.000976562 -4.25 -0.775391 -11.0615 -1.72949 -15.2031l-27.4268 -118.999c-6.99707 -30.3564 -33.8105 -51.7969 -64.5547 -51.7969h-205.702
 c-23.8447 0 -45.9502 13.0303 -57.6904 34.0059l-54.8525 97.999c-19.2607 34.4092 -5.82422 67.2617 24.7324 92.2178l-55.7568 144.928c-14.5791 37.8867 3.72754 80.6113 41.2012 95.6416c37.6406 15.0977 80.3691 -3.63477 95.1123 -41.9424l18.6787 -78.8496
 l-9.14062 94c0 40.8037 32.8096 74 73.1396 74s73.1406 -33.1963 73.1406 -74v-87.6348c26.2451 3.6748 51.2959 -8.69238 65.0068 -30.3408zM399.987 122l-0.000976562 70c0 25.1602 -36.5674 25.1201 -36.5674 0c0 -8.83691 -7.16309 -16 -16 -16h-6.85547
 c-8.83789 0 -16 7.16309 -16 16v28c0 25.1592 -36.5674 25.1221 -36.5674 0v-28c0 -8.83691 -7.16309 -16 -16 -16h-6.85645c-8.83691 0 -16 7.16309 -16 16v182c0 34.4297 -50.2803 34.375 -50.2803 0v-182c0 -8.83691 -7.16309 -16 -16 -16h-11.6328v0
 c-6.06445 0 -12.7549 4.59375 -14.9326 10.2539l-59.7842 155.357c-12.1396 31.5518 -59.2842 13.4326 -46.7168 -19.2227l64.0898 -166.549c0.589844 -1.53125 1.06738 -4.10547 1.06738 -5.74609c0 -4.19043 -2.63379 -9.74219 -5.87891 -12.3926l-26.6475 -21.7646
 c-7.12695 -5.81934 -9.06445 -16.3467 -4.50781 -24.4873l54.8535 -98c3.26367 -5.82812 9.31934 -9.44922 15.8057 -9.44922h205.701c8.49121 0 15.8037 5.99414 17.7812 14.5762l27.4277 119.001c0.333008 1.44629 0.501953 2.93457 0.501953 4.42285z" />
    <glyph glyph-name="registered" unicode="&#xf25d;" 
 d="M256 440c136.967 0 248 -111.033 248 -248s-111.033 -248 -248 -248s-248 111.033 -248 248s111.033 248 248 248zM256 -8c110.549 0 200 89.4678 200 200c0 110.549 -89.4678 200 -200 200c-110.549 0 -200 -89.4688 -200 -200c0 -110.549 89.4678 -200 200 -200z
 M366.442 73.791c4.40332 -7.99219 -1.37012 -17.791 -10.5107 -17.791h-42.8096h-0.0126953c-3.97559 0 -8.71582 2.84961 -10.5801 6.36035l-47.5156 89.3027h-31.958v-83.6631c0 -6.61719 -5.38281 -12 -12 -12h-38.5674c-6.61719 0 -12 5.38281 -12 12v248.304
 c0 6.61719 5.38281 12 12 12h78.667c71.251 0 101.498 -32.749 101.498 -85.252c0 -31.6123 -15.2148 -59.2969 -39.4824 -73.1758c3.02148 -4.61719 0.225586 0.199219 53.2715 -96.085zM256.933 208.094c20.9131 0 32.4307 11.5186 32.4316 32.4316
 c0 19.5752 -6.5127 31.709 -38.9297 31.709h-27.377v-64.1406h33.875z" />
    <glyph glyph-name="calendar-plus" unicode="&#xf271;" horiz-adv-x="448" 
 d="M336 156v-24c0 -6.59961 -5.40039 -12 -12 -12h-76v-76c0 -6.59961 -5.40039 -12 -12 -12h-24c-6.59961 0 -12 5.40039 -12 12v76h-76c-6.59961 0 -12 5.40039 -12 12v24c0 6.59961 5.40039 12 12 12h76v76c0 6.59961 5.40039 12 12 12h24c6.59961 0 12 -5.40039 12 -12
 v-76h76c6.59961 0 12 -5.40039 12 -12zM448 336v-352c0 -26.5 -21.5 -48 -48 -48h-352c-26.5 0 -48 21.5 -48 48v352c0 26.5 21.5 48 48 48h48v52c0 6.59961 5.40039 12 12 12h40c6.59961 0 12 -5.40039 12 -12v-52h128v52c0 6.59961 5.40039 12 12 12h40
 c6.59961 0 12 -5.40039 12 -12v-52h48c26.5 0 48 -21.5 48 -48zM400 -10v298h-352v-298c0 -3.2998 2.7002 -6 6 -6h340c3.2998 0 6 2.7002 6 6z" />
    <glyph glyph-name="calendar-minus" unicode="&#xf272;" horiz-adv-x="448" 
 d="M124 120c-6.59961 0 -12 5.40039 -12 12v24c0 6.59961 5.40039 12 12 12h200c6.59961 0 12 -5.40039 12 -12v-24c0 -6.59961 -5.40039 -12 -12 -12h-200zM448 336v-352c0 -26.5 -21.5 -48 -48 -48h-352c-26.5 0 -48 21.5 -48 48v352c0 26.5 21.5 48 48 48h48v52
 c0 6.59961 5.40039 12 12 12h40c6.59961 0 12 -5.40039 12 -12v-52h128v52c0 6.59961 5.40039 12 12 12h40c6.59961 0 12 -5.40039 12 -12v-52h48c26.5 0 48 -21.5 48 -48zM400 -10v298h-352v-298c0 -3.2998 2.7002 -6 6 -6h340c3.2998 0 6 2.7002 6 6z" />
    <glyph glyph-name="calendar-times" unicode="&#xf273;" horiz-adv-x="448" 
 d="M311.7 73.2998l-17 -17c-4.7002 -4.7002 -12.2998 -4.7002 -17 0l-53.7002 53.7998l-53.7002 -53.6992c-4.7002 -4.7002 -12.2998 -4.7002 -17 0l-17 17c-4.7002 4.69922 -4.7002 12.2998 0 17l53.7002 53.6992l-53.7002 53.7002c-4.7002 4.7002 -4.7002 12.2998 0 17
 l17 17c4.7002 4.7002 12.2998 4.7002 17 0l53.7002 -53.7002l53.7002 53.7002c4.7002 4.7002 12.2998 4.7002 17 0l17 -17c4.7002 -4.7002 4.7002 -12.2998 0 -17l-53.7998 -53.7998l53.6992 -53.7002c4.80078 -4.7002 4.80078 -12.2998 0.100586 -17zM448 336v-352
 c0 -26.5 -21.5 -48 -48 -48h-352c-26.5 0 -48 21.5 -48 48v352c0 26.5 21.5 48 48 48h48v52c0 6.59961 5.40039 12 12 12h40c6.59961 0 12 -5.40039 12 -12v-52h128v52c0 6.59961 5.40039 12 12 12h40c6.59961 0 12 -5.40039 12 -12v-52h48c26.5 0 48 -21.5 48 -48zM400 -10
 v298h-352v-298c0 -3.2998 2.7002 -6 6 -6h340c3.2998 0 6 2.7002 6 6z" />
    <glyph glyph-name="calendar-check" unicode="&#xf274;" horiz-adv-x="448" 
 d="M400 384c26.5098 0 48 -21.4902 48 -48v-352c0 -26.5098 -21.4902 -48 -48 -48h-352c-26.5098 0 -48 21.4902 -48 48v352c0 26.5098 21.4902 48 48 48h48v52c0 6.62695 5.37305 12 12 12h40c6.62695 0 12 -5.37305 12 -12v-52h128v52c0 6.62695 5.37305 12 12 12h40
 c6.62695 0 12 -5.37305 12 -12v-52h48zM394 -16c3.31152 0 6 2.68848 6 6v298h-352v-298c0 -3.31152 2.68848 -6 6 -6h340zM341.151 184.65l-142.31 -141.169c-4.70508 -4.66699 -12.3027 -4.6377 -16.9707 0.0673828l-75.0908 75.6992
 c-4.66699 4.70508 -4.6377 12.3027 0.0673828 16.9707l22.7197 22.5361c4.70508 4.66699 12.3027 4.63672 16.9697 -0.0693359l44.1035 -44.4609l111.072 110.182c4.70508 4.66699 12.3027 4.63672 16.9707 -0.0683594l22.5361 -22.7178
 c4.66699 -4.70508 4.63672 -12.3027 -0.0683594 -16.9697z" />
    <glyph glyph-name="map" unicode="&#xf279;" horiz-adv-x="576" 
 d="M560.02 416c8.4502 0 15.9805 -6.83008 15.9805 -16.0195v-346.32c0 -11.9609 -9.01367 -25.2705 -20.1201 -29.71l-151.83 -52.8105c-5.32617 -1.7334 -14.1953 -3.13965 -19.7969 -3.13965c-5.7373 0 -14.8105 1.47363 -20.2529 3.29004l-172 60.71l-170.05 -62.8398
 c-1.99023 -0.790039 -4 -1.16016 -5.95996 -1.16016c-8.45996 0 -15.9902 6.83008 -15.9902 16.0195v346.32c0.00292969 11.959 9.0166 25.2686 20.1201 29.71l151.83 52.8105c6.43945 2.08984 13.1201 3.13965 19.8096 3.13965
 c5.73242 -0.00195312 14.8008 -1.47168 20.2402 -3.28027l172 -60.7197h0.00976562l170.05 62.8398c1.98047 0.790039 4 1.16016 5.95996 1.16016zM224 357.58v-285.97l128 -45.1904v285.97zM48 29.9502l127.36 47.0801l0.639648 0.229492v286.2l-128 -44.5303v-288.979z
 M528 65.0801v288.97l-127.36 -47.0693l-0.639648 -0.240234v-286.19z" />
    <glyph glyph-name="comment-alt" unicode="&#xf27a;" 
 d="M448 448c35.2998 0 64 -28.7002 64 -64v-288c0 -35.2998 -28.7002 -64 -64 -64h-144l-124.9 -93.5996c-2.19922 -1.7002 -4.69922 -2.40039 -7.09961 -2.40039c-6.2002 0 -12 4.90039 -12 12v84h-96c-35.2998 0 -64 28.7002 -64 64v288c0 35.2998 28.7002 64 64 64h384z
 M464 96v288c0 8.7998 -7.2002 16 -16 16h-384c-8.7998 0 -16 -7.2002 -16 -16v-288c0 -8.7998 7.2002 -16 16 -16h144v-60l67.2002 50.4004l12.7998 9.59961h160c8.7998 0 16 7.2002 16 16z" />
    <glyph glyph-name="pause-circle" unicode="&#xf28b;" 
 d="M256 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM256 -8c110.5 0 200 89.5 200 200s-89.5 200 -200 200s-200 -89.5 -200 -200s89.5 -200 200 -200zM352 272v-160c0 -8.7998 -7.2002 -16 -16 -16h-48
 c-8.7998 0 -16 7.2002 -16 16v160c0 8.7998 7.2002 16 16 16h48c8.7998 0 16 -7.2002 16 -16zM240 272v-160c0 -8.7998 -7.2002 -16 -16 -16h-48c-8.7998 0 -16 7.2002 -16 16v160c0 8.7998 7.2002 16 16 16h48c8.7998 0 16 -7.2002 16 -16z" />
    <glyph glyph-name="stop-circle" unicode="&#xf28d;" 
 d="M504 192c0 -137 -111 -248 -248 -248s-248 111 -248 248s111 248 248 248s248 -111 248 -248zM56 192c0 -110.5 89.5 -200 200 -200s200 89.5 200 200s-89.5 200 -200 200s-200 -89.5 -200 -200zM352 272v-160c0 -8.7998 -7.2002 -16 -16 -16h-160
 c-8.7998 0 -16 7.2002 -16 16v160c0 8.7998 7.2002 16 16 16h160c8.7998 0 16 -7.2002 16 -16z" />
    <glyph glyph-name="handshake" unicode="&#xf2b5;" horiz-adv-x="640" 
 d="M519.2 320.1h120.8v-255.699h-64c-17.5 0 -31.7998 14.1992 -31.9004 31.6992h-57.8994c-1.7998 -8.19922 -5.2998 -16.0996 -10.9004 -23l-26.2002 -32.2998c-15.7998 -19.3994 -41.8994 -25.5 -64 -16.7998c-13.5 -16.5996 -30.5996 -24 -48.7998 -24
 c-15.0996 0 -28.5996 5.09961 -41.0996 15.9004c-31.7998 -21.9004 -74.7002 -21.3008 -105.601 3.7998l-84.5996 76.3994h-9.09961c-0.100586 -17.5 -14.3008 -31.6992 -31.9004 -31.6992h-64v255.699h118l47.5996 47.6006c10.5 10.3994 24.8008 16.2998 39.6006 16.2998
 h226.8v0c12.7812 0 30.5225 -7.30273 39.5996 -16.2998zM48 96.4004c8.7998 0 16 7.09961 16 16c0 8.7998 -7.2002 16 -16 16s-16 -7.2002 -16 -16c0 -8.80078 7.2002 -16 16 -16zM438 103.3c2.7002 3.40039 2.2002 8.5 -1.2002 11.2998l-108.2 87.8008l-8.19922 -7.5
 c-40.3008 -36.8008 -86.7002 -11.8008 -101.5 4.39941c-26.7002 29 -25 74.4004 4.39941 101.3l38.7002 35.5h-56.7002c-2 -0.799805 -3.7002 -1.5 -5.7002 -2.2998l-61.6992 -61.5996h-41.9004v-128.101h27.7002l97.2998 -88
 c16.0996 -13.0996 41.4004 -10.5 55.2998 6.60059l15.6006 19.2002l36.7998 -31.5c3 -2.40039 12 -4.90039 18 2.39941l30 36.5l23.8994 -19.3994c3.5 -2.80078 8.5 -2.2002 11.3008 1.19922zM544 144.1v128h-44.7002l-61.7002 61.6006
 c-1.39941 1.5 -3.39941 2.2998 -5.5 2.2998l-83.6992 -0.200195c-10 0 -19.6006 -3.7002 -27 -10.5l-65.6006 -60.0996c-9.7002 -8.7998 -10.5 -24 -1.2002 -33.9004c8.90039 -9.39941 25.1006 -8.7002 34.6006 0l55.2002 50.6006c6.5 5.89941 16.5996 5.5 22.5996 -1
 l10.9004 -11.7002c6 -6.5 5.5 -16.6006 -1 -22.6006l-12.5 -11.3994l102.699 -83.4004c2.80078 -2.2998 5.40039 -4.89941 7.7002 -7.7002h69.2002zM592 96.4004c8.7998 0 16 7.09961 16 16c0 8.7998 -7.2002 16 -16 16s-16 -7.2002 -16 -16c0 -8.80078 7.2002 -16 16 -16z
 " />
    <glyph glyph-name="envelope-open" unicode="&#xf2b6;" 
 d="M494.586 283.484c9.6123 -7.94824 17.4141 -24.5205 17.4141 -36.9932v-262.491c0 -26.5098 -21.4902 -48 -48 -48h-416c-26.5098 0 -48 21.4902 -48 48v262.515c0 12.5166 7.84668 29.1279 17.5146 37.0771c4.08008 3.35449 110.688 89.0996 135.15 108.549
 c22.6992 18.1426 60.1299 55.8594 103.335 55.8594c43.4365 0 81.2314 -38.1914 103.335 -55.8594c23.5283 -18.707 130.554 -104.773 135.251 -108.656zM464 -10v253.632v0.00488281c0 1.5791 -0.996094 3.66602 -2.22363 4.6582
 c-15.8633 12.8232 -108.793 87.5752 -132.366 106.316c-17.5527 14.0195 -49.7168 45.3887 -73.4102 45.3887c-23.6016 0 -55.2451 -30.8799 -73.4102 -45.3887c-23.5713 -18.7393 -116.494 -93.4795 -132.364 -106.293
 c-1.40918 -1.13965 -2.22559 -2.85254 -2.22559 -4.66504v-253.653c0 -3.31152 2.68848 -6 6 -6h404c3.31152 0 6 2.68848 6 6zM432.009 177.704c4.24902 -5.15918 3.46484 -12.7949 -1.74512 -16.9814c-28.9746 -23.2822 -59.2734 -47.5967 -70.9287 -56.8623
 c-22.6992 -18.1436 -60.1299 -55.8604 -103.335 -55.8604c-43.4521 0 -81.2871 38.2373 -103.335 55.8604c-11.2793 8.9668 -41.7441 33.4131 -70.9268 56.8643c-5.20996 4.1875 -5.99316 11.8223 -1.74512 16.9814l15.2578 18.5283
 c4.17773 5.07227 11.6572 5.84277 16.7793 1.72559c28.6182 -23.001 58.5654 -47.0352 70.5596 -56.5713c17.5527 -14.0195 49.7168 -45.3887 73.4102 -45.3887c23.6016 0 55.2461 30.8799 73.4102 45.3887c11.9941 9.53516 41.9434 33.5703 70.5625 56.5684
 c5.12207 4.11621 12.6016 3.3457 16.7783 -1.72656z" />
    <glyph glyph-name="address-book" unicode="&#xf2b9;" horiz-adv-x="448" 
 d="M436 288h-20v-64h20c6.59961 0 12 -5.40039 12 -12v-40c0 -6.59961 -5.40039 -12 -12 -12h-20v-64h20c6.59961 0 12 -5.40039 12 -12v-40c0 -6.59961 -5.40039 -12 -12 -12h-20v-48c0 -26.5 -21.5 -48 -48 -48h-320c-26.5 0 -48 21.5 -48 48v416c0 26.5 21.5 48 48 48
 h320c26.5 0 48 -21.5 48 -48v-48h20c6.59961 0 12 -5.40039 12 -12v-40c0 -6.59961 -5.40039 -12 -12 -12zM368 -16v416h-320v-416h320zM208 192c-35.2998 0 -64 28.7002 -64 64s28.7002 64 64 64s64 -28.7002 64 -64s-28.7002 -64 -64 -64zM118.4 64
 c-12.4004 0 -22.4004 8.59961 -22.4004 19.2002v19.2002c0 31.7998 30.0996 57.5996 67.2002 57.5996c11.3994 0 17.8994 -8 44.7998 -8c26.0996 0 34 8 44.7998 8c37.1006 0 67.2002 -25.7998 67.2002 -57.5996v-19.2002c0 -10.6006 -10 -19.2002 -22.4004 -19.2002
 h-179.199z" />
    <glyph glyph-name="address-card" unicode="&#xf2bb;" horiz-adv-x="576" 
 d="M528 416c26.5 0 48 -21.5 48 -48v-352c0 -26.5 -21.5 -48 -48 -48h-480c-26.5 0 -48 21.5 -48 48v352c0 26.5 21.5 48 48 48h480zM528 16v352h-480v-352h480zM208 192c-35.2998 0 -64 28.7002 -64 64s28.7002 64 64 64s64 -28.7002 64 -64s-28.7002 -64 -64 -64z
 M118.4 64c-12.4004 0 -22.4004 8.59961 -22.4004 19.2002v19.2002c0 31.7998 30.0996 57.5996 67.2002 57.5996c11.3994 0 17.8994 -8 44.7998 -8c26.0996 0 34 8 44.7998 8c37.1006 0 67.2002 -25.7998 67.2002 -57.5996v-19.2002
 c0 -10.6006 -10 -19.2002 -22.4004 -19.2002h-179.199zM360 128c-4.40039 0 -8 3.59961 -8 8v16c0 4.40039 3.59961 8 8 8h112c4.40039 0 8 -3.59961 8 -8v-16c0 -4.40039 -3.59961 -8 -8 -8h-112zM360 192c-4.40039 0 -8 3.59961 -8 8v16c0 4.40039 3.59961 8 8 8h112
 c4.40039 0 8 -3.59961 8 -8v-16c0 -4.40039 -3.59961 -8 -8 -8h-112zM360 256c-4.40039 0 -8 3.59961 -8 8v16c0 4.40039 3.59961 8 8 8h112c4.40039 0 8 -3.59961 8 -8v-16c0 -4.40039 -3.59961 -8 -8 -8h-112z" />
    <glyph glyph-name="user-circle" unicode="&#xf2bd;" horiz-adv-x="496" 
 d="M248 344c53 0 96 -43 96 -96s-43 -96 -96 -96s-96 43 -96 96s43 96 96 96zM248 200c26.5 0 48 21.5 48 48s-21.5 48 -48 48s-48 -21.5 -48 -48s21.5 -48 48 -48zM248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8
 c49.7002 0 95.0996 18.2998 130.1 48.4004c-14.8994 23 -40.3994 38.5 -69.5996 39.5c-20.7998 -6.5 -40.5996 -9.60059 -60.5 -9.60059s-39.7002 3.2002 -60.5 9.60059c-29.2002 -0.900391 -54.7002 -16.5 -69.5996 -39.5c35 -30.1006 80.3994 -48.4004 130.1 -48.4004z
 M410.7 76.0996c23.3994 32.7002 37.2998 72.7002 37.2998 115.9c0 110.3 -89.7002 200 -200 200s-200 -89.7002 -200 -200c0 -43.2002 13.9004 -83.2002 37.2998 -115.9c24.5 31.4004 62.2002 51.9004 105.101 51.9004c10.1992 0 26.0996 -9.59961 57.5996 -9.59961
 c31.5996 0 47.4004 9.59961 57.5996 9.59961c43 0 80.7002 -20.5 105.101 -51.9004z" />
    <glyph glyph-name="id-badge" unicode="&#xf2c1;" horiz-adv-x="384" 
 d="M336 448c26.5 0 48 -21.5 48 -48v-416c0 -26.5 -21.5 -48 -48 -48h-288c-26.5 0 -48 21.5 -48 48v416c0 26.5 21.5 48 48 48h288zM336 -16v416h-288v-416h288zM144 336c-8.7998 0 -16 7.2002 -16 16s7.2002 16 16 16h96c8.7998 0 16 -7.2002 16 -16s-7.2002 -16 -16 -16
 h-96zM192 160c-35.2998 0 -64 28.7002 -64 64s28.7002 64 64 64s64 -28.7002 64 -64s-28.7002 -64 -64 -64zM102.4 32c-12.4004 0 -22.4004 8.59961 -22.4004 19.2002v19.2002c0 31.7998 30.0996 57.5996 67.2002 57.5996c11.3994 0 17.8994 -8 44.7998 -8
 c26.0996 0 34 8 44.7998 8c37.1006 0 67.2002 -25.7998 67.2002 -57.5996v-19.2002c0 -10.6006 -10 -19.2002 -22.4004 -19.2002h-179.199z" />
    <glyph glyph-name="id-card" unicode="&#xf2c2;" horiz-adv-x="576" 
 d="M528 416c26.5 0 48 -21.5 48 -48v-352c0 -26.5 -21.5 -48 -48 -48h-480c-26.5 0 -48 21.5 -48 48v352c0 26.5 21.5 48 48 48h480zM528 16v288h-480v-288h32.7998c-1 4.5 -0.799805 -3.59961 -0.799805 22.4004c0 31.7998 30.0996 57.5996 67.2002 57.5996
 c11.3994 0 17.8994 -8 44.7998 -8c26.0996 0 34 8 44.7998 8c37.1006 0 67.2002 -25.7998 67.2002 -57.5996c0 -26 0.0996094 -17.9004 -0.799805 -22.4004h224.8zM360 96c-4.40039 0 -8 3.59961 -8 8v16c0 4.40039 3.59961 8 8 8h112c4.40039 0 8 -3.59961 8 -8v-16
 c0 -4.40039 -3.59961 -8 -8 -8h-112zM360 160c-4.40039 0 -8 3.59961 -8 8v16c0 4.40039 3.59961 8 8 8h112c4.40039 0 8 -3.59961 8 -8v-16c0 -4.40039 -3.59961 -8 -8 -8h-112zM360 224c-4.40039 0 -8 3.59961 -8 8v16c0 4.40039 3.59961 8 8 8h112
 c4.40039 0 8 -3.59961 8 -8v-16c0 -4.40039 -3.59961 -8 -8 -8h-112zM192 128c-35.2998 0 -64 28.7002 -64 64s28.7002 64 64 64s64 -28.7002 64 -64s-28.7002 -64 -64 -64z" />
    <glyph glyph-name="window-maximize" unicode="&#xf2d0;" 
 d="M464 416c26.5 0 48 -21.5 48 -48v-352c0 -26.5 -21.5 -48 -48 -48h-416c-26.5 0 -48 21.5 -48 48v352c0 26.5 21.5 48 48 48h416zM464 22v234h-416v-234c0 -3.2998 2.7002 -6 6 -6h404c3.2998 0 6 2.7002 6 6z" />
    <glyph glyph-name="window-minimize" unicode="&#xf2d1;" 
 d="M480 -32h-448c-17.7002 0 -32 14.2998 -32 32s14.2998 32 32 32h448c17.7002 0 32 -14.2998 32 -32s-14.2998 -32 -32 -32z" />
    <glyph glyph-name="window-restore" unicode="&#xf2d2;" 
 d="M464 448c26.5 0 48 -21.5 48 -48v-320c0 -26.5 -21.5 -48 -48 -48h-48v-48c0 -26.5 -21.5 -48 -48 -48h-320c-26.5 0 -48 21.5 -48 48v320c0 26.5 21.5 48 48 48h48v48c0 26.5 21.5 48 48 48h320zM368 -16v208h-320v-208h320zM464 80v320h-320v-48h224
 c26.5 0 48 -21.5 48 -48v-224h48z" />
    <glyph glyph-name="snowflake" unicode="&#xf2dc;" horiz-adv-x="448" 
 d="M440.1 92.7998c7.60059 -4.39941 10.1006 -14.2002 5.5 -21.7002l-7.89941 -13.8994c-4.40039 -7.7002 -14 -10.2998 -21.5 -5.90039l-39.2002 23l9.09961 -34.7002c2.30078 -8.5 -2.69922 -17.2998 -11.0996 -19.5996l-15.2002 -4.09961
 c-8.39941 -2.30078 -17.0996 2.7998 -19.2998 11.2998l-21.2998 81l-71.9004 42.2002v-84.5l58.2998 -59.3008c6.10059 -6.19922 6.10059 -16.3994 0 -22.5996l-11.0996 -11.2998c-6.09961 -6.2002 -16.0996 -6.2002 -22.2002 0l-24.8994 25.3994v-46.0996
 c0 -8.7998 -7 -16 -15.7002 -16h-15.7002c-8.7002 0 -15.7002 7.2002 -15.7002 16v45.9004l-24.8994 -25.4004c-6.10059 -6.2002 -16.1006 -6.2002 -22.2002 0l-11.1006 11.2998c-6.09961 6.2002 -6.09961 16.4004 0 22.6006l58.3008 59.2998v84.5l-71.9004 -42.2002
 l-21.2998 -81c-2.2998 -8.5 -10.9004 -13.5996 -19.2998 -11.2998l-15.2002 4.09961c-8.40039 2.2998 -13.2998 11.1006 -11.1006 19.6006l9.10059 34.6992l-39.2002 -23c-7.5 -4.39941 -17.2002 -1.7998 -21.5 5.90039l-7.90039 13.9004
 c-4.2998 7.69922 -1.69922 17.5 5.80078 21.8994l39.1992 23l-34.0996 9.2998c-8.40039 2.30078 -13.2998 11.1006 -11.0996 19.6006l4.09961 15.5c2.2998 8.5 10.9004 13.5996 19.2998 11.2998l79.7002 -21.7002l71.9004 42.2002l-71.9004 42.2002l-79.7002 -21.7002
 c-8.39941 -2.2998 -17.0996 2.7998 -19.2998 11.2998l-4.09961 15.5c-2.30078 8.5 2.69922 17.2998 11.0996 19.6006l34.0996 9.09961l-39.1992 23c-7.60059 4.5 -10.1006 14.2002 -5.80078 21.9004l7.90039 13.8994c4.40039 7.7002 14 10.2998 21.5 5.90039l39.2002 -23
 l-9.10059 34.7002c-2.2998 8.5 2.7002 17.2998 11.1006 19.5996l15.2002 4.09961c8.39941 2.30078 17.0996 -2.7998 19.2998 -11.2998l21.2998 -81l71.9004 -42.2002v84.5l-58.3008 59.3008c-6.09961 6.19922 -6.09961 16.3994 0 22.5996l11.5 11.2998
 c6.10059 6.2002 16.1006 6.2002 22.2002 0l24.9004 -25.3994v46.0996c0 8.7998 7 16 15.7002 16h15.6992c8.7002 0 15.7002 -7.2002 15.7002 -16v-45.9004l24.9004 25.4004c6.09961 6.2002 16.0996 6.2002 22.2002 0l11.0996 -11.2998
 c6.09961 -6.2002 6.09961 -16.4004 0 -22.6006l-58.2998 -59.2998v-84.5l71.8994 42.2002l21.3008 81c2.2998 8.5 10.8994 13.5996 19.2998 11.2998l15.2002 -4.09961c8.39941 -2.2998 13.2998 -11.1006 11.0996 -19.6006l-9.09961 -34.6992l39.1992 23
 c7.5 4.39941 17.2002 1.7998 21.5 -5.90039l7.90039 -13.9004c4.2998 -7.69922 1.7002 -17.5 -5.7998 -21.8994l-39.2002 -23l34.0996 -9.2998c8.40039 -2.30078 13.3008 -11.1006 11.1006 -19.6006l-4.10059 -15.5c-2.2998 -8.5 -10.8994 -13.5996 -19.2998 -11.2998
 l-79.7002 21.7002l-71.8994 -42.2002l71.7998 -42.2002l79.7002 21.7002c8.39941 2.2998 17.0996 -2.7998 19.2998 -11.2998l4.09961 -15.5c2.30078 -8.5 -2.69922 -17.2998 -11.0996 -19.6006l-34.0996 -9.2998z" />
    <glyph glyph-name="trash-alt" unicode="&#xf2ed;" horiz-adv-x="448" 
 d="M268 32c-6.62402 0 -12 5.37598 -12 12v216c0 6.62402 5.37598 12 12 12h24c6.62402 0 12 -5.37598 12 -12v-216c0 -6.62402 -5.37598 -12 -12 -12h-24zM432 368c8.83203 0 16 -7.16797 16 -16v-16c0 -8.83203 -7.16797 -16 -16 -16h-16v-336
 c0 -26.4961 -21.5039 -48 -48 -48h-288c-26.4961 0 -48 21.5039 -48 48v336h-16c-8.83203 0 -16 7.16797 -16 16v16c0 8.83203 7.16797 16 16 16h82.4102l34.0195 56.7002c7.71875 12.8613 26.1572 23.2998 41.1572 23.2998h0.00292969h100.82h0.0224609
 c15 0 33.4385 -10.4385 41.1572 -23.2998l34 -56.7002h82.4102zM171.84 397.09l-17.4502 -29.0898h139.221l-17.46 29.0898c-0.96582 1.60645 -3.26953 2.91016 -5.14355 2.91016h-0.00683594h-94h-0.0166016c-1.87402 0 -4.17871 -1.30371 -5.14355 -2.91016zM368 -16v336
 h-288v-336h288zM156 32c-6.62402 0 -12 5.37598 -12 12v216c0 6.62402 5.37598 12 12 12h24c6.62402 0 12 -5.37598 12 -12v-216c0 -6.62402 -5.37598 -12 -12 -12h-24z" />
    <glyph glyph-name="images" unicode="&#xf302;" horiz-adv-x="576" 
 d="M480 32v-16c0 -26.5098 -21.4902 -48 -48 -48h-384c-26.5098 0 -48 21.4902 -48 48v256c0 26.5098 21.4902 48 48 48h16v-48h-10c-3.31152 0 -6 -2.68848 -6 -6v-244c0 -3.31152 2.68848 -6 6 -6h372c3.31152 0 6 2.68848 6 6v10h48zM522 368h-372
 c-3.31152 0 -6 -2.68848 -6 -6v-244c0 -3.31152 2.68848 -6 6 -6h372c3.31152 0 6 2.68848 6 6v244c0 3.31152 -2.68848 6 -6 6zM528 416c26.5098 0 48 -21.4902 48 -48v-256c0 -26.5098 -21.4902 -48 -48 -48h-384c-26.5098 0 -48 21.4902 -48 48v256
 c0 26.5098 21.4902 48 48 48h384zM264 304c0 -22.0908 -17.9092 -40 -40 -40s-40 17.9092 -40 40s17.9092 40 40 40s40 -17.9092 40 -40zM192 208l39.5146 39.5146c4.68652 4.68652 12.2842 4.68652 16.9717 0l39.5137 -39.5146l103.515 103.515
 c4.68652 4.68652 12.2842 4.68652 16.9717 0l71.5137 -71.5146v-80h-288v48z" />
    <glyph glyph-name="clipboard" unicode="&#xf328;" horiz-adv-x="384" 
 d="M336 384c26.5 0 48 -21.5 48 -48v-352c0 -26.5 -21.5 -48 -48 -48h-288c-26.5 0 -48 21.5 -48 48v352c0 26.5 21.5 48 48 48h80c0 35.2998 28.7002 64 64 64s64 -28.7002 64 -64h80zM192 408c-13.2998 0 -24 -10.7002 -24 -24s10.7002 -24 24 -24s24 10.7002 24 24
 s-10.7002 24 -24 24zM336 -10v340c0 3.2998 -2.7002 6 -6 6h-42v-36c0 -6.59961 -5.40039 -12 -12 -12h-168c-6.59961 0 -12 5.40039 -12 12v36h-42c-3.2998 0 -6 -2.7002 -6 -6v-340c0 -3.2998 2.7002 -6 6 -6h276c3.2998 0 6 2.7002 6 6z" />
    <glyph glyph-name="arrow-alt-circle-down" unicode="&#xf358;" 
 d="M256 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM256 -8c110.5 0 200 89.5 200 200s-89.5 200 -200 200s-200 -89.5 -200 -200s89.5 -200 200 -200zM224 308c0 6.59961 5.40039 12 12 12h40c6.59961 0 12 -5.40039 12 -12v-116
 h67c10.7002 0 16.0996 -12.9004 8.5 -20.5l-99 -99c-4.7002 -4.7002 -12.2998 -4.7002 -17 0l-99 99c-7.5 7.59961 -2.2002 20.5 8.5 20.5h67v116z" />
    <glyph glyph-name="arrow-alt-circle-left" unicode="&#xf359;" 
 d="M8 192c0 137 111 248 248 248s248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248zM456 192c0 110.5 -89.5 200 -200 200s-200 -89.5 -200 -200s89.5 -200 200 -200s200 89.5 200 200zM384 212v-40c0 -6.59961 -5.40039 -12 -12 -12h-116v-67
 c0 -10.7002 -12.9004 -16 -20.5 -8.5l-99 99c-4.7002 4.7002 -4.7002 12.2998 0 17l99 99c7.59961 7.59961 20.5 2.2002 20.5 -8.5v-67h116c6.59961 0 12 -5.40039 12 -12z" />
    <glyph glyph-name="arrow-alt-circle-right" unicode="&#xf35a;" 
 d="M504 192c0 -137 -111 -248 -248 -248s-248 111 -248 248s111 248 248 248s248 -111 248 -248zM56 192c0 -110.5 89.5 -200 200 -200s200 89.5 200 200s-89.5 200 -200 200s-200 -89.5 -200 -200zM128 172v40c0 6.59961 5.40039 12 12 12h116v67
 c0 10.7002 12.9004 16 20.5 8.5l99 -99c4.7002 -4.7002 4.7002 -12.2998 0 -17l-99 -99c-7.59961 -7.59961 -20.5 -2.2002 -20.5 8.5v67h-116c-6.59961 0 -12 5.40039 -12 12z" />
    <glyph glyph-name="arrow-alt-circle-up" unicode="&#xf35b;" 
 d="M256 -56c-137 0 -248 111 -248 248s111 248 248 248s248 -111 248 -248s-111 -248 -248 -248zM256 392c-110.5 0 -200 -89.5 -200 -200s89.5 -200 200 -200s200 89.5 200 200s-89.5 200 -200 200zM276 64h-40c-6.59961 0 -12 5.40039 -12 12v116h-67
 c-10.7002 0 -16 12.9004 -8.5 20.5l99 99c4.7002 4.7002 12.2998 4.7002 17 0l99 -99c7.59961 -7.59961 2.2002 -20.5 -8.5 -20.5h-67v-116c0 -6.59961 -5.40039 -12 -12 -12z" />
    <glyph glyph-name="gem" unicode="&#xf3a5;" horiz-adv-x="576" 
 d="M464 448c4.09961 0 7.7998 -2 10.0996 -5.40039l99.9004 -147.199c2.90039 -4.40039 2.59961 -10.1006 -0.700195 -14.2002l-276 -340.8c-4.7998 -5.90039 -13.7998 -5.90039 -18.5996 0l-276 340.8c-3.2998 4 -3.60059 9.7998 -0.700195 14.2002l100 147.199
 c2.2002 3.40039 6 5.40039 10 5.40039h352zM444.7 400h-56.7998l51.6992 -96h68.4004zM242.6 400l-51.5996 -96h194l-51.7002 96h-90.7002zM131.3 400l-63.2998 -96h68.4004l51.6992 96h-56.7998zM88.2998 256l119.7 -160l-68.2998 160h-51.4004zM191.2 256l96.7998 -243.3
 l96.7998 243.3h-193.6zM368 96l119.6 160h-51.3994z" />
    <glyph glyph-name="money-bill-alt" unicode="&#xf3d1;" horiz-adv-x="640" 
 d="M320 304c53.0195 0 96 -50.1396 96 -112c0 -61.8701 -43 -112 -96 -112c-53.0195 0 -96 50.1504 -96 112c0 61.8604 42.9805 112 96 112zM360 136v16c0 4.41992 -3.58008 8 -8 8h-16v88c0 4.41992 -3.58008 8 -8 8h-13.5801h-0.000976562
 c-4.01074 0 -9.97266 -1.80566 -13.3086 -4.03027l-15.3301 -10.2197c-1.96777 -1.30957 -3.56445 -4.29004 -3.56445 -6.65332c0 -1.33691 0.601562 -3.32422 1.34375 -4.43652l8.88086 -13.3105c1.30859 -1.9668 4.29004 -3.56445 6.65332 -3.56445
 c1.33691 0 3.32422 0.602539 4.43652 1.34473l0.469727 0.310547v-55.4404h-16c-4.41992 0 -8 -3.58008 -8 -8v-16c0 -4.41992 3.58008 -8 8 -8h64c4.41992 0 8 3.58008 8 8zM608 384c17.6699 0 32 -14.3301 32 -32v-320c0 -17.6699 -14.3301 -32 -32 -32h-576
 c-17.6699 0 -32 14.3301 -32 32v320c0 17.6699 14.3301 32 32 32h576zM592 112v160c-35.3496 0 -64 28.6504 -64 64h-416c0 -35.3496 -28.6504 -64 -64 -64v-160c35.3496 0 64 -28.6504 64 -64h416c0 35.3496 28.6504 64 64 64z" />
    <glyph glyph-name="window-close" unicode="&#xf410;" 
 d="M464 416c26.5 0 48 -21.5 48 -48v-352c0 -26.5 -21.5 -48 -48 -48h-416c-26.5 0 -48 21.5 -48 48v352c0 26.5 21.5 48 48 48h416zM464 22v340c0 3.2998 -2.7002 6 -6 6h-404c-3.2998 0 -6 -2.7002 -6 -6v-340c0 -3.2998 2.7002 -6 6 -6h404c3.2998 0 6 2.7002 6 6z
 M356.5 253.4l-61.4004 -61.4004l61.4004 -61.4004c4.59961 -4.59961 4.59961 -12.0996 0 -16.7998l-22.2998 -22.2998c-4.60059 -4.59961 -12.1006 -4.59961 -16.7998 0l-61.4004 61.4004l-61.4004 -61.4004c-4.59961 -4.59961 -12.0996 -4.59961 -16.7998 0
 l-22.2998 22.2998c-4.59961 4.60059 -4.59961 12.1006 0 16.7998l61.4004 61.4004l-61.4004 61.4004c-4.59961 4.59961 -4.59961 12.0996 0 16.7998l22.2998 22.2998c4.60059 4.59961 12.1006 4.59961 16.7998 0l61.4004 -61.4004l61.4004 61.4004
 c4.59961 4.59961 12.0996 4.59961 16.7998 0l22.2998 -22.2998c4.7002 -4.60059 4.7002 -12.1006 0 -16.7998z" />
    <glyph glyph-name="comment-dots" unicode="&#xf4ad;" 
 d="M144 240c17.7002 0 32 -14.2998 32 -32s-14.2998 -32 -32 -32s-32 14.2998 -32 32s14.2998 32 32 32zM256 240c17.7002 0 32 -14.2998 32 -32s-14.2998 -32 -32 -32s-32 14.2998 -32 32s14.2998 32 32 32zM368 240c17.7002 0 32 -14.2998 32 -32s-14.2998 -32 -32 -32
 s-32 14.2998 -32 32s14.2998 32 32 32zM256 416c141.4 0 256 -93.0996 256 -208s-114.6 -208 -256 -208c-32.7998 0 -64 5.2002 -92.9004 14.2998c-29.0996 -20.5996 -77.5996 -46.2998 -139.1 -46.2998c-9.59961 0 -18.2998 5.7002 -22.0996 14.5
 c-3.80078 8.7998 -2 19 4.59961 26c0.5 0.400391 31.5 33.7998 46.4004 73.2002c-33 35.0996 -52.9004 78.7002 -52.9004 126.3c0 114.9 114.6 208 256 208zM256 48c114.7 0 208 71.7998 208 160s-93.2998 160 -208 160s-208 -71.7998 -208 -160
 c0 -42.2002 21.7002 -74.0996 39.7998 -93.4004l20.6006 -21.7998l-10.6006 -28.0996c-5.5 -14.5 -12.5996 -28.1006 -19.8994 -40.2002c23.5996 7.59961 43.1992 18.9004 57.5 29l19.5 13.7998l22.6992 -7.2002c25.3008 -8 51.7002 -12.0996 78.4004 -12.0996z" />
    <glyph glyph-name="smile-wink" unicode="&#xf4da;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM365.8 138.4c10.2002 -8.5 11.6006 -23.6006 3.10059 -33.8008
 c-30 -36 -74.1006 -56.5996 -120.9 -56.5996s-90.9004 20.5996 -120.9 56.5996c-8.39941 10.2002 -7.09961 25.3008 3.10059 33.8008c10.0996 8.39941 25.2998 7.09961 33.7998 -3.10059c20.7998 -25.0996 51.5 -39.3994 84 -39.3994s63.2002 14.3994 84 39.3994
 c8.5 10.2002 23.5996 11.6006 33.7998 3.10059zM168 208c-17.7002 0 -32 14.2998 -32 32s14.2998 32 32 32s32 -14.2998 32 -32s-14.2998 -32 -32 -32zM328 268c25.7002 0 55.9004 -16.9004 59.7002 -42.0996c1.7998 -11.1006 -11.2998 -18.2002 -19.7998 -10.8008l-9.5 8.5
 c-14.8008 13.2002 -46.2002 13.2002 -61 0l-9.5 -8.5c-8.30078 -7.39941 -21.5 -0.399414 -19.8008 10.8008c4 25.1992 34.2002 42.0996 59.9004 42.0996z" />
    <glyph glyph-name="angry" unicode="&#xf556;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM248 136c33.5996 0 65.2002 -14.7998 86.7998 -40.5996
 c8.40039 -10.2002 7.10059 -25.3008 -3.09961 -33.8008c-10.6006 -8.89941 -25.7002 -6.69922 -33.7998 3c-24.8008 29.7002 -75 29.7002 -99.8008 0c-8.5 -10.1992 -23.5996 -11.5 -33.7998 -3s-11.5996 23.6006 -3.09961 33.8008
 c21.5996 25.7998 53.2002 40.5996 86.7998 40.5996zM200 208c0 -17.7002 -14.2998 -32.0996 -32 -32.0996s-32 14.2998 -32 32c0 6.19922 2.2002 11.6992 5.2998 16.5996l-28.2002 8.5c-12.6992 3.7998 -19.8994 17.2002 -16.0996 29.9004
 c3.7998 12.6992 17.0996 20 29.9004 16.0996l80 -24c12.6992 -3.7998 19.8994 -17.2002 16.0996 -29.9004c-3.09961 -10.3994 -12.7002 -17.0996 -23 -17.0996zM399 262.9c3.7998 -12.7002 -3.40039 -26.1006 -16.0996 -29.8008l-28.2002 -8.5
 c3.09961 -4.89941 5.2998 -10.3994 5.2998 -16.5996c0 -17.7002 -14.2998 -32 -32 -32s-32 14.2998 -32 32c-10.2998 0 -19.9004 6.7002 -23 17.0996c-3.7998 12.7002 3.40039 26.1006 16.0996 29.9004l80 24c12.8008 3.7998 26.1006 -3.40039 29.9004 -16.0996z" />
    <glyph glyph-name="dizzy" unicode="&#xf567;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM214.2 209.9
 c-7.90039 -7.90039 -20.5 -7.90039 -28.4004 -0.200195l-17.7998 17.7998l-17.7998 -17.7998c-7.7998 -7.7998 -20.5 -7.7998 -28.2998 0c-7.80078 7.7998 -7.80078 20.5 0 28.2998l17.8994 17.9004l-17.8994 17.8994c-7.80078 7.7998 -7.80078 20.5 0 28.2998
 c7.7998 7.80078 20.5 7.80078 28.2998 0l17.7998 -17.7998l17.9004 17.9004c7.7998 7.7998 20.5 7.7998 28.2998 0s7.7998 -20.5 0 -28.2998l-17.9004 -17.9004l17.9004 -17.7998c7.7998 -7.7998 7.7998 -20.5 0 -28.2998zM374.2 302.1
 c7.7002 -7.7998 7.7002 -20.3994 0 -28.1992l-17.9004 -17.9004l17.7998 -18c7.80078 -7.7998 7.80078 -20.5 0 -28.2998c-7.7998 -7.7998 -20.5 -7.7998 -28.2998 0l-17.7998 17.7998l-17.7998 -17.7998c-7.7998 -7.7998 -20.5 -7.7998 -28.2998 0
 c-7.80078 7.7998 -7.80078 20.5 0 28.2998l17.8994 17.9004l-17.8994 17.8994c-7.80078 7.7998 -7.80078 20.5 0 28.2998c7.7998 7.80078 20.5 7.80078 28.2998 0l17.7998 -17.7998l17.9004 17.7998c7.7998 7.80078 20.5 7.80078 28.2998 0zM248 176
 c35.2998 0 64 -28.7002 64 -64s-28.7002 -64 -64 -64s-64 28.7002 -64 64s28.7002 64 64 64z" />
    <glyph glyph-name="flushed" unicode="&#xf579;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM344 304c44.2002 0 80 -35.7998 80 -80s-35.7998 -80 -80 -80
 s-80 35.7998 -80 80s35.7998 80 80 80zM344 176c26.5 0 48 21.5 48 48s-21.5 48 -48 48s-48 -21.5 -48 -48s21.5 -48 48 -48zM344 248c13.2998 0 24 -10.7002 24 -24s-10.7002 -24 -24 -24s-24 10.7002 -24 24s10.7002 24 24 24zM232 224c0 -44.2002 -35.7998 -80 -80 -80
 s-80 35.7998 -80 80s35.7998 80 80 80s80 -35.7998 80 -80zM152 176c26.5 0 48 21.5 48 48s-21.5 48 -48 48s-48 -21.5 -48 -48s21.5 -48 48 -48zM152 248c13.2998 0 24 -10.7002 24 -24s-10.7002 -24 -24 -24s-24 10.7002 -24 24s10.7002 24 24 24zM312 104
 c13.2002 0 24 -10.7998 24 -24s-10.7998 -24 -24 -24h-128c-13.2002 0 -24 10.7998 -24 24s10.7998 24 24 24h128z" />
    <glyph glyph-name="frown-open" unicode="&#xf57a;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM200 240c0 -17.7002 -14.2998 -32 -32 -32s-32 14.2998 -32 32
 s14.2998 32 32 32s32 -14.2998 32 -32zM328 272c17.7002 0 32 -14.2998 32 -32s-14.2998 -32 -32 -32s-32 14.2998 -32 32s14.2998 32 32 32zM248 160c35.5996 0 88.7998 -21.2998 95.7998 -61.2002c2 -11.7998 -9.09961 -21.5996 -20.5 -18.0996
 c-31.2002 9.59961 -59.3994 15.2998 -75.2998 15.2998s-44.0996 -5.7002 -75.2998 -15.2998c-11.5 -3.40039 -22.5 6.2998 -20.5 18.0996c7 39.9004 60.2002 61.2002 95.7998 61.2002z" />
    <glyph glyph-name="grimace" unicode="&#xf57f;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM168 208c-17.7002 0 -32 14.2998 -32 32s14.2998 32 32 32
 s32 -14.2998 32 -32s-14.2998 -32 -32 -32zM328 208c-17.7002 0 -32 14.2998 -32 32s14.2998 32 32 32s32 -14.2998 32 -32s-14.2998 -32 -32 -32zM344 192c26.5 0 48 -21.5 48 -48v-32c0 -26.5 -21.5 -48 -48 -48h-192c-26.5 0 -48 21.5 -48 48v32c0 26.5 21.5 48 48 48
 h192zM176 96v24h-40v-8c0 -8.7998 7.2002 -16 16 -16h24zM176 136v24h-24c-8.7998 0 -16 -7.2002 -16 -16v-8h40zM240 96v24h-48v-24h48zM240 136v24h-48v-24h48zM304 96v24h-48v-24h48zM304 136v24h-48v-24h48zM360 112v8h-40v-24h24c8.7998 0 16 7.2002 16 16zM360 136v8
 c0 8.7998 -7.2002 16 -16 16h-24v-24h40z" />
    <glyph glyph-name="grin" unicode="&#xf580;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM353.6 143.4c10 3.09961 19.3008 -5.5 17.7002 -15.3008
 c-8 -47.0996 -71.2998 -80 -123.3 -80s-115.4 32.9004 -123.3 80c-1.7002 9.90039 7.7998 18.4004 17.7002 15.3008c26 -8.30078 64.3994 -13.1006 105.6 -13.1006s79.7002 4.7998 105.6 13.1006zM168 208c-17.7002 0 -32 14.2998 -32 32s14.2998 32 32 32
 s32 -14.2998 32 -32s-14.2998 -32 -32 -32zM328 208c-17.7002 0 -32 14.2998 -32 32s14.2998 32 32 32s32 -14.2998 32 -32s-14.2998 -32 -32 -32z" />
    <glyph glyph-name="grin-alt" unicode="&#xf581;" horiz-adv-x="496" 
 d="M200.3 200c-7.5 -11.4004 -24.5996 -12 -32.7002 0c-12.3994 18.7002 -15.1992 37.2998 -15.6992 56c0.599609 18.7002 3.2998 37.2998 15.6992 56c7.60059 11.4004 24.7002 12 32.7002 0c12.4004 -18.7002 15.2002 -37.2998 15.7002 -56
 c-0.599609 -18.7002 -3.2998 -37.2998 -15.7002 -56zM328.3 200c-7.5 -11.4004 -24.5996 -12 -32.7002 0c-12.3994 18.7002 -15.1992 37.2998 -15.6992 56c0.599609 18.7002 3.2998 37.2998 15.6992 56c7.60059 11.4004 24.7002 12 32.7002 0
 c12.4004 -18.7002 15.2002 -37.2998 15.7002 -56c-0.599609 -18.7002 -3.2998 -37.2998 -15.7002 -56zM248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200
 s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM353.6 143.4c10 3.09961 19.3008 -5.5 17.7002 -15.3008c-8 -47.0996 -71.2998 -80 -123.3 -80s-115.4 32.8008 -123.3 80c-1.7002 10 7.7998 18.4004 17.7002 15.3008c26 -8.30078 64.3994 -13.1006 105.6 -13.1006
 s79.7002 4.7998 105.6 13.1006z" />
    <glyph glyph-name="grin-beam" unicode="&#xf582;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM353.6 143.4c10 3.09961 19.3008 -5.5 17.7002 -15.3008
 c-8 -47.0996 -71.2998 -80 -123.3 -80s-115.4 32.9004 -123.3 80c-1.7002 10 7.89941 18.4004 17.7002 15.3008c26 -8.30078 64.3994 -13.1006 105.6 -13.1006s79.7002 4.7998 105.6 13.1006zM117.7 216.3c-3.60059 1.10059 -6 4.60059 -5.7002 8.2998
 c3.2998 42.1006 32.2002 71.4004 56 71.4004s52.7002 -29.2998 56 -71.4004c0.299805 -3.7998 -2.09961 -7.19922 -5.7002 -8.2998c-3.09961 -1 -7.2002 0 -9.2998 3.7002l-9.5 17c-7.7002 13.7002 -19.2002 21.5996 -31.5 21.5996s-23.7998 -7.89941 -31.5 -21.5996
 l-9.5 -17c-1.90039 -3.2002 -5.7998 -4.7998 -9.2998 -3.7002zM277.7 216.3c-3.60059 1.10059 -6 4.60059 -5.7002 8.2998c3.2998 42.1006 32.2002 71.4004 56 71.4004s52.7002 -29.2998 56 -71.4004c0.299805 -3.7998 -2.09961 -7.19922 -5.7002 -8.2998
 c-3.09961 -1 -7.2002 0 -9.2998 3.7002l-9.5 17c-7.7002 13.7002 -19.2002 21.5996 -31.5 21.5996s-23.7998 -7.89941 -31.5 -21.5996l-9.5 -17c-1.90039 -3.2002 -5.7998 -4.7998 -9.2998 -3.7002z" />
    <glyph glyph-name="grin-beam-sweat" unicode="&#xf583;" horiz-adv-x="496" 
 d="M440 288c-29.5 0 -53.2998 26.2998 -53.2998 58.7002c0 25 31.7002 75.5 46.2002 97.2998c3.5 5.2998 10.5996 5.2998 14.1992 0c14.5 -21.7998 46.2002 -72.2998 46.2002 -97.2998c0 -32.4004 -23.7998 -58.7002 -53.2998 -58.7002zM248 48
 c-51.9004 0 -115.3 32.9004 -123.3 80c-1.7002 10 7.89941 18.4004 17.7002 15.2998c26 -8.2998 64.3994 -13.0996 105.6 -13.0996s79.7002 4.7998 105.6 13.0996c10 3.2002 19.4004 -5.39941 17.7002 -15.2998c-8 -47.0996 -71.3994 -80 -123.3 -80zM378.3 216.3
 c-3.09961 -0.899414 -7.2002 0.100586 -9.2998 3.7002l-9.5 17c-7.7002 13.7002 -19.2002 21.5996 -31.5 21.5996s-23.7998 -7.89941 -31.5 -21.5996l-9.5 -17c-1.90039 -3.2002 -5.7998 -4.7998 -9.2998 -3.7002c-3.60059 1.10059 -6 4.60059 -5.7002 8.2998
 c3.2998 42.1006 32.2002 71.4004 56 71.4004s52.7002 -29.2998 56 -71.4004c0.299805 -3.7998 -2.09961 -7.19922 -5.7002 -8.2998zM483.6 269.2c8 -24.2998 12.4004 -50.2002 12.4004 -77.2002c0 -137 -111 -248 -248 -248s-248 111 -248 248s111 248 248 248
 c45.7002 0 88.4004 -12.5996 125.2 -34.2002c-10.9004 -21.5996 -15.5 -36.2002 -17.2002 -45.7002c-31.2002 20.1006 -68.2002 31.9004 -108 31.9004c-110.3 0 -200 -89.7002 -200 -200s89.7002 -200 200 -200s200 89.7002 200 200
 c0 22.5 -3.90039 44.0996 -10.7998 64.2998c0.399414 0 21.7998 -2.7998 46.3994 12.9004zM168 258.6c-12.2998 0 -23.7998 -7.7998 -31.5 -21.5996l-9.5 -17c-1.90039 -3.2002 -5.7998 -4.7998 -9.2998 -3.7002c-3.60059 1.10059 -6 4.60059 -5.7002 8.2998
 c3.2998 42.1006 32.2002 71.4004 56 71.4004s52.7002 -29.2998 56 -71.4004c0.299805 -3.7998 -2.09961 -7.19922 -5.7002 -8.2998c-3.09961 -1 -7.2002 0 -9.2998 3.7002l-9.5 17c-7.7002 13.7002 -19.2002 21.5996 -31.5 21.5996z" />
    <glyph glyph-name="grin-hearts" unicode="&#xf584;" horiz-adv-x="496" 
 d="M353.6 143.4c10 3.09961 19.3008 -5.5 17.7002 -15.3008c-8 -47.0996 -71.2998 -80 -123.3 -80s-115.4 32.8008 -123.3 80c-1.7002 10 7.89941 18.4004 17.7002 15.3008c26 -8.30078 64.3994 -13.1006 105.6 -13.1006s79.7002 4.7998 105.6 13.1006zM200.8 192.3
 l-70.2002 18.1006c-20.3994 5.2998 -31.8994 27 -24.1992 47.1992c6.69922 17.7002 26.6992 26.7002 44.8994 22l7.10059 -1.89941l2 7.09961c5.09961 18.1006 22.8994 30.9004 41.5 27.9004c21.3994 -3.40039 34.3994 -24.2002 28.7998 -44.5l-19.4004 -69.9004
 c-1.2998 -4.5 -6 -7.2002 -10.5 -6zM389.6 257.6c7.7002 -20.1992 -3.7998 -41.7998 -24.1992 -47.0996l-70.2002 -18.2002c-4.60059 -1.2002 -9.2998 1.5 -10.5 6l-19.4004 69.9004c-5.59961 20.2998 7.40039 41.0996 28.7998 44.5c18.7002 3 36.5 -9.7998 41.5 -27.9004
 l2 -7.09961l7.10059 1.89941c18.2002 4.7002 38.2002 -4.39941 44.8994 -22zM248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200
 s89.7002 -200 200 -200z" />
    <glyph glyph-name="grin-squint" unicode="&#xf585;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM353.6 143.4c10 3.09961 19.3008 -5.5 17.7002 -15.3008
 c-8 -47.0996 -71.2998 -80 -123.3 -80s-115.4 32.9004 -123.3 80c-1.7002 9.90039 7.7998 18.4004 17.7002 15.3008c26 -8.30078 64.3994 -13.1006 105.6 -13.1006s79.7002 4.7998 105.6 13.1006zM118.9 184.2c-3.80078 4.39941 -3.90039 11 -0.100586 15.5l33.6006 40.2998
 l-33.6006 40.2998c-3.7002 4.5 -3.7002 11 0.100586 15.5c3.89941 4.40039 10.1992 5.5 15.2998 2.5l80 -48c3.59961 -2.2002 5.7998 -6.09961 5.7998 -10.2998s-2.2002 -8.09961 -5.7998 -10.2998l-80 -48c-5.40039 -3.2002 -11.7002 -1.7002 -15.2998 2.5zM361.8 181.7
 l-80 48c-3.59961 2.2002 -5.7998 6.09961 -5.7998 10.2998s2.2002 8.09961 5.7998 10.2998l80 48c5.10059 2.90039 11.5 1.90039 15.2998 -2.5c3.80078 -4.5 3.90039 -11 0.100586 -15.5l-33.6006 -40.2998l33.6006 -40.2998c3.7002 -4.5 3.7002 -11 -0.100586 -15.5
 c-3.59961 -4.2002 -9.89941 -5.7002 -15.2998 -2.5z" />
    <glyph glyph-name="grin-squint-tears" unicode="&#xf586;" 
 d="M117.1 63.9004c6.30078 0.899414 11.7002 -4.5 10.9004 -10.9004c-3.7002 -25.7998 -13.7002 -84 -30.5996 -100.9c-22 -21.8994 -57.9004 -21.5 -80.3008 0.900391c-22.3994 22.4004 -22.7998 58.4004 -0.899414 80.2998
 c16.8994 16.9004 75.0996 26.9004 100.899 30.6006zM75.9004 105.6c-19.6006 -3.89941 -35.1006 -8.09961 -47.3008 -12.1992c-39.2998 90.5996 -22.0996 199.899 52 274c48.5 48.3994 111.9 72.5996 175.4 72.5996c38.9004 0 77.7998 -9.2002 113.2 -27.4004
 c-4 -12.1992 -8.2002 -28 -12 -48.2998c-30.4004 17.9004 -65 27.7002 -101.2 27.7002c-53.4004 0 -103.6 -20.7998 -141.4 -58.5996c-61.5996 -61.5 -74.2998 -153.4 -38.6992 -227.801zM428.2 293.2c20.2998 3.89941 36.2002 8 48.5 12
 c47.8994 -93.2002 32.8994 -210.5 -45.2002 -288.601c-48.5 -48.3994 -111.9 -72.5996 -175.4 -72.5996c-33.6992 0 -67.2998 7 -98.6992 20.5996c4.19922 12.2002 8.2998 27.7002 12.1992 47.2002c26.6006 -12.7998 55.9004 -19.7998 86.4004 -19.7998
 c53.4004 0 103.6 20.7998 141.4 58.5996c65.6992 65.7002 75.7998 166 30.7998 242.601zM394.9 320.1c-6.30078 -0.899414 -11.7002 4.5 -10.9004 10.9004c3.7002 25.7998 13.7002 84 30.5996 100.9c22 21.8994 57.9004 21.5 80.3008 -0.900391
 c22.3994 -22.4004 22.7998 -58.4004 0.899414 -80.2998c-16.8994 -16.9004 -75.0996 -26.9004 -100.899 -30.6006zM207.9 211.8c3 -3 4.19922 -7.2998 3.19922 -11.5l-22.5996 -90.5c-1.40039 -5.39941 -6.2002 -9.09961 -11.7002 -9.09961h-0.899414
 c-5.80078 0.5 -10.5 5.09961 -11 10.8994l-4.80078 52.3008l-52.2998 4.7998c-5.7998 0.5 -10.3994 5.2002 -10.8994 11c-0.400391 5.89941 3.39941 11.2002 9.09961 12.5996l90.5 22.7002c4.2002 1 8.40039 -0.200195 11.4004 -3.2002zM247.6 236.9
 c-0.0996094 0 -6.39941 -1.80078 -11.3994 3.19922c-3 3 -4.2002 7.30078 -3.2002 11.4004l22.5996 90.5c1.40039 5.7002 7 9.2002 12.6006 9.09961c5.7998 -0.5 10.5 -5.09961 11 -10.8994l4.7998 -52.2998l52.2998 -4.80078c5.7998 -0.5 10.4004 -5.19922 10.9004 -11
 c0.399414 -5.89941 -3.40039 -11.1992 -9.10059 -12.5996zM299.6 148.4c29.1006 29.0996 53 59.5996 65.3008 83.7998c4.89941 9.2998 17.5996 9.89941 23.3994 1.7002c27.7002 -38.9004 6.10059 -106.9 -30.5996 -143.7s-104.8 -58.2998 -143.7 -30.6006
 c-8.2998 5.90039 -7.5 18.6006 1.7002 23.4004c24.2002 12.5 54.7998 36.2998 83.8994 65.4004z" />
    <glyph glyph-name="grin-stars" unicode="&#xf587;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM353.6 143.4c10 3.09961 19.3008 -5.5 17.7002 -15.3008
 c-8 -47.0996 -71.2998 -80 -123.3 -80s-115.4 32.8008 -123.3 80c-1.7002 10 7.89941 18.4004 17.7002 15.3008c26 -8.30078 64.3994 -13.1006 105.6 -13.1006s79.7002 4.7998 105.6 13.1006zM125.7 200.9l6.09961 34.8994l-25.3994 24.6006
 c-4.60059 4.59961 -1.90039 12.2998 4.2998 13.1992l34.8994 5l15.5 31.6006c2.90039 5.7998 11 5.7998 13.9004 0l15.5 -31.6006l34.9004 -5c6.19922 -1 8.7998 -8.69922 4.2998 -13.1992l-25.4004 -24.6006l6 -34.8994c1 -6.2002 -5.39941 -11 -11 -7.90039
 l-31.2998 16.2998l-31.2998 -16.2998c-5.60059 -3.09961 -12 1.7002 -11 7.90039zM385.4 273.6c6.19922 -1 8.89941 -8.59961 4.39941 -13.1992l-25.3994 -24.6006l6 -34.8994c1 -6.2002 -5.40039 -11 -11 -7.90039l-31.3008 16.2998l-31.2998 -16.2998
 c-5.59961 -3.09961 -12 1.7002 -11 7.90039l6 34.8994l-25.3994 24.6006c-4.60059 4.59961 -1.90039 12.2998 4.2998 13.1992l34.8994 5l15.5 31.6006c2.90039 5.7998 11 5.7998 13.9004 0l15.5 -31.6006z" />
    <glyph glyph-name="grin-tears" unicode="&#xf588;" horiz-adv-x="640" 
 d="M117.1 191.9c6.30078 0.899414 11.7002 -4.5 10.9004 -10.9004c-3.7002 -25.7998 -13.7002 -84 -30.5996 -100.9c-22 -21.8994 -57.9004 -21.5 -80.3008 0.900391c-22.3994 22.4004 -22.7998 58.4004 -0.899414 80.2998c16.8994 16.9004 75.0996 26.9004 100.899 30.6006
 zM623.8 161.3c21.9004 -21.8994 21.5 -57.8994 -0.799805 -80.2002c-22.4004 -22.3994 -58.4004 -22.7998 -80.2998 -0.899414c-16.9004 16.8994 -26.9004 75.0996 -30.6006 100.899c-0.899414 6.30078 4.5 11.7002 10.8008 10.8008
 c25.7998 -3.7002 84 -13.7002 100.899 -30.6006zM497.2 99.5996c12.3994 -37.2998 25.0996 -43.7998 28.2998 -46.5c-44.5996 -65.7998 -120 -109.1 -205.5 -109.1s-160.9 43.2998 -205.5 109.1c3.09961 2.60059 15.7998 9.10059 28.2998 46.5
 c33.4004 -63.8994 100.3 -107.6 177.2 -107.6s143.8 43.7002 177.2 107.6zM122.7 223.5c-2.40039 0.299805 -5 2.5 -49.5 -6.90039c12.3994 125.4 118.1 223.4 246.8 223.4s234.4 -98 246.8 -223.5c-44.2998 9.40039 -47.3994 7.2002 -49.5 7
 c-15.2002 95.2998 -97.7998 168.5 -197.3 168.5s-182.1 -73.2002 -197.3 -168.5zM320 48c-51.9004 0 -115.3 32.9004 -123.3 80c-1.7002 10 7.89941 18.4004 17.7002 15.2998c26 -8.2998 64.3994 -13.0996 105.6 -13.0996s79.7002 4.7998 105.6 13.0996
 c10 3.2002 19.4004 -5.39941 17.7002 -15.2998c-8 -47.0996 -71.3994 -80 -123.3 -80zM450.3 216.3c-3.09961 -0.899414 -7.2002 0.100586 -9.2998 3.7002l-9.5 17c-7.7002 13.7002 -19.2002 21.5996 -31.5 21.5996s-23.7998 -7.89941 -31.5 -21.5996l-9.5 -17
 c-1.90039 -3.2002 -5.7998 -4.7998 -9.2998 -3.7002c-3.60059 1.10059 -6 4.60059 -5.7002 8.2998c3.2998 42.1006 32.2002 71.4004 56 71.4004s52.7002 -29.2998 56 -71.4004c0.299805 -3.7998 -2.09961 -7.19922 -5.7002 -8.2998zM240 258.6
 c-12.2998 0 -23.7998 -7.7998 -31.5 -21.5996l-9.5 -17c-1.90039 -3.2002 -5.7998 -4.7998 -9.2998 -3.7002c-3.60059 1.10059 -6 4.60059 -5.7002 8.2998c3.2998 42.1006 32.2002 71.4004 56 71.4004s52.7002 -29.2998 56 -71.4004
 c0.299805 -3.7998 -2.09961 -7.19922 -5.7002 -8.2998c-3.09961 -1 -7.2002 0 -9.2998 3.7002l-9.5 17c-7.7002 13.7002 -19.2002 21.5996 -31.5 21.5996z" />
    <glyph glyph-name="grin-tongue" unicode="&#xf589;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM312 40h0.0996094v43.7998l-17.6992 8.7998c-15.1006 7.60059 -31.5 -1.69922 -34.9004 -16.5l-2.7998 -12.0996c-2.10059 -9.2002 -15.2002 -9.2002 -17.2998 0
 l-2.80078 12.0996c-3.39941 14.8008 -19.8994 24 -34.8994 16.5l-17.7002 -8.7998v-42.7998c0 -35.2002 28 -64.5 63.0996 -65c35.8008 -0.5 64.9004 28.4004 64.9004 64zM340.2 14.7002c64 33.3994 107.8 100.3 107.8 177.3c0 110.3 -89.7002 200 -200 200
 s-200 -89.7002 -200 -200c0 -77 43.7998 -143.9 107.8 -177.3c-2.2002 8.09961 -3.7998 16.5 -3.7998 25.2998v43.5c-14.2002 12.4004 -24.4004 27.5 -27.2998 44.5c-1.7002 10 7.7998 18.4004 17.7002 15.2998c26 -8.2998 64.3994 -13.0996 105.6 -13.0996
 s79.7002 4.7998 105.6 13.0996c10 3.2002 19.4004 -5.39941 17.7002 -15.2998c-2.89941 -17 -13.0996 -32.0996 -27.2998 -44.5v-43.5c0 -8.7998 -1.59961 -17.2002 -3.7998 -25.2998zM168 272c17.7002 0 32 -14.2998 32 -32s-14.2998 -32 -32 -32s-32 14.2998 -32 32
 s14.2998 32 32 32zM328 272c17.7002 0 32 -14.2998 32 -32s-14.2998 -32 -32 -32s-32 14.2998 -32 32s14.2998 32 32 32z" />
    <glyph glyph-name="grin-tongue-squint" unicode="&#xf58a;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM312 40h0.0996094v43.7998l-17.6992 8.7998c-15.1006 7.60059 -31.5 -1.69922 -34.9004 -16.5l-2.7998 -12.0996c-2.10059 -9.2002 -15.2002 -9.2002 -17.2998 0
 l-2.80078 12.0996c-3.39941 14.8008 -19.8994 24 -34.8994 16.5l-17.7002 -8.7998v-42.7998c0 -35.2002 28 -64.5 63.0996 -65c35.8008 -0.5 64.9004 28.4004 64.9004 64zM340.2 14.7002c64 33.3994 107.8 100.3 107.8 177.3c0 110.3 -89.7002 200 -200 200
 s-200 -89.7002 -200 -200c0 -77 43.7998 -143.9 107.8 -177.3c-2.2002 8.09961 -3.7998 16.5 -3.7998 25.2998v43.5c-14.2002 12.4004 -24.4004 27.5 -27.2998 44.5c-1.7002 10 7.7998 18.4004 17.7002 15.2998c26 -8.2998 64.3994 -13.0996 105.6 -13.0996
 s79.7002 4.7998 105.6 13.0996c10 3.2002 19.4004 -5.39941 17.7002 -15.2998c-2.89941 -17 -13.0996 -32.0996 -27.2998 -44.5v-43.5c0 -8.7998 -1.59961 -17.2002 -3.7998 -25.2998zM377.1 295.8c3.80078 -4.39941 3.90039 -11 0.100586 -15.5l-33.6006 -40.2998
 l33.6006 -40.2998c3.7002 -4.5 3.7002 -11 -0.100586 -15.5c-3.59961 -4.2002 -9.89941 -5.7002 -15.2998 -2.5l-80 48c-3.59961 2.2002 -5.7998 6.09961 -5.7998 10.2998s2.2002 8.09961 5.7998 10.2998l80 48c5 3 11.5 1.90039 15.2998 -2.5zM214.2 250.3
 c3.59961 -2.2002 5.7998 -6.09961 5.7998 -10.2998s-2.2002 -8.09961 -5.7998 -10.2998l-80 -48c-5.40039 -3.2002 -11.7002 -1.7002 -15.2998 2.5c-3.80078 4.5 -3.90039 11 -0.100586 15.5l33.6006 40.2998l-33.6006 40.2998c-3.7002 4.5 -3.7002 11 0.100586 15.5
 c3.89941 4.5 10.2998 5.5 15.2998 2.5z" />
    <glyph glyph-name="grin-tongue-wink" unicode="&#xf58b;" horiz-adv-x="496" 
 d="M152 268c25.7002 0 55.9004 -16.9004 59.7998 -42.0996c0.799805 -5 -1.7002 -10 -6.09961 -12.4004c-5.7002 -3.09961 -11.2002 -0.599609 -13.7002 1.59961l-9.5 8.5c-14.7998 13.2002 -46.2002 13.2002 -61 0l-9.5 -8.5
 c-3.7998 -3.39941 -9.2998 -4 -13.7002 -1.59961c-4.39941 2.40039 -6.89941 7.40039 -6.09961 12.4004c3.89941 25.1992 34.0996 42.0996 59.7998 42.0996zM328 320c44.2002 0 80 -35.7998 80 -80s-35.7998 -80 -80 -80s-80 35.7998 -80 80s35.7998 80 80 80zM328 192
 c26.5 0 48 21.5 48 48s-21.5 48 -48 48s-48 -21.5 -48 -48s21.5 -48 48 -48zM328 264c13.2998 0 24 -10.7002 24 -24s-10.7002 -24 -24 -24s-24 10.7002 -24 24s10.7002 24 24 24zM248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248z
 M312 40h0.0996094v43.7998l-17.6992 8.7998c-15.1006 7.60059 -31.5 -1.69922 -34.9004 -16.5l-2.7998 -12.0996c-2.10059 -9.2002 -15.2002 -9.2002 -17.2998 0l-2.80078 12.0996c-3.39941 14.8008 -19.8994 24 -34.8994 16.5l-17.7002 -8.7998v-42.7998
 c0 -35.2002 28 -64.5 63.0996 -65c35.8008 -0.5 64.9004 28.4004 64.9004 64zM340.2 14.7002c64 33.3994 107.8 100.3 107.8 177.3c0 110.3 -89.7002 200 -200 200s-200 -89.7002 -200 -200c0 -77 43.7998 -143.9 107.8 -177.3
 c-2.2002 8.09961 -3.7998 16.5 -3.7998 25.2998v43.5c-14.2002 12.4004 -24.4004 27.5 -27.2998 44.5c-1.7002 10 7.7998 18.4004 17.7002 15.2998c26 -8.2998 64.3994 -13.0996 105.6 -13.0996s79.7002 4.7998 105.6 13.0996c10 3.2002 19.4004 -5.39941 17.7002 -15.2998
 c-2.89941 -17 -13.0996 -32.0996 -27.2998 -44.5v-43.5c0 -8.7998 -1.59961 -17.2002 -3.7998 -25.2998z" />
    <glyph glyph-name="grin-wink" unicode="&#xf58c;" horiz-adv-x="496" 
 d="M328 268c25.6904 0 55.8799 -16.9199 59.8701 -42.1201c1.72949 -11.0898 -11.3506 -18.2695 -19.8301 -10.8398l-9.5498 8.47949c-14.8105 13.1904 -46.1602 13.1904 -60.9707 0l-9.5498 -8.47949c-8.33008 -7.40039 -21.5801 -0.379883 -19.8301 10.8398
 c3.98047 25.2002 34.1699 42.1201 59.8604 42.1201zM168 208c-17.6699 0 -32 14.3301 -32 32s14.3301 32 32 32s32 -14.3301 32 -32s-14.3301 -32 -32 -32zM353.55 143.36c10.04 3.13965 19.3906 -5.4502 17.71 -15.3408
 c-7.92969 -47.1494 -71.3193 -80.0195 -123.26 -80.0195s-115.33 32.8701 -123.26 80.0195c-1.69043 9.9707 7.76953 18.4707 17.71 15.3408c25.9297 -8.31055 64.3994 -13.0605 105.55 -13.0605s79.6201 4.75977 105.55 13.0605zM248 440c136.97 0 248 -111.03 248 -248
 s-111.03 -248 -248 -248s-248 111.03 -248 248s111.03 248 248 248zM248 -8c110.28 0 200 89.7197 200 200s-89.7197 200 -200 200s-200 -89.7197 -200 -200s89.7197 -200 200 -200z" />
    <glyph glyph-name="kiss" unicode="&#xf596;" horiz-adv-x="496" 
 d="M168 272c17.7002 0 32 -14.2998 32 -32s-14.2998 -32 -32 -32s-32 14.2998 -32 32s14.2998 32 32 32zM304 140c0 -13 -13.4004 -27.2998 -35.0996 -36.4004c21.7998 -8.69922 35.1992 -23 35.1992 -36c0 -19.1992 -28.6992 -41.5 -71.5 -44h-0.5
 c-3.69922 0 -7 2.60059 -7.7998 6.2002c-0.899414 3.7998 1.10059 7.7002 4.7002 9.2002l17 7.2002c12.9004 5.5 20.7002 13.5 20.7002 21.5s-7.7998 16 -20.7998 21.5l-16.9004 7.2002c-6 2.59961 -5.7002 12.3994 0 14.7998l17 7.2002
 c12.9004 5.5 20.7002 13.5 20.7002 21.5s-7.7998 16 -20.7998 21.5l-16.9004 7.19922c-3.59961 1.5 -5.59961 5.40039 -4.7002 9.2002c0.799805 3.7998 4.40039 6.60059 8.2002 6.2002c42.7002 -2.5 71.5 -24.7998 71.5 -44zM248 440c137 0 248 -111 248 -248
 s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM328 272c17.7002 0 32 -14.2998 32 -32s-14.2998 -32 -32 -32s-32 14.2998 -32 32s14.2998 32 32 32z
 " />
    <glyph glyph-name="kiss-beam" unicode="&#xf597;" horiz-adv-x="496" 
 d="M168 296c23.7998 0 52.7002 -29.2998 55.7998 -71.4004c0.299805 -3.7998 -2 -7.19922 -5.59961 -8.2998c-3.10059 -1 -7.2002 0 -9.2998 3.7002l-9.5 17c-7.7002 13.7002 -19.2002 21.5996 -31.5 21.5996c-12.3008 0 -23.8008 -7.89941 -31.5 -21.5996l-9.5 -17
 c-1.80078 -3.2002 -5.80078 -4.7002 -9.30078 -3.7002c-3.59961 1.10059 -5.89941 4.60059 -5.59961 8.2998c3.2998 42.1006 32.2002 71.4004 56 71.4004zM248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8
 c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM304 140c0 -13 -13.4004 -27.2998 -35.0996 -36.4004c21.7998 -8.69922 35.1992 -23 35.1992 -36c0 -19.1992 -28.6992 -41.5 -71.5 -44h-0.5
 c-3.69922 0 -7 2.60059 -7.7998 6.2002c-0.899414 3.7998 1.10059 7.7002 4.7002 9.2002l17 7.2002c12.9004 5.5 20.7002 13.5 20.7002 21.5s-7.7998 16 -20.7998 21.5l-16.9004 7.2002c-6 2.59961 -5.7002 12.3994 0 14.7998l17 7.2002
 c12.9004 5.5 20.7002 13.5 20.7002 21.5s-7.7998 16 -20.7998 21.5l-16.9004 7.19922c-3.59961 1.5 -5.59961 5.40039 -4.7002 9.2002c0.799805 3.7998 4.40039 6.60059 8.2002 6.2002c42.7002 -2.5 71.5 -24.7998 71.5 -44zM328 296
 c23.7998 0 52.7002 -29.2998 55.7998 -71.4004c0.299805 -3.7998 -2 -7.19922 -5.59961 -8.2998c-3.10059 -1 -7.2002 0 -9.2998 3.7002l-9.5 17c-7.7002 13.7002 -19.2002 21.5996 -31.5 21.5996c-12.3008 0 -23.8008 -7.89941 -31.5 -21.5996l-9.5 -17
 c-1.80078 -3.2002 -5.80078 -4.7002 -9.30078 -3.7002c-3.59961 1.10059 -5.89941 4.60059 -5.59961 8.2998c3.2998 42.1006 32.2002 71.4004 56 71.4004z" />
    <glyph glyph-name="kiss-wink-heart" unicode="&#xf598;" horiz-adv-x="504" 
 d="M304 139.5c0 -13 -13.4004 -27.2998 -35.0996 -36.4004c21.7998 -8.69922 35.1992 -23 35.1992 -36c0 -19.1992 -28.6992 -41.5 -71.5 -44h-0.5c-3.69922 0 -7 2.60059 -7.7998 6.2002c-0.899414 3.7998 1.10059 7.7002 4.7002 9.2002l17 7.2002
 c12.9004 5.5 20.7002 13.5 20.7002 21.5s-7.7998 16 -20.7998 21.5l-16.9004 7.2002c-6 2.59961 -5.7002 12.3994 0 14.7998l17 7.2002c12.9004 5.5 20.7002 13.5 20.7002 21.5s-7.7998 16 -20.7998 21.5l-16.9004 7.19922c-3.59961 1.5 -5.59961 5.40039 -4.7002 9.2002
 c0.799805 3.7998 4.40039 6.60059 8.2002 6.2002c42.7002 -2.5 71.5 -24.7998 71.5 -44zM374.5 223c-14.7998 13.2002 -46.2002 13.2002 -61 0l-9.5 -8.5c-2.5 -2.2998 -7.90039 -4.7002 -13.7002 -1.59961c-4.39941 2.39941 -6.89941 7.39941 -6.09961 12.3994
 c3.89941 25.2002 34.2002 42.1006 59.7998 42.1006s55.7998 -16.9004 59.7998 -42.1006c0.799805 -5 -1.7002 -10 -6.09961 -12.3994c-4.40039 -2.40039 -9.90039 -1.7002 -13.7002 1.59961zM136 239.5c0 17.7002 14.2998 32 32 32s32 -14.2998 32 -32s-14.2998 -32 -32 -32
 s-32 14.2998 -32 32zM501.1 45.5c9.2002 -23.9004 -4.39941 -49.4004 -28.5 -55.7002l-83 -21.5c-5.39941 -1.39941 -10.8994 1.7998 -12.3994 7.10059l-22.9004 82.5996c-6.59961 24 8.7998 48.5996 34 52.5996c22 3.5 43.1006 -11.5996 49 -33l2.2998 -8.39941
 l8.40039 2.2002c21.5996 5.59961 45.0996 -5.10059 53.0996 -25.9004zM334 11.7002c17.7002 -64 10.9004 -39.5 13.4004 -46.7998c-30.5 -13.4004 -64 -20.9004 -99.4004 -20.9004c-137 0 -248 111 -248 248s111 248 248 248s248 -111 247.9 -248
 c0 -31.7998 -6.2002 -62.0996 -17.1006 -90c-6 1.5 -12.2002 2.7998 -18.5996 2.90039c-5.60059 9.69922 -13.6006 17.5 -22.6006 23.8994c6.7002 19.9004 10.4004 41.1006 10.4004 63.2002c0 110.3 -89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200
 c30.7998 0 59.9004 7.2002 86 19.7002z" />
    <glyph glyph-name="laugh" unicode="&#xf599;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM389.4 50.5996c37.7998 37.8008 58.5996 88 58.5996 141.4s-20.7998 103.6 -58.5996 141.4c-37.8008 37.7998 -88 58.5996 -141.4 58.5996s-103.6 -20.7998 -141.4 -58.5996
 c-37.7998 -37.8008 -58.5996 -88 -58.5996 -141.4s20.7998 -103.6 58.5996 -141.4c37.8008 -37.7998 88 -58.5996 141.4 -58.5996s103.6 20.7998 141.4 58.5996zM328 224c-17.7002 0 -32 14.2998 -32 32s14.2998 32 32 32s32 -14.2998 32 -32s-14.2998 -32 -32 -32zM168 224
 c-17.7002 0 -32 14.2998 -32 32s14.2998 32 32 32s32 -14.2998 32 -32s-14.2998 -32 -32 -32zM362.4 160c8.19922 0 14.5 -7 13.5 -15c-7.5 -59.2002 -58.9004 -105 -121.101 -105h-13.5996c-62.2002 0 -113.601 45.7998 -121.101 105c-1 8 5.30078 15 13.5 15h228.801z" />
    <glyph glyph-name="laugh-beam" unicode="&#xf59a;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM389.4 50.5996c37.7998 37.8008 58.5996 88 58.5996 141.4s-20.7998 103.6 -58.5996 141.4c-37.8008 37.7998 -88 58.5996 -141.4 58.5996s-103.6 -20.7998 -141.4 -58.5996
 c-37.7998 -37.8008 -58.5996 -88 -58.5996 -141.4s20.7998 -103.6 58.5996 -141.4c37.8008 -37.7998 88 -58.5996 141.4 -58.5996s103.6 20.7998 141.4 58.5996zM328 296c23.7998 0 52.7002 -29.2998 55.7998 -71.4004c0.700195 -8.5 -10.7998 -11.8994 -14.8994 -4.5
 l-9.5 17c-7.7002 13.7002 -19.2002 21.6006 -31.5 21.6006c-12.3008 0 -23.8008 -7.90039 -31.5 -21.6006l-9.5 -17c-4.10059 -7.39941 -15.6006 -4.09961 -14.9004 4.5c3.2998 42.1006 32.2002 71.4004 56 71.4004zM127 220.1c-4.2002 -7.39941 -15.7002 -4 -15.0996 4.5
 c3.2998 42.1006 32.1992 71.4004 56 71.4004c23.7998 0 52.6992 -29.2998 56 -71.4004c0.699219 -8.5 -10.8008 -11.8994 -14.9004 -4.5l-9.5 17c-7.7002 13.7002 -19.2002 21.6006 -31.5 21.6006s-23.7998 -7.90039 -31.5 -21.6006zM362.4 160c8.19922 0 14.5 -7 13.5 -15
 c-7.5 -59.2002 -58.9004 -105 -121.101 -105h-13.5996c-62.2002 0 -113.601 45.7998 -121.101 105c-1 8 5.30078 15 13.5 15h228.801z" />
    <glyph glyph-name="laugh-squint" unicode="&#xf59b;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM389.4 50.5996c37.7998 37.8008 58.5996 88 58.5996 141.4s-20.7998 103.6 -58.5996 141.4c-37.8008 37.7998 -88 58.5996 -141.4 58.5996s-103.6 -20.7998 -141.4 -58.5996
 c-37.7998 -37.8008 -58.5996 -88 -58.5996 -141.4s20.7998 -103.6 58.5996 -141.4c37.8008 -37.7998 88 -58.5996 141.4 -58.5996s103.6 20.7998 141.4 58.5996zM343.6 252l33.6006 -40.2998c8.59961 -10.4004 -3.90039 -24.7998 -15.4004 -18l-80 48
 c-7.7998 4.7002 -7.7998 15.8994 0 20.5996l80 48c11.6006 6.7998 24 -7.7002 15.4004 -18zM134.2 193.7c-11.6006 -6.7998 -24.1006 7.59961 -15.4004 18l33.6006 40.2998l-33.6006 40.2998c-8.59961 10.2998 3.7998 24.9004 15.4004 18l80 -48
 c7.7998 -4.7002 7.7998 -15.8994 0 -20.5996zM362.4 160c8.19922 0 14.5 -7 13.5 -15c-7.5 -59.2002 -58.9004 -105 -121.101 -105h-13.5996c-62.2002 0 -113.601 45.7998 -121.101 105c-1 8 5.30078 15 13.5 15h228.801z" />
    <glyph glyph-name="laugh-wink" unicode="&#xf59c;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM389.4 50.5996c37.7998 37.8008 58.5996 88 58.5996 141.4s-20.7998 103.6 -58.5996 141.4c-37.8008 37.7998 -88 58.5996 -141.4 58.5996s-103.6 -20.7998 -141.4 -58.5996
 c-37.7998 -37.8008 -58.5996 -88 -58.5996 -141.4s20.7998 -103.6 58.5996 -141.4c37.8008 -37.7998 88 -58.5996 141.4 -58.5996s103.6 20.7998 141.4 58.5996zM328 284c25.7002 0 55.9004 -16.9004 59.7002 -42.0996c1.7998 -11.1006 -11.2998 -18.2002 -19.7998 -10.8008
 l-9.5 8.5c-14.8008 13.2002 -46.2002 13.2002 -61 0l-9.5 -8.5c-8.30078 -7.39941 -21.5 -0.399414 -19.8008 10.8008c4 25.1992 34.2002 42.0996 59.9004 42.0996zM168 224c-17.7002 0 -32 14.2998 -32 32s14.2998 32 32 32s32 -14.2998 32 -32s-14.2998 -32 -32 -32z
 M362.4 160c8.19922 0 14.5 -7 13.5 -15c-7.5 -59.2002 -58.9004 -105 -121.101 -105h-13.5996c-62.2002 0 -113.601 45.7998 -121.101 105c-1 8 5.30078 15 13.5 15h228.801z" />
    <glyph glyph-name="meh-blank" unicode="&#xf5a4;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM168 272c17.7002 0 32 -14.2998 32 -32s-14.2998 -32 -32 -32
 s-32 14.2998 -32 32s14.2998 32 32 32zM328 272c17.7002 0 32 -14.2998 32 -32s-14.2998 -32 -32 -32s-32 14.2998 -32 32s14.2998 32 32 32z" />
    <glyph glyph-name="meh-rolling-eyes" unicode="&#xf5a5;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM336 296c39.7998 0 72 -32.2002 72 -72s-32.2002 -72 -72 -72
 s-72 32.2002 -72 72s32.2002 72 72 72zM336 184c22.0996 0 40 17.9004 40 40c0 13.5996 -7.2998 25.0996 -17.7002 32.2998c1 -2.59961 1.7002 -5.39941 1.7002 -8.2998c0 -13.2998 -10.7002 -24 -24 -24s-24 10.7002 -24 24c0 3 0.700195 5.7002 1.7002 8.2998
 c-10.4004 -7.2002 -17.7002 -18.7002 -17.7002 -32.2998c0 -22.0996 17.9004 -40 40 -40zM232 224c0 -39.7998 -32.2002 -72 -72 -72s-72 32.2002 -72 72s32.2002 72 72 72s72 -32.2002 72 -72zM120 224c0 -22.0996 17.9004 -40 40 -40s40 17.9004 40 40
 c0 13.5996 -7.2998 25.0996 -17.7002 32.2998c1 -2.59961 1.7002 -5.39941 1.7002 -8.2998c0 -13.2998 -10.7002 -24 -24 -24s-24 10.7002 -24 24c0 3 0.700195 5.7002 1.7002 8.2998c-10.4004 -7.2002 -17.7002 -18.7002 -17.7002 -32.2998zM312 96
 c13.2002 0 24 -10.7998 24 -24s-10.7998 -24 -24 -24h-128c-13.2002 0 -24 10.7998 -24 24s10.7998 24 24 24h128z" />
    <glyph glyph-name="sad-cry" unicode="&#xf5b3;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM392 53.5996c34.5996 35.9004 56 84.7002 56 138.4c0 110.3 -89.7002 200 -200 200s-200 -89.7002 -200 -200c0 -53.7002 21.4004 -102.4 56 -138.4v114.4
 c0 13.2002 10.7998 24 24 24s24 -10.7998 24 -24v-151.4c28.5 -15.5996 61.2002 -24.5996 96 -24.5996s67.5 9 96 24.5996v151.4c0 13.2002 10.7998 24 24 24s24 -10.7998 24 -24v-114.4zM205.8 213.5c-5.7998 -3.2002 -11.2002 -0.700195 -13.7002 1.59961l-9.5 8.5
 c-14.7998 13.2002 -46.1992 13.2002 -61 0l-9.5 -8.5c-3.7998 -3.39941 -9.2998 -4 -13.6992 -1.59961c-4.40039 2.40039 -6.90039 7.40039 -6.10059 12.4004c3.90039 25.1992 34.2002 42.0996 59.7998 42.0996c25.6006 0 55.8008 -16.9004 59.8008 -42.0996
 c0.799805 -5 -1.7002 -10 -6.10059 -12.4004zM344 268c25.7002 0 55.9004 -16.9004 59.7998 -42.0996c0.799805 -5 -1.7002 -10 -6.09961 -12.4004c-5.7002 -3.09961 -11.2002 -0.599609 -13.7002 1.59961l-9.5 8.5c-14.7998 13.2002 -46.2002 13.2002 -61 0l-9.5 -8.5
 c-3.7998 -3.39941 -9.2002 -4 -13.7002 -1.59961c-4.39941 2.40039 -6.89941 7.40039 -6.09961 12.4004c3.89941 25.1992 34.0996 42.0996 59.7998 42.0996zM248 176c30.9004 0 56 -28.7002 56 -64s-25.0996 -64 -56 -64s-56 28.7002 -56 64s25.0996 64 56 64z" />
    <glyph glyph-name="sad-tear" unicode="&#xf5b4;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM256 144c38.0996 0 74 -16.7998 98.5 -46.0996
 c8.5 -10.2002 7.09961 -25.3008 -3.09961 -33.8008c-10.6006 -8.7998 -25.7002 -6.69922 -33.8008 3.10059c-15.2998 18.2998 -37.7998 28.7998 -61.5996 28.7998c-13.2002 0 -24 10.7998 -24 24s10.7998 24 24 24zM168 208c-17.7002 0 -32 14.2998 -32 32s14.2998 32 32 32
 s32 -14.2998 32 -32s-14.2998 -32 -32 -32zM328 272c17.7002 0 32 -14.2998 32 -32s-14.2998 -32 -32 -32s-32 14.2998 -32 32s14.2998 32 32 32zM162.4 173.2c2.7998 3.7002 8.39941 3.7002 11.1992 0c11.4004 -15.2998 36.4004 -50.6006 36.4004 -68.1006
 c0 -22.6992 -18.7998 -41.0996 -42 -41.0996s-42 18.4004 -42 41.0996c0 17.5 25 52.8008 36.4004 68.1006z" />
    <glyph glyph-name="smile-beam" unicode="&#xf5b8;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM332 135.4c8.5 10.1992 23.5996 11.5 33.7998 3.09961
 c10.2002 -8.5 11.6006 -23.5996 3.10059 -33.7998c-30 -36 -74.1006 -56.6006 -120.9 -56.6006s-90.9004 20.6006 -120.9 56.6006c-8.39941 10.2002 -7.09961 25.2998 3.10059 33.7998c10.2002 8.40039 25.2998 7.09961 33.7998 -3.09961
 c20.7998 -25.1006 51.5 -39.4004 84 -39.4004s63.2002 14.4004 84 39.4004zM136.5 237l-9.5 -17c-1.90039 -3.2002 -5.90039 -4.7998 -9.2998 -3.7002c-3.60059 1.10059 -6 4.60059 -5.7002 8.2998c3.2998 42.1006 32.2002 71.4004 56 71.4004s52.7002 -29.2998 56 -71.4004
 c0.299805 -3.7998 -2.09961 -7.19922 -5.7002 -8.2998c-3.09961 -1 -7.2002 0 -9.2998 3.7002l-9.5 17c-7.7002 13.7002 -19.2002 21.5996 -31.5 21.5996s-23.7998 -7.89941 -31.5 -21.5996zM328 296c23.7998 0 52.7002 -29.2998 56 -71.4004
 c0.299805 -3.7998 -2.09961 -7.19922 -5.7002 -8.2998c-3.09961 -1 -7.2002 0 -9.2998 3.7002l-9.5 17c-7.7002 13.7002 -19.2002 21.5996 -31.5 21.5996s-23.7998 -7.89941 -31.5 -21.5996l-9.5 -17c-1.90039 -3.2002 -5.7998 -4.7998 -9.2998 -3.7002
 c-3.60059 1.10059 -6 4.60059 -5.7002 8.2998c3.2998 42.1006 32.2002 71.4004 56 71.4004z" />
    <glyph glyph-name="surprise" unicode="&#xf5c2;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM248 168c35.2998 0 64 -28.7002 64 -64s-28.7002 -64 -64 -64
 s-64 28.7002 -64 64s28.7002 64 64 64zM200 240c0 -17.7002 -14.2998 -32 -32 -32s-32 14.2998 -32 32s14.2998 32 32 32s32 -14.2998 32 -32zM328 272c17.7002 0 32 -14.2998 32 -32s-14.2998 -32 -32 -32s-32 14.2998 -32 32s14.2998 32 32 32z" />
    <glyph glyph-name="tired" unicode="&#xf5c8;" horiz-adv-x="496" 
 d="M248 440c137 0 248 -111 248 -248s-111 -248 -248 -248s-248 111 -248 248s111 248 248 248zM248 -8c110.3 0 200 89.7002 200 200s-89.7002 200 -200 200s-200 -89.7002 -200 -200s89.7002 -200 200 -200zM377.1 295.8c3.80078 -4.39941 3.90039 -11 0.100586 -15.5
 l-33.6006 -40.2998l33.6006 -40.2998c3.7998 -4.5 3.7002 -11 -0.100586 -15.5c-3.5 -4.10059 -9.89941 -5.7002 -15.2998 -2.5l-80 48c-3.59961 2.2002 -5.7998 6.09961 -5.7998 10.2998s2.2002 8.09961 5.7998 10.2998l80 48c5 2.90039 11.5 1.90039 15.2998 -2.5z
 M220 240c0 -4.2002 -2.2002 -8.09961 -5.7998 -10.2998l-80 -48c-5.40039 -3.2002 -11.7998 -1.60059 -15.2998 2.5c-3.80078 4.5 -3.90039 11 -0.100586 15.5l33.6006 40.2998l-33.6006 40.2998c-3.7998 4.5 -3.7002 11 0.100586 15.5
 c3.7998 4.40039 10.2998 5.5 15.2998 2.5l80 -48c3.59961 -2.2002 5.7998 -6.09961 5.7998 -10.2998zM248 176c45.4004 0 100.9 -38.2998 107.8 -93.2998c1.5 -11.9004 -7 -21.6006 -15.5 -17.9004c-22.7002 9.7002 -56.2998 15.2002 -92.2998 15.2002
 s-69.5996 -5.5 -92.2998 -15.2002c-8.60059 -3.7002 -17 6.10059 -15.5 17.9004c6.89941 55 62.3994 93.2998 107.8 93.2998z" />
  </font>
 </defs></svg>
--- a/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-regular-400.ttf
+++ b/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-regular-400.ttf
--- a/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-regular-400.woff
+++ b/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-regular-400.woff
--- a/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-regular-400.woff2
+++ b/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-regular-400.woff2
--- a/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-solid-900.eot
+++ b/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-solid-900.eot
--- a/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-solid-900.svg
+++ b/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-solid-900.svg
--- a/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-solid-900.ttf
+++ b/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-solid-900.ttf
--- a/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-solid-900.woff
+++ b/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-solid-900.woff
--- a/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-solid-900.woff2
+++ b/0.2/_static/vendor/fontawesome/5.13.0/webfonts/fa-solid-900.woff2
--- a/0.2/_static/webpack-macros.html
+++ b/0.2/_static/webpack-macros.html
@ -0,0 +1,25 @@
 <!-- these macros are generated by "yarn build:production". do not edit by hand. -->
 {% macro head_pre_icons() %}
  <link rel="stylesheet"
    href="{{ pathto('_static/vendor/fontawesome/5.13.0/css/all.min.css', 1) }}">
  <link rel="preload" as="font" type="font/woff2" crossorigin
    href="{{ pathto('_static/vendor/fontawesome/5.13.0/webfonts/fa-solid-900.woff2', 1) }}">
  <link rel="preload" as="font" type="font/woff2" crossorigin
    href="{{ pathto('_static/vendor/fontawesome/5.13.0/webfonts/fa-brands-400.woff2', 1) }}">
 {% endmacro %}
 {% macro head_pre_fonts() %}
 {% endmacro %}
 {% macro head_pre_bootstrap() %}
  <link href="{{ pathto('_static/css/theme.css', 1) }}" rel="stylesheet" />
  <link href="{{ pathto('_static/css/index.c5995385ac14fb8791e8eb36b4908be2.css', 1) }}" rel="stylesheet" />
 {% endmacro %}
 {% macro head_js_preload() %}
  <link rel="preload" as="script" href="{{ pathto('_static/js/index.1c5a1a01449ed65a7b51.js', 1) }}">
 {% endmacro %}
 {% macro body_post() %}
  <script src="{{ pathto('_static/js/index.1c5a1a01449ed65a7b51.js', 1) }}"></script>
 {% endmacro %}
--- a/0.2/about/index.html
+++ b/0.2/about/index.html
@ -1,175 +1,256 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="shortcut icon" href="../img/favicon.ico">
    <title>About - MIPLearn</title>
    <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.12.0/css/all.css">
    <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.12.0/css/v4-shims.css">
    <link rel="stylesheet" href="//cdn.jsdelivr.net/npm/hack-font@3.3.0/build/web/hack.min.css">
    <link href='//rsms.me/inter/inter.css' rel='stylesheet' type='text/css'>
    <link href='//fonts.googleapis.com/css?family=Open+Sans:300italic,400italic,700italic,400,300,600,700&subset=latin-ext,latin' rel='stylesheet' type='text/css'>
    <link href="../css/bootstrap-custom.min.css" rel="stylesheet">
    <link href="../css/base.min.css" rel="stylesheet">
    <link href="../css/cinder.min.css" rel="stylesheet">
 <!DOCTYPE html>
-        <link rel="stylesheet" href="//cdn.jsdelivr.net/gh/highlightjs/cdn-release@9.18.0/build/styles/github.min.css">
+<html>
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>4. About &#8212; MIPLearn&lt;br/&gt;&lt;small&gt;0.2.0&lt;/small&gt;</title>
  <link href="../_static/css/theme.css" rel="stylesheet" />
  <link href="../_static/css/index.c5995385ac14fb8791e8eb36b4908be2.css" rel="stylesheet" />
  <link rel="stylesheet"
    href="../_static/vendor/fontawesome/5.13.0/css/all.min.css">
  <link rel="preload" as="font" type="font/woff2" crossorigin
    href="../_static/vendor/fontawesome/5.13.0/webfonts/fa-solid-900.woff2">
  <link rel="preload" as="font" type="font/woff2" crossorigin
    href="../_static/vendor/fontawesome/5.13.0/webfonts/fa-brands-400.woff2">
    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
    <link rel="stylesheet" href="../_static/sphinx-book-theme.acff12b8f9c144ce68a297486a2fa670.css" type="text/css" />
    <link rel="stylesheet" type="text/css" href="../_static/custom.css" />
  <link rel="preload" as="script" href="../_static/js/index.1c5a1a01449ed65a7b51.js">
    <script id="documentation_options" data-url_root="../" src="../_static/documentation_options.js"></script>
    <script src="../_static/jquery.js"></script>
    <script src="../_static/underscore.js"></script>
    <script src="../_static/doctools.js"></script>
    <script src="../_static/sphinx-book-theme.12a9622fbb08dcb3a2a40b2c02b83a57.js"></script>
    <script async="async" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/latest.js?config=TeX-AMS-MML_HTMLorMML"></script>
    <script type="text/x-mathjax-config">MathJax.Hub.Config({"tex2jax": {"inlineMath": [["\\(", "\\)"]], "displayMath": [["\\[", "\\]"]], "processRefs": false, "processEnvironments": false}})</script>
    <link rel="author" title="About these documents" href="#" />
    <link rel="index" title="Index" href="../genindex/" />
    <link rel="search" title="Search" href="../search/" />
    <link rel="prev" title="3. Customization" href="../customization/" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <meta name="docsearch:language" content="en" />
  </head>
  <body data-spy="scroll" data-target="#bd-toc-nav" data-offset="80">
    <div class="container-fluid" id="banner"></div>
    <div class="container-xl">
      <div class="row">
 <div class="col-12 col-md-3 bd-sidebar site-navigation show" id="site-navigation">
        <div class="navbar-brand-box">
    <a class="navbar-brand text-wrap" href="../">
      <h1 class="site-logo" id="site-title">MIPLearn<br/><small>0.2.0</small></h1>
    </a>
 </div><form class="bd-search d-flex align-items-center" action="../search/" method="get">
  <i class="icon fas fa-search"></i>
  <input type="search" class="form-control" name="q" id="search-input" placeholder="Search the docs ..." aria-label="Search the docs ..." autocomplete="off" >
 </form><nav class="bd-links" id="bd-docs-nav" aria-label="Main navigation">
    <div class="bd-toc-item active">
        <ul class="current nav bd-sidenav">
 <li class="toctree-l1">
  <a class="reference internal" href="../usage/">
   <span class="sectnum">
    1.
   </span>
   Using MIPLearn
  </a>
 </li>
 <li class="toctree-l1">
  <a class="reference internal" href="../benchmark/">
   <span class="sectnum">
    2.
   </span>
   Benchmarks
  </a>
 </li>
 <li class="toctree-l1">
  <a class="reference internal" href="../customization/">
   <span class="sectnum">
    3.
   </span>
   Customization
  </a>
 </li>
 <li class="toctree-l1 current active">
  <a class="current reference internal" href="#">
   <span class="sectnum">
    4.
   </span>
   About
  </a>
 </li>
 </ul>
    </div>
 </nav> <!-- To handle the deprecated key -->
-    <link href="../css/custom.css" rel="stylesheet">
+</div>
    <!-- HTML5 shim and Respond.js IE8 support of HTML5 elements and media queries -->
    <!--[if lt IE 9]>
            <script src="https://cdn.jsdelivr.net/npm/html5shiv@3.7.3/dist/html5shiv.min.js"></script>
            <script src="https://cdn.jsdelivr.net/npm/respond.js@1.4.2/dest/respond.min.js"></script>
        <![endif]-->
 </head>
-<body>
+<main class="col py-md-3 pl-md-4 bd-content overflow-auto" role="main">
-    <div class="navbar navbar-default navbar-fixed-top" role="navigation">
+    <div class="topbar container-xl fixed-top">
-    <div class="container">
+    <div class="topbar-contents row">
        <div class="col-12 col-md-3 bd-topbar-whitespace site-navigation show"></div>
        <div class="col pl-md-4 topbar-main">
-        <!-- Collapsed navigation -->
+            <button id="navbar-toggler" class="navbar-toggler ml-0" type="button" data-toggle="collapse"
-        <div class="navbar-header">
+                data-toggle="tooltip" data-placement="bottom" data-target=".site-navigation" aria-controls="navbar-menu"
-            <!-- Expander button -->
+                aria-expanded="true" aria-label="Toggle navigation" aria-controls="site-navigation"
-            <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
+                title="Toggle navigation" data-toggle="tooltip" data-placement="left">
-                <span class="sr-only">Toggle navigation</span>
+                <i class="fas fa-bars"></i>
-                <span class="icon-bar"></span>
+                <i class="fas fa-arrow-left"></i>
-                <span class="icon-bar"></span>
+                <i class="fas fa-arrow-up"></i>
                <span class="icon-bar"></span>
            </button>
-            <!-- Main title -->
+<div class="dropdown-buttons-trigger">
-
+    <button id="dropdown-buttons-trigger" class="btn btn-secondary topbarbtn" aria-label="Download this page"><i
-            
+            class="fas fa-download"></i></button>
              <a class="navbar-brand" href="..">MIPLearn</a>
        </div>
-        <!-- Expanded navigation -->
+    <div class="dropdown-buttons">
-        <div class="navbar-collapse collapse">
+        <!-- ipynb file if we had a myst markdown file -->
                <!-- Main navigation -->
                <ul class="nav navbar-nav">
                    <li >
                        <a href="..">Home</a>
                    </li>
                    <li >
                        <a href="../usage/">Usage</a>
                    </li>
                    <li >
                        <a href="../problems/">Problems</a>
                    </li>
        <!-- Download raw file -->
        <a class="dropdown-buttons" href="../_sources/about.md.txt"><button type="button"
                class="btn btn-secondary topbarbtn" title="Download source file" data-toggle="tooltip"
                data-placement="left">.md</button></a>
        <!-- Download PDF via print -->
        <button type="button" id="download-print" class="btn btn-secondary topbarbtn" title="Print to PDF"
            onClick="window.print()" data-toggle="tooltip" data-placement="left">.pdf</button>
    </div>
 </div>
            <!-- Source interaction buttons -->
-                    <li >
+<div class="dropdown-buttons-trigger">
-                        <a href="../customization/">Customization</a>
+    <button id="dropdown-buttons-trigger" class="btn btn-secondary topbarbtn"
-                    </li>
+        aria-label="Connect with source repository"><i class="fab fa-github"></i></button>
    <div class="dropdown-buttons sourcebuttons">
        <a class="repository-button"
            href="https://github.com/ANL-CEEESA/MIPLearn/"><button type="button" class="btn btn-secondary topbarbtn"
                data-toggle="tooltip" data-placement="left" title="Source repository"><i
                    class="fab fa-github"></i>repository</button></a>
    </div>
 </div>
-                    <li class="active">
+            <!-- Full screen (wrap in <a> to have style consistency -->
                        <a href="./">About</a>
                    </li>
 <a class="full-screen-button"><button type="button" class="btn btn-secondary topbarbtn" data-toggle="tooltip"
        data-placement="bottom" onclick="toggleFullScreen()" aria-label="Fullscreen mode"
        title="Fullscreen mode"><i
            class="fas fa-expand"></i></button></a>
            <!-- Launch buttons -->
-                    <li >
+        </div>
                        <a href="../api/miplearn/index.html">API</a>
                    </li>
        <!-- Table of contents -->
        <div class="d-none d-md-block col-md-2 bd-toc show">
-                </ul>
+            <div class="tocsection onthispage pt-5 pb-3">
                <i class="fas fa-list"></i> Contents
            </div>
            <nav id="bd-toc-nav">
                <ul class="visible nav section-nav flex-column">
 <li class="toc-h2 nav-item toc-entry">
  <a class="reference internal nav-link" href="#authors">
   <span class="sectnum">
    4.1.
   </span>
   Authors
  </a>
 </li>
 <li class="toc-h2 nav-item toc-entry">
  <a class="reference internal nav-link" href="#acknowledgments">
   <span class="sectnum">
    4.2.
   </span>
   Acknowledgments
  </a>
 </li>
 <li class="toc-h2 nav-item toc-entry">
  <a class="reference internal nav-link" href="#references">
   <span class="sectnum">
    4.3.
   </span>
   References
  </a>
 </li>
 <li class="toc-h2 nav-item toc-entry">
  <a class="reference internal nav-link" href="#license">
   <span class="sectnum">
    4.4.
   </span>
   License
  </a>
 </li>
 </ul>
-            <ul class="nav navbar-nav navbar-right">
+            </nav>
                    <li>
                        <a href="#" data-toggle="modal" data-target="#mkdocs_search_modal">
                            <i class="fas fa-search"></i> Search
                        </a>
                    </li>
                    <li >
                        <a rel="prev" href="../customization/">
                            <i class="fas fa-arrow-left"></i> Previous
                        </a>
                    </li>
                    <li class="disabled">
                        <a rel="next" >
                            Next <i class="fas fa-arrow-right"></i>
                        </a>
                    </li>
                    <li>
                        <a href="https://github.com/ANL-CEEESA/MIPLearn/edit/dev/docs/about.md"><i class="fab fa-github"></i> Edit on GitHub</a>
                    </li>
            </ul>
        </div>
    </div>
 </div>
-
+    <div id="main-content" class="row">
-    <div class="container">
+        <div class="col-12 col-md-9 pl-md-3 pr-md-0">
-        
+        
-        
+              <div>
-        <div class="col-md-3"><div class="bs-sidebar hidden-print affix well" role="complementary">
+                
-    <ul class="nav bs-sidenav">
+  <div class="section" id="about">
-        <li class="first-level active"><a href="#about">About</a></li>
+<h1><span class="sectnum">4.</span> About<a class="headerlink" href="#about" title="Permalink to this headline">¶</a></h1>
-            <li class="second-level"><a href="#authors">Authors</a></li>
+<div class="section" id="authors">
-                
+<h2><span class="sectnum">4.1.</span> Authors<a class="headerlink" href="#authors" title="Permalink to this headline">¶</a></h2>
-            <li class="second-level"><a href="#acknowledgments">Acknowledgments</a></li>
+<ul class="simple">
-                
+<li><p><strong>Alinson S. Xavier,</strong> Argonne National Laboratory &lt;<a class="reference external" href="mailto:axavier&#37;&#52;&#48;anl&#46;gov">mailto:axavier<span>&#64;</span>anl<span>&#46;</span>gov</a>&gt;</p></li>
-            <li class="second-level"><a href="#references">References</a></li>
+<li><p><strong>Feng Qiu,</strong> Argonne National Laboratory &lt;<a class="reference external" href="mailto:fqiu&#37;&#52;&#48;anl&#46;gov">mailto:fqiu<span>&#64;</span>anl<span>&#46;</span>gov</a>&gt;</p></li>
            <li class="second-level"><a href="#license">License</a></li>
    </ul>
 </div></div>
        <div class="col-md-9" role="main">
 <h1 id="about">About</h1>
 <h3 id="authors">Authors</h3>
 <ul>
 <li><strong>Alinson S. Xavier,</strong> Argonne National Laboratory &lt;<a href="&#109;&#97;&#105;&#108;&#116;&#111;&#58;&#97;&#120;&#97;&#118;&#105;&#101;&#114;&#64;&#97;&#110;&#108;&#46;&#103;&#111;&#118;">&#97;&#120;&#97;&#118;&#105;&#101;&#114;&#64;&#97;&#110;&#108;&#46;&#103;&#111;&#118;</a>&gt;</li>
 <li><strong>Feng Qiu,</strong> Argonne National Laboratory &lt;<a href="&#109;&#97;&#105;&#108;&#116;&#111;&#58;&#102;&#113;&#105;&#117;&#64;&#97;&#110;&#108;&#46;&#103;&#111;&#118;">&#102;&#113;&#105;&#117;&#64;&#97;&#110;&#108;&#46;&#103;&#111;&#118;</a>&gt;</li>
 </ul>
-<h3 id="acknowledgments">Acknowledgments</h3>
+</div>
-<ul>
+<div class="section" id="acknowledgments">
-<li>Based upon work supported by <strong>Laboratory Directed Research and Development</strong> (LDRD) funding from Argonne National Laboratory, provided by the Director, Office of Science, of the U.S. Department of Energy under Contract No. DE-AC02-06CH11357, and the <strong>U.S. Department of Energy Advanced Grid Modeling Program</strong> under Grant DE-OE0000875.</li>
+<h2><span class="sectnum">4.2.</span> Acknowledgments<a class="headerlink" href="#acknowledgments" title="Permalink to this headline">¶</a></h2>
 <ul class="simple">
 <li><p>Based upon work supported by <strong>Laboratory Directed Research and Development</strong> (LDRD) funding from Argonne National Laboratory, provided by the Director, Office of Science, of the U.S. Department of Energy under Contract No. DE-AC02-06CH11357, and the <strong>U.S. Department of Energy Advanced Grid Modeling Program</strong> under Grant DE-OE0000875.</p></li>
 </ul>
-<h3 id="references">References</h3>
+</div>
 <div class="section" id="references">
 <h2><span class="sectnum">4.3.</span> References<a class="headerlink" href="#references" title="Permalink to this headline">¶</a></h2>
 <p>If you use MIPLearn in your research, or the included problem generators, we kindly request that you cite the package as follows:</p>
-<ul>
+<ul class="simple">
-<li><strong>Alinson S. Xavier, Feng Qiu.</strong> <em>MIPLearn: An Extensible Framework for Learning-Enhanced Optimization</em>. Zenodo (2020). DOI: <a href="https://doi.org/10.5281/zenodo.4287567">10.5281/zenodo.4287567</a></li>
+<li><p><strong>Alinson S. Xavier, Feng Qiu.</strong> <em>MIPLearn: An Extensible Framework for Learning-Enhanced Optimization</em>. Zenodo (2020). DOI: <a class="reference external" href="https://doi.org/10.5281/zenodo.4287567">10.5281/zenodo.4287567</a></p></li>
 </ul>
 <p>If you use MIPLearn in the field of power systems optimization, we kindly request that you cite the reference below, in which the main techniques implemented in MIPLearn were first developed:</p>
-<ul>
+<ul class="simple">
-<li><strong>Alinson S. Xavier, Feng Qiu, Shabbir Ahmed.</strong> <em>Learning to Solve Large-Scale Unit Commitment Problems.</em> INFORMS Journal on Computing (2020). DOI: <a href="https://doi.org/10.1287/ijoc.2020.0976">10.1287/ijoc.2020.0976</a></li>
+<li><p><strong>Alinson S. Xavier, Feng Qiu, Shabbir Ahmed.</strong> <em>Learning to Solve Large-Scale Unit Commitment Problems.</em> INFORMS Journal on Computing (2020). DOI: <a class="reference external" href="https://doi.org/10.1287/ijoc.2020.0976">10.1287/ijoc.2020.0976</a></p></li>
 </ul>
-<h3 id="license">License</h3>
+</div>
-<pre><code class="language-text">MIPLearn, an extensible framework for Learning-Enhanced Mixed-Integer Optimization
+<div class="section" id="license">
 <h2><span class="sectnum">4.4.</span> License<a class="headerlink" href="#license" title="Permalink to this headline">¶</a></h2>
 <div class="highlight-text notranslate"><div class="highlight"><pre><span></span>MIPLearn, an extensible framework for Learning-Enhanced Mixed-Integer Optimization
 Copyright © 2020, UChicago Argonne, LLC. All Rights Reserved.
 Redistribution and use in source and binary forms, with or without modification, are permitted
@ -193,109 +274,39 @@ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSE
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
-</code></pre></div>
+</pre></div>
-        
+</div>
-        
+</div>
-    </div>
+</div>
      <footer class="col-md-12 text-center">
            <hr>
            <p>
            <small>Copyright © 2020, UChicago Argonne, LLC. All Rights Reserved.</small><br>
            <small>Documentation built with <a href="http://www.mkdocs.org/">MkDocs</a>.</small>
            </p>
              </div>
-      </footer>
+        <div class='prev-next-bottom'>
-    <script src="//ajax.googleapis.com/ajax/libs/jquery/1.12.4/jquery.min.js"></script>
+    <a class='left-prev' id="prev-link" href="../customization/" title="previous page"><span class="sectnum">3.</span> Customization</a>
    <script src="../js/bootstrap-3.0.3.min.js"></script>
        </div>
-    <script src="//cdn.jsdelivr.net/gh/highlightjs/cdn-release@9.18.0/build/highlight.min.js"></script>
+        </div>
    </div>
    <footer class="footer mt-5 mt-md-0">
    <div class="container">
      <p>
-    <script>hljs.initHighlightingOnLoad();</script>
+            &copy; Copyright 2020-2021, UChicago Argonne, LLC.<br/>
      </p>
    </div>
  </footer>
 </main>
-    <script>var base_url = ".."</script>
+      </div>
    </div>
-    <script src="../js/base.js"></script>
+  <script src="../_static/js/index.1c5a1a01449ed65a7b51.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
    <script src="../js/mathjax.js"></script>
    <script src="../search/main.js"></script>
    <div class="modal" id="mkdocs_search_modal" tabindex="-1" role="dialog" aria-labelledby="searchModalLabel" aria-hidden="true">
    <div class="modal-dialog modal-lg">
        <div class="modal-content">
            <div class="modal-header">
                <button type="button" class="close" data-dismiss="modal">
                    <span aria-hidden="true">&times;</span>
                    <span class="sr-only">Close</span>
                </button>
                <h4 class="modal-title" id="searchModalLabel">Search</h4>
            </div>
            <div class="modal-body">
                <p>
                    From here you can search these documents. Enter
                    your search terms below.
                </p>
                <form>
                    <div class="form-group">
                        <input type="text" class="form-control" placeholder="Search..." id="mkdocs-search-query" title="Type search term here">
                    </div>
                </form>
                <div id="mkdocs-search-results"></div>
            </div>
            <div class="modal-footer">
            </div>
        </div>
    </div>
 </div><div class="modal" id="mkdocs_keyboard_modal" tabindex="-1" role="dialog" aria-labelledby="keyboardModalLabel" aria-hidden="true">
    <div class="modal-dialog">
        <div class="modal-content">
            <div class="modal-header">
                <h4 class="modal-title" id="keyboardModalLabel">Keyboard Shortcuts</h4>
                <button type="button" class="close" data-dismiss="modal"><span aria-hidden="true">&times;</span><span class="sr-only">Close</span></button>
            </div>
            <div class="modal-body">
              <table class="table">
                <thead>
                  <tr>
                    <th style="width: 20%;">Keys</th>
                    <th>Action</th>
                  </tr>
                </thead>
                <tbody>
                  <tr>
                    <td class="help shortcut"><kbd>?</kbd></td>
                    <td>Open this help</td>
                  </tr>
                  <tr>
                    <td class="next shortcut"><kbd>n</kbd></td>
                    <td>Next page</td>
                  </tr>
                  <tr>
                    <td class="prev shortcut"><kbd>p</kbd></td>
                    <td>Previous page</td>
                  </tr>
                  <tr>
                    <td class="search shortcut"><kbd>s</kbd></td>
                    <td>Search</td>
                  </tr>
                </tbody>
              </table>
            </div>
            <div class="modal-footer">
            </div>
        </div>
    </div>
 </div>
    </body>
  </body>
 </html>
--- a/0.2/api/miplearn/benchmark.html
+++ b/0.2/api/miplearn/benchmark.html
@ -1,452 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.benchmark API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.benchmark</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import logging
 import os
 from typing import Dict, Union, List
 import pandas as pd
 from miplearn.instance import Instance
 from miplearn.solvers.learning import LearningSolver
 from miplearn.types import LearningSolveStats
 class BenchmarkRunner:
    &#34;&#34;&#34;
    Utility class that simplifies the task of comparing the performance of different
    solvers.
    Example
    -------
    ```python
    benchmark = BenchmarkRunner({
        &#34;Baseline&#34;: LearningSolver(...),
        &#34;Strategy A&#34;: LearningSolver(...),
        &#34;Strategy B&#34;: LearningSolver(...),
        &#34;Strategy C&#34;: LearningSolver(...),
    })
    benchmark.fit(train_instances)
    benchmark.parallel_solve(test_instances, n_jobs=5)
    benchmark.save_results(&#34;result.csv&#34;)
    ```
    Parameters
    ----------
    solvers: Dict[str, LearningSolver]
        Dictionary containing the solvers to compare. Solvers may have different
        arguments and components. The key should be the name of the solver. It
        appears in the exported tables of results.
    &#34;&#34;&#34;
    def __init__(self, solvers: Dict[str, LearningSolver]) -&gt; None:
        self.solvers: Dict[str, LearningSolver] = solvers
        self.results = pd.DataFrame(
            columns=[
                &#34;Solver&#34;,
                &#34;Instance&#34;,
            ]
        )
    def parallel_solve(
        self,
        instances: Union[List[str], List[Instance]],
        n_jobs: int = 1,
        n_trials: int = 3,
    ) -&gt; None:
        &#34;&#34;&#34;
        Solves the given instances in parallel and collect benchmark statistics.
        Parameters
        ----------
        instances: Union[List[str], List[Instance]]
            List of instances to solve. This can either be a list of instances
            already loaded in memory, or a list of filenames pointing to pickled (and
            optionally gzipped) files.
        n_jobs: int
            List of instances to solve in parallel at a time.
        n_trials: int
            How many times each instance should be solved.
        &#34;&#34;&#34;
        self._silence_miplearn_logger()
        trials = instances * n_trials
        for (solver_name, solver) in self.solvers.items():
            results = solver.parallel_solve(
                trials,
                n_jobs=n_jobs,
                label=&#34;Solve (%s)&#34; % solver_name,
                discard_outputs=True,
            )
            for i in range(len(trials)):
                idx = i % len(instances)
                results[i][&#34;Solver&#34;] = solver_name
                results[i][&#34;Instance&#34;] = idx
                self.results = self.results.append(pd.DataFrame([results[i]]))
        self._restore_miplearn_logger()
    def write_csv(self, filename: str) -&gt; None:
        &#34;&#34;&#34;
        Writes the collected results to a CSV file.
        Parameters
        ----------
        filename: str
            The name of the file.
        &#34;&#34;&#34;
        os.makedirs(os.path.dirname(filename), exist_ok=True)
        self.results.to_csv(filename)
    def fit(self, instances: Union[List[str], List[Instance]]) -&gt; None:
        &#34;&#34;&#34;
        Trains all solvers with the provided training instances.
        Parameters
        ----------
        instances:  Union[List[str], List[Instance]]
            List of training instances. This can either be a list of instances
            already loaded in memory, or a list of filenames pointing to pickled (and
            optionally gzipped) files.
        &#34;&#34;&#34;
        for (solver_name, solver) in self.solvers.items():
            solver.fit(instances)
    def _silence_miplearn_logger(self) -&gt; None:
        miplearn_logger = logging.getLogger(&#34;miplearn&#34;)
        self.prev_log_level = miplearn_logger.getEffectiveLevel()
        miplearn_logger.setLevel(logging.WARNING)
    def _restore_miplearn_logger(self) -&gt; None:
        miplearn_logger = logging.getLogger(&#34;miplearn&#34;)
        miplearn_logger.setLevel(self.prev_log_level)</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.benchmark.BenchmarkRunner"><code class="flex name class">
 <span>class <span class="ident">BenchmarkRunner</span></span>
 <span>(</span><span>solvers)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Utility class that simplifies the task of comparing the performance of different
 solvers.</p>
 <h2 id="example">Example</h2>
 <pre><code class="language-python">benchmark = BenchmarkRunner({
    &quot;Baseline&quot;: LearningSolver(...),
    &quot;Strategy A&quot;: LearningSolver(...),
    &quot;Strategy B&quot;: LearningSolver(...),
    &quot;Strategy C&quot;: LearningSolver(...),
 })
 benchmark.fit(train_instances)
 benchmark.parallel_solve(test_instances, n_jobs=5)
 benchmark.save_results(&quot;result.csv&quot;)
 </code></pre>
 <h2 id="parameters">Parameters</h2>
 <dl>
 <dt><strong><code>solvers</code></strong> :&ensp;<code>Dict</code>[<code>str</code>, <code>LearningSolver</code>]</dt>
 <dd>Dictionary containing the solvers to compare. Solvers may have different
 arguments and components. The key should be the name of the solver. It
 appears in the exported tables of results.</dd>
 </dl></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class BenchmarkRunner:
    &#34;&#34;&#34;
    Utility class that simplifies the task of comparing the performance of different
    solvers.
    Example
    -------
    ```python
    benchmark = BenchmarkRunner({
        &#34;Baseline&#34;: LearningSolver(...),
        &#34;Strategy A&#34;: LearningSolver(...),
        &#34;Strategy B&#34;: LearningSolver(...),
        &#34;Strategy C&#34;: LearningSolver(...),
    })
    benchmark.fit(train_instances)
    benchmark.parallel_solve(test_instances, n_jobs=5)
    benchmark.save_results(&#34;result.csv&#34;)
    ```
    Parameters
    ----------
    solvers: Dict[str, LearningSolver]
        Dictionary containing the solvers to compare. Solvers may have different
        arguments and components. The key should be the name of the solver. It
        appears in the exported tables of results.
    &#34;&#34;&#34;
    def __init__(self, solvers: Dict[str, LearningSolver]) -&gt; None:
        self.solvers: Dict[str, LearningSolver] = solvers
        self.results = pd.DataFrame(
            columns=[
                &#34;Solver&#34;,
                &#34;Instance&#34;,
            ]
        )
    def parallel_solve(
        self,
        instances: Union[List[str], List[Instance]],
        n_jobs: int = 1,
        n_trials: int = 3,
    ) -&gt; None:
        &#34;&#34;&#34;
        Solves the given instances in parallel and collect benchmark statistics.
        Parameters
        ----------
        instances: Union[List[str], List[Instance]]
            List of instances to solve. This can either be a list of instances
            already loaded in memory, or a list of filenames pointing to pickled (and
            optionally gzipped) files.
        n_jobs: int
            List of instances to solve in parallel at a time.
        n_trials: int
            How many times each instance should be solved.
        &#34;&#34;&#34;
        self._silence_miplearn_logger()
        trials = instances * n_trials
        for (solver_name, solver) in self.solvers.items():
            results = solver.parallel_solve(
                trials,
                n_jobs=n_jobs,
                label=&#34;Solve (%s)&#34; % solver_name,
                discard_outputs=True,
            )
            for i in range(len(trials)):
                idx = i % len(instances)
                results[i][&#34;Solver&#34;] = solver_name
                results[i][&#34;Instance&#34;] = idx
                self.results = self.results.append(pd.DataFrame([results[i]]))
        self._restore_miplearn_logger()
    def write_csv(self, filename: str) -&gt; None:
        &#34;&#34;&#34;
        Writes the collected results to a CSV file.
        Parameters
        ----------
        filename: str
            The name of the file.
        &#34;&#34;&#34;
        os.makedirs(os.path.dirname(filename), exist_ok=True)
        self.results.to_csv(filename)
    def fit(self, instances: Union[List[str], List[Instance]]) -&gt; None:
        &#34;&#34;&#34;
        Trains all solvers with the provided training instances.
        Parameters
        ----------
        instances:  Union[List[str], List[Instance]]
            List of training instances. This can either be a list of instances
            already loaded in memory, or a list of filenames pointing to pickled (and
            optionally gzipped) files.
        &#34;&#34;&#34;
        for (solver_name, solver) in self.solvers.items():
            solver.fit(instances)
    def _silence_miplearn_logger(self) -&gt; None:
        miplearn_logger = logging.getLogger(&#34;miplearn&#34;)
        self.prev_log_level = miplearn_logger.getEffectiveLevel()
        miplearn_logger.setLevel(logging.WARNING)
    def _restore_miplearn_logger(self) -&gt; None:
        miplearn_logger = logging.getLogger(&#34;miplearn&#34;)
        miplearn_logger.setLevel(self.prev_log_level)</code></pre>
 </details>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.benchmark.BenchmarkRunner.fit"><code class="name flex">
 <span>def <span class="ident">fit</span></span>(<span>self, instances)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Trains all solvers with the provided training instances.</p>
 <h2 id="parameters">Parameters</h2>
 <dl>
 <dt><strong><code>instances</code></strong> :&ensp; <code>Union</code>[<code>List</code>[<code>str</code>], <code>List</code>[<code>Instance</code>]]</dt>
 <dd>List of training instances. This can either be a list of instances
 already loaded in memory, or a list of filenames pointing to pickled (and
 optionally gzipped) files.</dd>
 </dl></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def fit(self, instances: Union[List[str], List[Instance]]) -&gt; None:
    &#34;&#34;&#34;
    Trains all solvers with the provided training instances.
    Parameters
    ----------
    instances:  Union[List[str], List[Instance]]
        List of training instances. This can either be a list of instances
        already loaded in memory, or a list of filenames pointing to pickled (and
        optionally gzipped) files.
    &#34;&#34;&#34;
    for (solver_name, solver) in self.solvers.items():
        solver.fit(instances)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.benchmark.BenchmarkRunner.parallel_solve"><code class="name flex">
 <span>def <span class="ident">parallel_solve</span></span>(<span>self, instances, n_jobs=1, n_trials=3)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Solves the given instances in parallel and collect benchmark statistics.</p>
 <h2 id="parameters">Parameters</h2>
 <dl>
 <dt><strong><code>instances</code></strong> :&ensp;<code>Union</code>[<code>List</code>[<code>str</code>], <code>List</code>[<code>Instance</code>]]</dt>
 <dd>List of instances to solve. This can either be a list of instances
 already loaded in memory, or a list of filenames pointing to pickled (and
 optionally gzipped) files.</dd>
 <dt><strong><code>n_jobs</code></strong> :&ensp;<code>int</code></dt>
 <dd>List of instances to solve in parallel at a time.</dd>
 <dt><strong><code>n_trials</code></strong> :&ensp;<code>int</code></dt>
 <dd>How many times each instance should be solved.</dd>
 </dl></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def parallel_solve(
    self,
    instances: Union[List[str], List[Instance]],
    n_jobs: int = 1,
    n_trials: int = 3,
 ) -&gt; None:
    &#34;&#34;&#34;
    Solves the given instances in parallel and collect benchmark statistics.
    Parameters
    ----------
    instances: Union[List[str], List[Instance]]
        List of instances to solve. This can either be a list of instances
        already loaded in memory, or a list of filenames pointing to pickled (and
        optionally gzipped) files.
    n_jobs: int
        List of instances to solve in parallel at a time.
    n_trials: int
        How many times each instance should be solved.
    &#34;&#34;&#34;
    self._silence_miplearn_logger()
    trials = instances * n_trials
    for (solver_name, solver) in self.solvers.items():
        results = solver.parallel_solve(
            trials,
            n_jobs=n_jobs,
            label=&#34;Solve (%s)&#34; % solver_name,
            discard_outputs=True,
        )
        for i in range(len(trials)):
            idx = i % len(instances)
            results[i][&#34;Solver&#34;] = solver_name
            results[i][&#34;Instance&#34;] = idx
            self.results = self.results.append(pd.DataFrame([results[i]]))
    self._restore_miplearn_logger()</code></pre>
 </details>
 </dd>
 <dt id="miplearn.benchmark.BenchmarkRunner.write_csv"><code class="name flex">
 <span>def <span class="ident">write_csv</span></span>(<span>self, filename)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Writes the collected results to a CSV file.</p>
 <h2 id="parameters">Parameters</h2>
 <dl>
 <dt><strong><code>filename</code></strong> :&ensp;<code>str</code></dt>
 <dd>The name of the file.</dd>
 </dl></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def write_csv(self, filename: str) -&gt; None:
    &#34;&#34;&#34;
    Writes the collected results to a CSV file.
    Parameters
    ----------
    filename: str
        The name of the file.
    &#34;&#34;&#34;
    os.makedirs(os.path.dirname(filename), exist_ok=True)
    self.results.to_csv(filename)</code></pre>
 </details>
 </dd>
 </dl>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn" href="index.html">miplearn</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.benchmark.BenchmarkRunner" href="#miplearn.benchmark.BenchmarkRunner">BenchmarkRunner</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.benchmark.BenchmarkRunner.fit" href="#miplearn.benchmark.BenchmarkRunner.fit">fit</a></code></li>
 <li><code><a title="miplearn.benchmark.BenchmarkRunner.parallel_solve" href="#miplearn.benchmark.BenchmarkRunner.parallel_solve">parallel_solve</a></code></li>
 <li><code><a title="miplearn.benchmark.BenchmarkRunner.write_csv" href="#miplearn.benchmark.BenchmarkRunner.write_csv">write_csv</a></code></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/classifiers/adaptive.html
+++ b/0.2/api/miplearn/classifiers/adaptive.html
@ -1,249 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.classifiers.adaptive API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.classifiers.adaptive</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import logging
 from copy import deepcopy
 from typing import Any, Dict
 from sklearn.linear_model import LogisticRegression
 from sklearn.neighbors import KNeighborsClassifier
 from sklearn.pipeline import make_pipeline
 from sklearn.preprocessing import StandardScaler
 from miplearn.classifiers import Classifier
 from miplearn.classifiers.counting import CountingClassifier
 from miplearn.classifiers.evaluator import ClassifierEvaluator
 logger = logging.getLogger(__name__)
 class AdaptiveClassifier(Classifier):
    &#34;&#34;&#34;
    A meta-classifier which dynamically selects what actual classifier to use
    based on its cross-validation score on a particular training data set.
    &#34;&#34;&#34;
    def __init__(
        self,
        candidates: Dict[str, Any] = None,
        evaluator: ClassifierEvaluator = ClassifierEvaluator(),
    ) -&gt; None:
        &#34;&#34;&#34;
        Initializes the meta-classifier.
        &#34;&#34;&#34;
        if candidates is None:
            candidates = {
                &#34;knn(100)&#34;: {
                    &#34;classifier&#34;: KNeighborsClassifier(n_neighbors=100),
                    &#34;min samples&#34;: 100,
                },
                &#34;logistic&#34;: {
                    &#34;classifier&#34;: make_pipeline(StandardScaler(), LogisticRegression()),
                    &#34;min samples&#34;: 30,
                },
                &#34;counting&#34;: {
                    &#34;classifier&#34;: CountingClassifier(),
                    &#34;min samples&#34;: 0,
                },
            }
        self.candidates = candidates
        self.evaluator = evaluator
        self.classifier = None
    def fit(self, x_train, y_train):
        best_name, best_clf, best_score = None, None, -float(&#34;inf&#34;)
        n_samples = x_train.shape[0]
        for (name, clf_dict) in self.candidates.items():
            if n_samples &lt; clf_dict[&#34;min samples&#34;]:
                continue
            clf = deepcopy(clf_dict[&#34;classifier&#34;])
            clf.fit(x_train, y_train)
            score = self.evaluator.evaluate(clf, x_train, y_train)
            if score &gt; best_score:
                best_name, best_clf, best_score = name, clf, score
        logger.debug(&#34;Best classifier: %s (score=%.3f)&#34; % (best_name, best_score))
        self.classifier = best_clf
    def predict_proba(self, x_test):
        return self.classifier.predict_proba(x_test)</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.classifiers.adaptive.AdaptiveClassifier"><code class="flex name class">
 <span>class <span class="ident">AdaptiveClassifier</span></span>
 <span>(</span><span>candidates=None, evaluator=&lt;miplearn.classifiers.evaluator.ClassifierEvaluator object&gt;)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>A meta-classifier which dynamically selects what actual classifier to use
 based on its cross-validation score on a particular training data set.</p>
 <p>Initializes the meta-classifier.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class AdaptiveClassifier(Classifier):
    &#34;&#34;&#34;
    A meta-classifier which dynamically selects what actual classifier to use
    based on its cross-validation score on a particular training data set.
    &#34;&#34;&#34;
    def __init__(
        self,
        candidates: Dict[str, Any] = None,
        evaluator: ClassifierEvaluator = ClassifierEvaluator(),
    ) -&gt; None:
        &#34;&#34;&#34;
        Initializes the meta-classifier.
        &#34;&#34;&#34;
        if candidates is None:
            candidates = {
                &#34;knn(100)&#34;: {
                    &#34;classifier&#34;: KNeighborsClassifier(n_neighbors=100),
                    &#34;min samples&#34;: 100,
                },
                &#34;logistic&#34;: {
                    &#34;classifier&#34;: make_pipeline(StandardScaler(), LogisticRegression()),
                    &#34;min samples&#34;: 30,
                },
                &#34;counting&#34;: {
                    &#34;classifier&#34;: CountingClassifier(),
                    &#34;min samples&#34;: 0,
                },
            }
        self.candidates = candidates
        self.evaluator = evaluator
        self.classifier = None
    def fit(self, x_train, y_train):
        best_name, best_clf, best_score = None, None, -float(&#34;inf&#34;)
        n_samples = x_train.shape[0]
        for (name, clf_dict) in self.candidates.items():
            if n_samples &lt; clf_dict[&#34;min samples&#34;]:
                continue
            clf = deepcopy(clf_dict[&#34;classifier&#34;])
            clf.fit(x_train, y_train)
            score = self.evaluator.evaluate(clf, x_train, y_train)
            if score &gt; best_score:
                best_name, best_clf, best_score = name, clf, score
        logger.debug(&#34;Best classifier: %s (score=%.3f)&#34; % (best_name, best_score))
        self.classifier = best_clf
    def predict_proba(self, x_test):
        return self.classifier.predict_proba(x_test)</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.classifiers.Classifier" href="index.html#miplearn.classifiers.Classifier">Classifier</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.classifiers.adaptive.AdaptiveClassifier.fit"><code class="name flex">
 <span>def <span class="ident">fit</span></span>(<span>self, x_train, y_train)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def fit(self, x_train, y_train):
    best_name, best_clf, best_score = None, None, -float(&#34;inf&#34;)
    n_samples = x_train.shape[0]
    for (name, clf_dict) in self.candidates.items():
        if n_samples &lt; clf_dict[&#34;min samples&#34;]:
            continue
        clf = deepcopy(clf_dict[&#34;classifier&#34;])
        clf.fit(x_train, y_train)
        score = self.evaluator.evaluate(clf, x_train, y_train)
        if score &gt; best_score:
            best_name, best_clf, best_score = name, clf, score
    logger.debug(&#34;Best classifier: %s (score=%.3f)&#34; % (best_name, best_score))
    self.classifier = best_clf</code></pre>
 </details>
 </dd>
 <dt id="miplearn.classifiers.adaptive.AdaptiveClassifier.predict_proba"><code class="name flex">
 <span>def <span class="ident">predict_proba</span></span>(<span>self, x_test)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def predict_proba(self, x_test):
    return self.classifier.predict_proba(x_test)</code></pre>
 </details>
 </dd>
 </dl>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.classifiers" href="index.html">miplearn.classifiers</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.classifiers.adaptive.AdaptiveClassifier" href="#miplearn.classifiers.adaptive.AdaptiveClassifier">AdaptiveClassifier</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.classifiers.adaptive.AdaptiveClassifier.fit" href="#miplearn.classifiers.adaptive.AdaptiveClassifier.fit">fit</a></code></li>
 <li><code><a title="miplearn.classifiers.adaptive.AdaptiveClassifier.predict_proba" href="#miplearn.classifiers.adaptive.AdaptiveClassifier.predict_proba">predict_proba</a></code></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/classifiers/counting.html
+++ b/0.2/api/miplearn/classifiers/counting.html
@ -1,167 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.classifiers.counting API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.classifiers.counting</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import numpy as np
 from miplearn.classifiers import Classifier
 class CountingClassifier(Classifier):
    &#34;&#34;&#34;
    A classifier that generates constant predictions, based only on the
    frequency of the training labels. For example, if y_train is [1.0, 0.0, 0.0]
    this classifier always returns [0.66 0.33] for any x_test. It essentially
    counts how many times each label appeared, hence the name.
    &#34;&#34;&#34;
    def __init__(self) -&gt; None:
        self.mean = None
    def fit(self, x_train, y_train):
        self.mean = np.mean(y_train)
    def predict_proba(self, x_test):
        return np.array([[1 - self.mean, self.mean] for _ in range(x_test.shape[0])])
    def __repr__(self):
        return &#34;CountingClassifier(mean=%s)&#34; % self.mean</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.classifiers.counting.CountingClassifier"><code class="flex name class">
 <span>class <span class="ident">CountingClassifier</span></span>
 </code></dt>
 <dd>
 <section class="desc"><p>A classifier that generates constant predictions, based only on the
 frequency of the training labels. For example, if y_train is [1.0, 0.0, 0.0]
 this classifier always returns [0.66 0.33] for any x_test. It essentially
 counts how many times each label appeared, hence the name.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class CountingClassifier(Classifier):
    &#34;&#34;&#34;
    A classifier that generates constant predictions, based only on the
    frequency of the training labels. For example, if y_train is [1.0, 0.0, 0.0]
    this classifier always returns [0.66 0.33] for any x_test. It essentially
    counts how many times each label appeared, hence the name.
    &#34;&#34;&#34;
    def __init__(self) -&gt; None:
        self.mean = None
    def fit(self, x_train, y_train):
        self.mean = np.mean(y_train)
    def predict_proba(self, x_test):
        return np.array([[1 - self.mean, self.mean] for _ in range(x_test.shape[0])])
    def __repr__(self):
        return &#34;CountingClassifier(mean=%s)&#34; % self.mean</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.classifiers.Classifier" href="index.html#miplearn.classifiers.Classifier">Classifier</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.classifiers.counting.CountingClassifier.fit"><code class="name flex">
 <span>def <span class="ident">fit</span></span>(<span>self, x_train, y_train)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def fit(self, x_train, y_train):
    self.mean = np.mean(y_train)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.classifiers.counting.CountingClassifier.predict_proba"><code class="name flex">
 <span>def <span class="ident">predict_proba</span></span>(<span>self, x_test)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def predict_proba(self, x_test):
    return np.array([[1 - self.mean, self.mean] for _ in range(x_test.shape[0])])</code></pre>
 </details>
 </dd>
 </dl>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.classifiers" href="index.html">miplearn.classifiers</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.classifiers.counting.CountingClassifier" href="#miplearn.classifiers.counting.CountingClassifier">CountingClassifier</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.classifiers.counting.CountingClassifier.fit" href="#miplearn.classifiers.counting.CountingClassifier.fit">fit</a></code></li>
 <li><code><a title="miplearn.classifiers.counting.CountingClassifier.predict_proba" href="#miplearn.classifiers.counting.CountingClassifier.predict_proba">predict_proba</a></code></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/classifiers/cv.html
+++ b/0.2/api/miplearn/classifiers/cv.html
@ -1,316 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.classifiers.cv API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.classifiers.cv</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import logging
 from copy import deepcopy
 import numpy as np
 from sklearn.dummy import DummyClassifier
 from sklearn.linear_model import LogisticRegression
 from sklearn.model_selection import cross_val_score
 from miplearn.classifiers import Classifier
 logger = logging.getLogger(__name__)
 class CrossValidatedClassifier(Classifier):
    &#34;&#34;&#34;
    A meta-classifier that, upon training, evaluates the performance of another
    classifier on the training data set using k-fold cross validation, then
    either adopts the other classifier it if the cv-score is high enough, or
    returns a constant label for every x_test otherwise.
    The threshold is specified in comparison to a dummy classifier trained
    on the same dataset. For example, a threshold of 0.0 indicates that any
    classifier as good as the dummy predictor is acceptable. A threshold of 1.0
    indicates that only classifier with a perfect cross-validation score are
    acceptable. Other numbers are a linear interpolation of these two extremes.
    &#34;&#34;&#34;
    def __init__(
        self,
        classifier=LogisticRegression(),
        threshold=0.75,
        constant=0.0,
        cv=5,
        scoring=&#34;accuracy&#34;,
    ):
        self.classifier = None
        self.classifier_prototype = classifier
        self.constant = constant
        self.threshold = threshold
        self.cv = cv
        self.scoring = scoring
    def fit(self, x_train, y_train):
        # Calculate dummy score and absolute score threshold
        y_train_avg = np.average(y_train)
        dummy_score = max(y_train_avg, 1 - y_train_avg)
        absolute_threshold = 1.0 * self.threshold + dummy_score * (1 - self.threshold)
        # Calculate cross validation score and decide which classifier to use
        clf = deepcopy(self.classifier_prototype)
        cv_score = float(
            np.mean(
                cross_val_score(
                    clf,
                    x_train,
                    y_train,
                    cv=self.cv,
                    scoring=self.scoring,
                )
            )
        )
        if cv_score &gt;= absolute_threshold:
            logger.debug(
                &#34;cv_score is above threshold (%.2f &gt;= %.2f); keeping&#34;
                % (cv_score, absolute_threshold)
            )
            self.classifier = clf
        else:
            logger.debug(
                &#34;cv_score is below threshold (%.2f &lt; %.2f); discarding&#34;
                % (cv_score, absolute_threshold)
            )
            self.classifier = DummyClassifier(
                strategy=&#34;constant&#34;,
                constant=self.constant,
            )
        # Train chosen classifier
        self.classifier.fit(x_train, y_train)
    def predict_proba(self, x_test):
        return self.classifier.predict_proba(x_test)</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.classifiers.cv.CrossValidatedClassifier"><code class="flex name class">
 <span>class <span class="ident">CrossValidatedClassifier</span></span>
 <span>(</span><span>classifier=LogisticRegression(), threshold=0.75, constant=0.0, cv=5, scoring='accuracy')</span>
 </code></dt>
 <dd>
 <section class="desc"><p>A meta-classifier that, upon training, evaluates the performance of another
 classifier on the training data set using k-fold cross validation, then
 either adopts the other classifier it if the cv-score is high enough, or
 returns a constant label for every x_test otherwise.</p>
 <p>The threshold is specified in comparison to a dummy classifier trained
 on the same dataset. For example, a threshold of 0.0 indicates that any
 classifier as good as the dummy predictor is acceptable. A threshold of 1.0
 indicates that only classifier with a perfect cross-validation score are
 acceptable. Other numbers are a linear interpolation of these two extremes.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class CrossValidatedClassifier(Classifier):
    &#34;&#34;&#34;
    A meta-classifier that, upon training, evaluates the performance of another
    classifier on the training data set using k-fold cross validation, then
    either adopts the other classifier it if the cv-score is high enough, or
    returns a constant label for every x_test otherwise.
    The threshold is specified in comparison to a dummy classifier trained
    on the same dataset. For example, a threshold of 0.0 indicates that any
    classifier as good as the dummy predictor is acceptable. A threshold of 1.0
    indicates that only classifier with a perfect cross-validation score are
    acceptable. Other numbers are a linear interpolation of these two extremes.
    &#34;&#34;&#34;
    def __init__(
        self,
        classifier=LogisticRegression(),
        threshold=0.75,
        constant=0.0,
        cv=5,
        scoring=&#34;accuracy&#34;,
    ):
        self.classifier = None
        self.classifier_prototype = classifier
        self.constant = constant
        self.threshold = threshold
        self.cv = cv
        self.scoring = scoring
    def fit(self, x_train, y_train):
        # Calculate dummy score and absolute score threshold
        y_train_avg = np.average(y_train)
        dummy_score = max(y_train_avg, 1 - y_train_avg)
        absolute_threshold = 1.0 * self.threshold + dummy_score * (1 - self.threshold)
        # Calculate cross validation score and decide which classifier to use
        clf = deepcopy(self.classifier_prototype)
        cv_score = float(
            np.mean(
                cross_val_score(
                    clf,
                    x_train,
                    y_train,
                    cv=self.cv,
                    scoring=self.scoring,
                )
            )
        )
        if cv_score &gt;= absolute_threshold:
            logger.debug(
                &#34;cv_score is above threshold (%.2f &gt;= %.2f); keeping&#34;
                % (cv_score, absolute_threshold)
            )
            self.classifier = clf
        else:
            logger.debug(
                &#34;cv_score is below threshold (%.2f &lt; %.2f); discarding&#34;
                % (cv_score, absolute_threshold)
            )
            self.classifier = DummyClassifier(
                strategy=&#34;constant&#34;,
                constant=self.constant,
            )
        # Train chosen classifier
        self.classifier.fit(x_train, y_train)
    def predict_proba(self, x_test):
        return self.classifier.predict_proba(x_test)</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.classifiers.Classifier" href="index.html#miplearn.classifiers.Classifier">Classifier</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.classifiers.cv.CrossValidatedClassifier.fit"><code class="name flex">
 <span>def <span class="ident">fit</span></span>(<span>self, x_train, y_train)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def fit(self, x_train, y_train):
    # Calculate dummy score and absolute score threshold
    y_train_avg = np.average(y_train)
    dummy_score = max(y_train_avg, 1 - y_train_avg)
    absolute_threshold = 1.0 * self.threshold + dummy_score * (1 - self.threshold)
    # Calculate cross validation score and decide which classifier to use
    clf = deepcopy(self.classifier_prototype)
    cv_score = float(
        np.mean(
            cross_val_score(
                clf,
                x_train,
                y_train,
                cv=self.cv,
                scoring=self.scoring,
            )
        )
    )
    if cv_score &gt;= absolute_threshold:
        logger.debug(
            &#34;cv_score is above threshold (%.2f &gt;= %.2f); keeping&#34;
            % (cv_score, absolute_threshold)
        )
        self.classifier = clf
    else:
        logger.debug(
            &#34;cv_score is below threshold (%.2f &lt; %.2f); discarding&#34;
            % (cv_score, absolute_threshold)
        )
        self.classifier = DummyClassifier(
            strategy=&#34;constant&#34;,
            constant=self.constant,
        )
    # Train chosen classifier
    self.classifier.fit(x_train, y_train)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.classifiers.cv.CrossValidatedClassifier.predict_proba"><code class="name flex">
 <span>def <span class="ident">predict_proba</span></span>(<span>self, x_test)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def predict_proba(self, x_test):
    return self.classifier.predict_proba(x_test)</code></pre>
 </details>
 </dd>
 </dl>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.classifiers" href="index.html">miplearn.classifiers</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.classifiers.cv.CrossValidatedClassifier" href="#miplearn.classifiers.cv.CrossValidatedClassifier">CrossValidatedClassifier</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.classifiers.cv.CrossValidatedClassifier.fit" href="#miplearn.classifiers.cv.CrossValidatedClassifier.fit">fit</a></code></li>
 <li><code><a title="miplearn.classifiers.cv.CrossValidatedClassifier.predict_proba" href="#miplearn.classifiers.cv.CrossValidatedClassifier.predict_proba">predict_proba</a></code></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/classifiers/evaluator.html
+++ b/0.2/api/miplearn/classifiers/evaluator.html
@ -1,123 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.classifiers.evaluator API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.classifiers.evaluator</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 from sklearn.metrics import roc_auc_score
 class ClassifierEvaluator:
    def __init__(self) -&gt; None:
        pass
    def evaluate(self, clf, x_train, y_train):
        # FIXME: use cross-validation
        proba = clf.predict_proba(x_train)
        return roc_auc_score(y_train, proba[:, 1])</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.classifiers.evaluator.ClassifierEvaluator"><code class="flex name class">
 <span>class <span class="ident">ClassifierEvaluator</span></span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class ClassifierEvaluator:
    def __init__(self) -&gt; None:
        pass
    def evaluate(self, clf, x_train, y_train):
        # FIXME: use cross-validation
        proba = clf.predict_proba(x_train)
        return roc_auc_score(y_train, proba[:, 1])</code></pre>
 </details>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.classifiers.evaluator.ClassifierEvaluator.evaluate"><code class="name flex">
 <span>def <span class="ident">evaluate</span></span>(<span>self, clf, x_train, y_train)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def evaluate(self, clf, x_train, y_train):
    # FIXME: use cross-validation
    proba = clf.predict_proba(x_train)
    return roc_auc_score(y_train, proba[:, 1])</code></pre>
 </details>
 </dd>
 </dl>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.classifiers" href="index.html">miplearn.classifiers</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.classifiers.evaluator.ClassifierEvaluator" href="#miplearn.classifiers.evaluator.ClassifierEvaluator">ClassifierEvaluator</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.classifiers.evaluator.ClassifierEvaluator.evaluate" href="#miplearn.classifiers.evaluator.ClassifierEvaluator.evaluate">evaluate</a></code></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/classifiers/index.html
+++ b/0.2/api/miplearn/classifiers/index.html
@ -1,283 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.classifiers API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.classifiers</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 from abc import ABC, abstractmethod
 import numpy as np
 class Classifier(ABC):
    @abstractmethod
    def fit(self, x_train, y_train):
        pass
    @abstractmethod
    def predict_proba(self, x_test):
        pass
    def predict(self, x_test):
        proba = self.predict_proba(x_test)
        assert isinstance(proba, np.ndarray)
        assert proba.shape == (x_test.shape[0], 2)
        return (proba[:, 1] &gt; 0.5).astype(float)
 class Regressor(ABC):
    @abstractmethod
    def fit(self, x_train, y_train):
        pass
    @abstractmethod
    def predict(self):
        pass</code></pre>
 </details>
 </section>
 <section>
 <h2 class="section-title" id="header-submodules">Sub-modules</h2>
 <dl>
 <dt><code class="name"><a title="miplearn.classifiers.adaptive" href="adaptive.html">miplearn.classifiers.adaptive</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.classifiers.counting" href="counting.html">miplearn.classifiers.counting</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.classifiers.cv" href="cv.html">miplearn.classifiers.cv</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.classifiers.evaluator" href="evaluator.html">miplearn.classifiers.evaluator</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.classifiers.threshold" href="threshold.html">miplearn.classifiers.threshold</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 </dl>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.classifiers.Classifier"><code class="flex name class">
 <span>class <span class="ident">Classifier</span></span>
 </code></dt>
 <dd>
 <section class="desc"><p>Helper class that provides a standard way to create an ABC using
 inheritance.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class Classifier(ABC):
    @abstractmethod
    def fit(self, x_train, y_train):
        pass
    @abstractmethod
    def predict_proba(self, x_test):
        pass
    def predict(self, x_test):
        proba = self.predict_proba(x_test)
        assert isinstance(proba, np.ndarray)
        assert proba.shape == (x_test.shape[0], 2)
        return (proba[:, 1] &gt; 0.5).astype(float)</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li>abc.ABC</li>
 </ul>
 <h3>Subclasses</h3>
 <ul class="hlist">
 <li><a title="miplearn.classifiers.adaptive.AdaptiveClassifier" href="adaptive.html#miplearn.classifiers.adaptive.AdaptiveClassifier">AdaptiveClassifier</a></li>
 <li><a title="miplearn.classifiers.counting.CountingClassifier" href="counting.html#miplearn.classifiers.counting.CountingClassifier">CountingClassifier</a></li>
 <li><a title="miplearn.classifiers.cv.CrossValidatedClassifier" href="cv.html#miplearn.classifiers.cv.CrossValidatedClassifier">CrossValidatedClassifier</a></li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.classifiers.Classifier.fit"><code class="name flex">
 <span>def <span class="ident">fit</span></span>(<span>self, x_train, y_train)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">@abstractmethod
 def fit(self, x_train, y_train):
    pass</code></pre>
 </details>
 </dd>
 <dt id="miplearn.classifiers.Classifier.predict"><code class="name flex">
 <span>def <span class="ident">predict</span></span>(<span>self, x_test)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def predict(self, x_test):
    proba = self.predict_proba(x_test)
    assert isinstance(proba, np.ndarray)
    assert proba.shape == (x_test.shape[0], 2)
    return (proba[:, 1] &gt; 0.5).astype(float)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.classifiers.Classifier.predict_proba"><code class="name flex">
 <span>def <span class="ident">predict_proba</span></span>(<span>self, x_test)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">@abstractmethod
 def predict_proba(self, x_test):
    pass</code></pre>
 </details>
 </dd>
 </dl>
 </dd>
 <dt id="miplearn.classifiers.Regressor"><code class="flex name class">
 <span>class <span class="ident">Regressor</span></span>
 </code></dt>
 <dd>
 <section class="desc"><p>Helper class that provides a standard way to create an ABC using
 inheritance.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class Regressor(ABC):
    @abstractmethod
    def fit(self, x_train, y_train):
        pass
    @abstractmethod
    def predict(self):
        pass</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li>abc.ABC</li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.classifiers.Regressor.fit"><code class="name flex">
 <span>def <span class="ident">fit</span></span>(<span>self, x_train, y_train)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">@abstractmethod
 def fit(self, x_train, y_train):
    pass</code></pre>
 </details>
 </dd>
 <dt id="miplearn.classifiers.Regressor.predict"><code class="name flex">
 <span>def <span class="ident">predict</span></span>(<span>self)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">@abstractmethod
 def predict(self):
    pass</code></pre>
 </details>
 </dd>
 </dl>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn" href="../index.html">miplearn</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-submodules">Sub-modules</a></h3>
 <ul>
 <li><code><a title="miplearn.classifiers.adaptive" href="adaptive.html">miplearn.classifiers.adaptive</a></code></li>
 <li><code><a title="miplearn.classifiers.counting" href="counting.html">miplearn.classifiers.counting</a></code></li>
 <li><code><a title="miplearn.classifiers.cv" href="cv.html">miplearn.classifiers.cv</a></code></li>
 <li><code><a title="miplearn.classifiers.evaluator" href="evaluator.html">miplearn.classifiers.evaluator</a></code></li>
 <li><code><a title="miplearn.classifiers.threshold" href="threshold.html">miplearn.classifiers.threshold</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.classifiers.Classifier" href="#miplearn.classifiers.Classifier">Classifier</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.classifiers.Classifier.fit" href="#miplearn.classifiers.Classifier.fit">fit</a></code></li>
 <li><code><a title="miplearn.classifiers.Classifier.predict" href="#miplearn.classifiers.Classifier.predict">predict</a></code></li>
 <li><code><a title="miplearn.classifiers.Classifier.predict_proba" href="#miplearn.classifiers.Classifier.predict_proba">predict_proba</a></code></li>
 </ul>
 </li>
 <li>
 <h4><code><a title="miplearn.classifiers.Regressor" href="#miplearn.classifiers.Regressor">Regressor</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.classifiers.Regressor.fit" href="#miplearn.classifiers.Regressor.fit">fit</a></code></li>
 <li><code><a title="miplearn.classifiers.Regressor.predict" href="#miplearn.classifiers.Regressor.predict">predict</a></code></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/classifiers/threshold.html
+++ b/0.2/api/miplearn/classifiers/threshold.html
@ -1,245 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.classifiers.threshold API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.classifiers.threshold</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 from abc import abstractmethod, ABC
 import numpy as np
 from sklearn.metrics._ranking import _binary_clf_curve
 from miplearn.classifiers import Classifier
 class DynamicThreshold(ABC):
    @abstractmethod
    def find(
        self,
        clf: Classifier,
        x_train: np.ndarray,
        y_train: np.ndarray,
    ) -&gt; float:
        &#34;&#34;&#34;
        Given a trained binary classifier `clf` and a training data set,
        returns the numerical threshold (float) satisfying some criterea.
        &#34;&#34;&#34;
        pass
 class MinPrecisionThreshold(DynamicThreshold):
    &#34;&#34;&#34;
    The smallest possible threshold satisfying a minimum acceptable true
    positive rate (also known as precision).
    &#34;&#34;&#34;
    def __init__(self, min_precision: float) -&gt; None:
        self.min_precision = min_precision
    def find(self, clf, x_train, y_train):
        proba = clf.predict_proba(x_train)
        assert isinstance(proba, np.ndarray), &#34;classifier should return numpy array&#34;
        assert proba.shape == (
            x_train.shape[0],
            2,
        ), &#34;classifier should return (%d,%d)-shaped array, not %s&#34; % (
            x_train.shape[0],
            2,
            str(proba.shape),
        )
        fps, tps, thresholds = _binary_clf_curve(y_train, proba[:, 1])
        precision = tps / (tps + fps)
        for k in reversed(range(len(precision))):
            if precision[k] &gt;= self.min_precision:
                return thresholds[k]
        return 2.0</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.classifiers.threshold.DynamicThreshold"><code class="flex name class">
 <span>class <span class="ident">DynamicThreshold</span></span>
 </code></dt>
 <dd>
 <section class="desc"><p>Helper class that provides a standard way to create an ABC using
 inheritance.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class DynamicThreshold(ABC):
    @abstractmethod
    def find(
        self,
        clf: Classifier,
        x_train: np.ndarray,
        y_train: np.ndarray,
    ) -&gt; float:
        &#34;&#34;&#34;
        Given a trained binary classifier `clf` and a training data set,
        returns the numerical threshold (float) satisfying some criterea.
        &#34;&#34;&#34;
        pass</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li>abc.ABC</li>
 </ul>
 <h3>Subclasses</h3>
 <ul class="hlist">
 <li><a title="miplearn.classifiers.threshold.MinPrecisionThreshold" href="#miplearn.classifiers.threshold.MinPrecisionThreshold">MinPrecisionThreshold</a></li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.classifiers.threshold.DynamicThreshold.find"><code class="name flex">
 <span>def <span class="ident">find</span></span>(<span>self, clf, x_train, y_train)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Given a trained binary classifier <code>clf</code> and a training data set,
 returns the numerical threshold (float) satisfying some criterea.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">@abstractmethod
 def find(
    self,
    clf: Classifier,
    x_train: np.ndarray,
    y_train: np.ndarray,
 ) -&gt; float:
    &#34;&#34;&#34;
    Given a trained binary classifier `clf` and a training data set,
    returns the numerical threshold (float) satisfying some criterea.
    &#34;&#34;&#34;
    pass</code></pre>
 </details>
 </dd>
 </dl>
 </dd>
 <dt id="miplearn.classifiers.threshold.MinPrecisionThreshold"><code class="flex name class">
 <span>class <span class="ident">MinPrecisionThreshold</span></span>
 <span>(</span><span>min_precision)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>The smallest possible threshold satisfying a minimum acceptable true
 positive rate (also known as precision).</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class MinPrecisionThreshold(DynamicThreshold):
    &#34;&#34;&#34;
    The smallest possible threshold satisfying a minimum acceptable true
    positive rate (also known as precision).
    &#34;&#34;&#34;
    def __init__(self, min_precision: float) -&gt; None:
        self.min_precision = min_precision
    def find(self, clf, x_train, y_train):
        proba = clf.predict_proba(x_train)
        assert isinstance(proba, np.ndarray), &#34;classifier should return numpy array&#34;
        assert proba.shape == (
            x_train.shape[0],
            2,
        ), &#34;classifier should return (%d,%d)-shaped array, not %s&#34; % (
            x_train.shape[0],
            2,
            str(proba.shape),
        )
        fps, tps, thresholds = _binary_clf_curve(y_train, proba[:, 1])
        precision = tps / (tps + fps)
        for k in reversed(range(len(precision))):
            if precision[k] &gt;= self.min_precision:
                return thresholds[k]
        return 2.0</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.classifiers.threshold.DynamicThreshold" href="#miplearn.classifiers.threshold.DynamicThreshold">DynamicThreshold</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.classifiers.threshold.DynamicThreshold" href="#miplearn.classifiers.threshold.DynamicThreshold">DynamicThreshold</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.classifiers.threshold.DynamicThreshold.find" href="#miplearn.classifiers.threshold.DynamicThreshold.find">find</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.classifiers" href="index.html">miplearn.classifiers</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.classifiers.threshold.DynamicThreshold" href="#miplearn.classifiers.threshold.DynamicThreshold">DynamicThreshold</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.classifiers.threshold.DynamicThreshold.find" href="#miplearn.classifiers.threshold.DynamicThreshold.find">find</a></code></li>
 </ul>
 </li>
 <li>
 <h4><code><a title="miplearn.classifiers.threshold.MinPrecisionThreshold" href="#miplearn.classifiers.threshold.MinPrecisionThreshold">MinPrecisionThreshold</a></code></h4>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/components/component.html
+++ b/0.2/api/miplearn/components/component.html
@ -1,525 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.components.component API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.components.component</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 from abc import ABC, abstractmethod
 from typing import Any, List, Union, TYPE_CHECKING
 from miplearn.instance import Instance
 from miplearn.types import LearningSolveStats, TrainingSample
 if TYPE_CHECKING:
    from miplearn.solvers.learning import LearningSolver
 class Component(ABC):
    &#34;&#34;&#34;
    A Component is an object which adds functionality to a LearningSolver.
    For better code maintainability, LearningSolver simply delegates most of its
    functionality to Components. Each Component is responsible for exactly one ML
    strategy.
    &#34;&#34;&#34;
    def before_solve(
        self,
        solver: &#34;LearningSolver&#34;,
        instance: Instance,
        model: Any,
    ) -&gt; None:
        &#34;&#34;&#34;
        Method called by LearningSolver before the problem is solved.
        Parameters
        ----------
        solver
            The solver calling this method.
        instance
            The instance being solved.
        model
            The concrete optimization model being solved.
        &#34;&#34;&#34;
        return
    @abstractmethod
    def after_solve(
        self,
        solver: &#34;LearningSolver&#34;,
        instance: Instance,
        model: Any,
        stats: LearningSolveStats,
        training_data: TrainingSample,
    ) -&gt; None:
        &#34;&#34;&#34;
        Method called by LearningSolver after the problem is solved to optimality.
        Parameters
        ----------
        solver: LearningSolver
            The solver calling this method.
        instance: Instance
            The instance being solved.
        model: Any
            The concrete optimization model being solved.
        stats: LearningSolveStats
            A dictionary containing statistics about the solution process, such as
            number of nodes explored and running time. Components are free to add
            their own statistics here. For example, PrimalSolutionComponent adds
            statistics regarding the number of predicted variables. All statistics in
            this dictionary are exported to the benchmark CSV file.
        training_data: TrainingSample
            A dictionary containing data that may be useful for training machine
            learning models and accelerating the solution process. Components are
            free to add their own training data here. For example,
            PrimalSolutionComponent adds the current primal solution. The data must
            be pickable.
        &#34;&#34;&#34;
        pass
    def fit(
        self,
        training_instances: Union[List[str], List[Instance]],
    ) -&gt; None:
        return
    def iteration_cb(
        self,
        solver: &#34;LearningSolver&#34;,
        instance: Instance,
        model: Any,
    ) -&gt; bool:
        &#34;&#34;&#34;
        Method called by LearningSolver at the end of each iteration.
        After solving the MIP, LearningSolver calls `iteration_cb` of each component,
        giving them a chance to modify the problem and resolve it before the solution
        process ends. For example, the lazy constraint component uses `iteration_cb`
        to check that all lazy constraints are satisfied.
        If `iteration_cb` returns False for all components, the solution process
        ends. If it retunrs True for any component, the MIP is solved again.
        Parameters
        ----------
        solver: LearningSolver
            The solver calling this method.
        instance: Instance
            The instance being solved.
        model: Any
            The concrete optimization model being solved.
        &#34;&#34;&#34;
        return False
    def lazy_cb(
        self,
        solver: &#34;LearningSolver&#34;,
        instance: Instance,
        model: Any,
    ) -&gt; None:
        return</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.components.component.Component"><code class="flex name class">
 <span>class <span class="ident">Component</span></span>
 </code></dt>
 <dd>
 <section class="desc"><p>A Component is an object which adds functionality to a LearningSolver.</p>
 <p>For better code maintainability, LearningSolver simply delegates most of its
 functionality to Components. Each Component is responsible for exactly one ML
 strategy.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class Component(ABC):
    &#34;&#34;&#34;
    A Component is an object which adds functionality to a LearningSolver.
    For better code maintainability, LearningSolver simply delegates most of its
    functionality to Components. Each Component is responsible for exactly one ML
    strategy.
    &#34;&#34;&#34;
    def before_solve(
        self,
        solver: &#34;LearningSolver&#34;,
        instance: Instance,
        model: Any,
    ) -&gt; None:
        &#34;&#34;&#34;
        Method called by LearningSolver before the problem is solved.
        Parameters
        ----------
        solver
            The solver calling this method.
        instance
            The instance being solved.
        model
            The concrete optimization model being solved.
        &#34;&#34;&#34;
        return
    @abstractmethod
    def after_solve(
        self,
        solver: &#34;LearningSolver&#34;,
        instance: Instance,
        model: Any,
        stats: LearningSolveStats,
        training_data: TrainingSample,
    ) -&gt; None:
        &#34;&#34;&#34;
        Method called by LearningSolver after the problem is solved to optimality.
        Parameters
        ----------
        solver: LearningSolver
            The solver calling this method.
        instance: Instance
            The instance being solved.
        model: Any
            The concrete optimization model being solved.
        stats: LearningSolveStats
            A dictionary containing statistics about the solution process, such as
            number of nodes explored and running time. Components are free to add
            their own statistics here. For example, PrimalSolutionComponent adds
            statistics regarding the number of predicted variables. All statistics in
            this dictionary are exported to the benchmark CSV file.
        training_data: TrainingSample
            A dictionary containing data that may be useful for training machine
            learning models and accelerating the solution process. Components are
            free to add their own training data here. For example,
            PrimalSolutionComponent adds the current primal solution. The data must
            be pickable.
        &#34;&#34;&#34;
        pass
    def fit(
        self,
        training_instances: Union[List[str], List[Instance]],
    ) -&gt; None:
        return
    def iteration_cb(
        self,
        solver: &#34;LearningSolver&#34;,
        instance: Instance,
        model: Any,
    ) -&gt; bool:
        &#34;&#34;&#34;
        Method called by LearningSolver at the end of each iteration.
        After solving the MIP, LearningSolver calls `iteration_cb` of each component,
        giving them a chance to modify the problem and resolve it before the solution
        process ends. For example, the lazy constraint component uses `iteration_cb`
        to check that all lazy constraints are satisfied.
        If `iteration_cb` returns False for all components, the solution process
        ends. If it retunrs True for any component, the MIP is solved again.
        Parameters
        ----------
        solver: LearningSolver
            The solver calling this method.
        instance: Instance
            The instance being solved.
        model: Any
            The concrete optimization model being solved.
        &#34;&#34;&#34;
        return False
    def lazy_cb(
        self,
        solver: &#34;LearningSolver&#34;,
        instance: Instance,
        model: Any,
    ) -&gt; None:
        return</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li>abc.ABC</li>
 </ul>
 <h3>Subclasses</h3>
 <ul class="hlist">
 <li><a title="miplearn.components.composite.CompositeComponent" href="composite.html#miplearn.components.composite.CompositeComponent">CompositeComponent</a></li>
 <li><a title="miplearn.components.cuts.UserCutsComponent" href="cuts.html#miplearn.components.cuts.UserCutsComponent">UserCutsComponent</a></li>
 <li><a title="miplearn.components.lazy_dynamic.DynamicLazyConstraintsComponent" href="lazy_dynamic.html#miplearn.components.lazy_dynamic.DynamicLazyConstraintsComponent">DynamicLazyConstraintsComponent</a></li>
 <li><a title="miplearn.components.lazy_static.StaticLazyConstraintsComponent" href="lazy_static.html#miplearn.components.lazy_static.StaticLazyConstraintsComponent">StaticLazyConstraintsComponent</a></li>
 <li><a title="miplearn.components.objective.ObjectiveValueComponent" href="objective.html#miplearn.components.objective.ObjectiveValueComponent">ObjectiveValueComponent</a></li>
 <li><a title="miplearn.components.primal.PrimalSolutionComponent" href="primal.html#miplearn.components.primal.PrimalSolutionComponent">PrimalSolutionComponent</a></li>
 <li><a title="miplearn.components.relaxation.RelaxationComponent" href="relaxation.html#miplearn.components.relaxation.RelaxationComponent">RelaxationComponent</a></li>
 <li><a title="miplearn.components.steps.convert_tight.ConvertTightIneqsIntoEqsStep" href="steps/convert_tight.html#miplearn.components.steps.convert_tight.ConvertTightIneqsIntoEqsStep">ConvertTightIneqsIntoEqsStep</a></li>
 <li><a title="miplearn.components.steps.drop_redundant.DropRedundantInequalitiesStep" href="steps/drop_redundant.html#miplearn.components.steps.drop_redundant.DropRedundantInequalitiesStep">DropRedundantInequalitiesStep</a></li>
 <li><a title="miplearn.components.steps.relax_integrality.RelaxIntegralityStep" href="steps/relax_integrality.html#miplearn.components.steps.relax_integrality.RelaxIntegralityStep">RelaxIntegralityStep</a></li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.components.component.Component.after_solve"><code class="name flex">
 <span>def <span class="ident">after_solve</span></span>(<span>self, solver, instance, model, stats, training_data)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Method called by LearningSolver after the problem is solved to optimality.</p>
 <h2 id="parameters">Parameters</h2>
 <dl>
 <dt><strong><code>solver</code></strong> :&ensp;<code>LearningSolver</code></dt>
 <dd>The solver calling this method.</dd>
 <dt><strong><code>instance</code></strong> :&ensp;<code>Instance</code></dt>
 <dd>The instance being solved.</dd>
 <dt><strong><code>model</code></strong> :&ensp;<code>Any</code></dt>
 <dd>The concrete optimization model being solved.</dd>
 <dt><strong><code>stats</code></strong> :&ensp;<code>LearningSolveStats</code></dt>
 <dd>A dictionary containing statistics about the solution process, such as
 number of nodes explored and running time. Components are free to add
 their own statistics here. For example, PrimalSolutionComponent adds
 statistics regarding the number of predicted variables. All statistics in
 this dictionary are exported to the benchmark CSV file.</dd>
 <dt><strong><code>training_data</code></strong> :&ensp;<code>TrainingSample</code></dt>
 <dd>A dictionary containing data that may be useful for training machine
 learning models and accelerating the solution process. Components are
 free to add their own training data here. For example,
 PrimalSolutionComponent adds the current primal solution. The data must
 be pickable.</dd>
 </dl></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">@abstractmethod
 def after_solve(
    self,
    solver: &#34;LearningSolver&#34;,
    instance: Instance,
    model: Any,
    stats: LearningSolveStats,
    training_data: TrainingSample,
 ) -&gt; None:
    &#34;&#34;&#34;
    Method called by LearningSolver after the problem is solved to optimality.
    Parameters
    ----------
    solver: LearningSolver
        The solver calling this method.
    instance: Instance
        The instance being solved.
    model: Any
        The concrete optimization model being solved.
    stats: LearningSolveStats
        A dictionary containing statistics about the solution process, such as
        number of nodes explored and running time. Components are free to add
        their own statistics here. For example, PrimalSolutionComponent adds
        statistics regarding the number of predicted variables. All statistics in
        this dictionary are exported to the benchmark CSV file.
    training_data: TrainingSample
        A dictionary containing data that may be useful for training machine
        learning models and accelerating the solution process. Components are
        free to add their own training data here. For example,
        PrimalSolutionComponent adds the current primal solution. The data must
        be pickable.
    &#34;&#34;&#34;
    pass</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.component.Component.before_solve"><code class="name flex">
 <span>def <span class="ident">before_solve</span></span>(<span>self, solver, instance, model)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Method called by LearningSolver before the problem is solved.</p>
 <h2 id="parameters">Parameters</h2>
 <dl>
 <dt><strong><code>solver</code></strong></dt>
 <dd>The solver calling this method.</dd>
 <dt><strong><code>instance</code></strong></dt>
 <dd>The instance being solved.</dd>
 <dt><strong><code>model</code></strong></dt>
 <dd>The concrete optimization model being solved.</dd>
 </dl></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def before_solve(
    self,
    solver: &#34;LearningSolver&#34;,
    instance: Instance,
    model: Any,
 ) -&gt; None:
    &#34;&#34;&#34;
    Method called by LearningSolver before the problem is solved.
    Parameters
    ----------
    solver
        The solver calling this method.
    instance
        The instance being solved.
    model
        The concrete optimization model being solved.
    &#34;&#34;&#34;
    return</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.component.Component.fit"><code class="name flex">
 <span>def <span class="ident">fit</span></span>(<span>self, training_instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def fit(
    self,
    training_instances: Union[List[str], List[Instance]],
 ) -&gt; None:
    return</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.component.Component.iteration_cb"><code class="name flex">
 <span>def <span class="ident">iteration_cb</span></span>(<span>self, solver, instance, model)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Method called by LearningSolver at the end of each iteration.</p>
 <p>After solving the MIP, LearningSolver calls <code>iteration_cb</code> of each component,
 giving them a chance to modify the problem and resolve it before the solution
 process ends. For example, the lazy constraint component uses <code>iteration_cb</code>
 to check that all lazy constraints are satisfied.</p>
 <p>If <code>iteration_cb</code> returns False for all components, the solution process
 ends. If it retunrs True for any component, the MIP is solved again.</p>
 <h2 id="parameters">Parameters</h2>
 <dl>
 <dt><strong><code>solver</code></strong> :&ensp;<code>LearningSolver</code></dt>
 <dd>The solver calling this method.</dd>
 <dt><strong><code>instance</code></strong> :&ensp;<code>Instance</code></dt>
 <dd>The instance being solved.</dd>
 <dt><strong><code>model</code></strong> :&ensp;<code>Any</code></dt>
 <dd>The concrete optimization model being solved.</dd>
 </dl></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def iteration_cb(
    self,
    solver: &#34;LearningSolver&#34;,
    instance: Instance,
    model: Any,
 ) -&gt; bool:
    &#34;&#34;&#34;
    Method called by LearningSolver at the end of each iteration.
    After solving the MIP, LearningSolver calls `iteration_cb` of each component,
    giving them a chance to modify the problem and resolve it before the solution
    process ends. For example, the lazy constraint component uses `iteration_cb`
    to check that all lazy constraints are satisfied.
    If `iteration_cb` returns False for all components, the solution process
    ends. If it retunrs True for any component, the MIP is solved again.
    Parameters
    ----------
    solver: LearningSolver
        The solver calling this method.
    instance: Instance
        The instance being solved.
    model: Any
        The concrete optimization model being solved.
    &#34;&#34;&#34;
    return False</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.component.Component.lazy_cb"><code class="name flex">
 <span>def <span class="ident">lazy_cb</span></span>(<span>self, solver, instance, model)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def lazy_cb(
    self,
    solver: &#34;LearningSolver&#34;,
    instance: Instance,
    model: Any,
 ) -&gt; None:
    return</code></pre>
 </details>
 </dd>
 </dl>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.components" href="index.html">miplearn.components</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.components.component.Component" href="#miplearn.components.component.Component">Component</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.components.component.Component.after_solve" href="#miplearn.components.component.Component.after_solve">after_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.before_solve" href="#miplearn.components.component.Component.before_solve">before_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.fit" href="#miplearn.components.component.Component.fit">fit</a></code></li>
 <li><code><a title="miplearn.components.component.Component.iteration_cb" href="#miplearn.components.component.Component.iteration_cb">iteration_cb</a></code></li>
 <li><code><a title="miplearn.components.component.Component.lazy_cb" href="#miplearn.components.component.Component.lazy_cb">lazy_cb</a></code></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/components/composite.html
+++ b/0.2/api/miplearn/components/composite.html
@ -1,234 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.components.composite API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.components.composite</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 from miplearn.components.component import Component
 class CompositeComponent(Component):
    &#34;&#34;&#34;
    A Component which redirects each method call to one or more subcomponents.
    Useful for breaking down complex components into smaller classes. See
    RelaxationComponent for a concrete example.
    Parameters
    ----------
    children : list[Component]
        Subcomponents that compose this component.
    &#34;&#34;&#34;
    def __init__(self, children):
        self.children = children
    def before_solve(self, solver, instance, model):
        for child in self.children:
            child.before_solve(solver, instance, model)
    def after_solve(
        self,
        solver,
        instance,
        model,
        stats,
        training_data,
    ):
        for child in self.children:
            child.after_solve(solver, instance, model, stats, training_data)
    def fit(self, training_instances):
        for child in self.children:
            child.fit(training_instances)
    def lazy_cb(self, solver, instance, model):
        for child in self.children:
            child.lazy_cb(solver, instance, model)
    def iteration_cb(self, solver, instance, model):
        should_repeat = False
        for child in self.children:
            if child.iteration_cb(solver, instance, model):
                should_repeat = True
        return should_repeat</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.components.composite.CompositeComponent"><code class="flex name class">
 <span>class <span class="ident">CompositeComponent</span></span>
 <span>(</span><span>children)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>A Component which redirects each method call to one or more subcomponents.</p>
 <p>Useful for breaking down complex components into smaller classes. See
 RelaxationComponent for a concrete example.</p>
 <h2 id="parameters">Parameters</h2>
 <dl>
 <dt><strong><code>children</code></strong> :&ensp;<code>list</code>[<code>Component</code>]</dt>
 <dd>Subcomponents that compose this component.</dd>
 </dl></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class CompositeComponent(Component):
    &#34;&#34;&#34;
    A Component which redirects each method call to one or more subcomponents.
    Useful for breaking down complex components into smaller classes. See
    RelaxationComponent for a concrete example.
    Parameters
    ----------
    children : list[Component]
        Subcomponents that compose this component.
    &#34;&#34;&#34;
    def __init__(self, children):
        self.children = children
    def before_solve(self, solver, instance, model):
        for child in self.children:
            child.before_solve(solver, instance, model)
    def after_solve(
        self,
        solver,
        instance,
        model,
        stats,
        training_data,
    ):
        for child in self.children:
            child.after_solve(solver, instance, model, stats, training_data)
    def fit(self, training_instances):
        for child in self.children:
            child.fit(training_instances)
    def lazy_cb(self, solver, instance, model):
        for child in self.children:
            child.lazy_cb(solver, instance, model)
    def iteration_cb(self, solver, instance, model):
        should_repeat = False
        for child in self.children:
            if child.iteration_cb(solver, instance, model):
                should_repeat = True
        return should_repeat</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.components.component.Component" href="component.html#miplearn.components.component.Component">Component</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.components.composite.CompositeComponent.fit"><code class="name flex">
 <span>def <span class="ident">fit</span></span>(<span>self, training_instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def fit(self, training_instances):
    for child in self.children:
        child.fit(training_instances)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.composite.CompositeComponent.lazy_cb"><code class="name flex">
 <span>def <span class="ident">lazy_cb</span></span>(<span>self, solver, instance, model)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def lazy_cb(self, solver, instance, model):
    for child in self.children:
        child.lazy_cb(solver, instance, model)</code></pre>
 </details>
 </dd>
 </dl>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.components.component.Component" href="component.html#miplearn.components.component.Component">Component</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.components.component.Component.after_solve" href="component.html#miplearn.components.component.Component.after_solve">after_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.before_solve" href="component.html#miplearn.components.component.Component.before_solve">before_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.iteration_cb" href="component.html#miplearn.components.component.Component.iteration_cb">iteration_cb</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.components" href="index.html">miplearn.components</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.components.composite.CompositeComponent" href="#miplearn.components.composite.CompositeComponent">CompositeComponent</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.components.composite.CompositeComponent.fit" href="#miplearn.components.composite.CompositeComponent.fit">fit</a></code></li>
 <li><code><a title="miplearn.components.composite.CompositeComponent.lazy_cb" href="#miplearn.components.composite.CompositeComponent.lazy_cb">lazy_cb</a></code></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/components/cuts.html
+++ b/0.2/api/miplearn/components/cuts.html
@ -1,386 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.components.cuts API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.components.cuts</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import logging
 import sys
 from copy import deepcopy
 from typing import Any, Dict
 import numpy as np
 from tqdm.auto import tqdm
 from miplearn.classifiers import Classifier
 from miplearn.classifiers.counting import CountingClassifier
 from miplearn.components import classifier_evaluation_dict
 from miplearn.components.component import Component
 from miplearn.extractors import InstanceFeaturesExtractor
 logger = logging.getLogger(__name__)
 class UserCutsComponent(Component):
    &#34;&#34;&#34;
    A component that predicts which user cuts to enforce.
    &#34;&#34;&#34;
    def __init__(
        self,
        classifier: Classifier = CountingClassifier(),
        threshold: float = 0.05,
    ):
        self.threshold: float = threshold
        self.classifier_prototype: Classifier = classifier
        self.classifiers: Dict[Any, Classifier] = {}
    def before_solve(self, solver, instance, model):
        instance.found_violated_user_cuts = []
        logger.info(&#34;Predicting violated user cuts...&#34;)
        violations = self.predict(instance)
        logger.info(&#34;Enforcing %d user cuts...&#34; % len(violations))
        for v in violations:
            cut = instance.build_user_cut(model, v)
            solver.internal_solver.add_constraint(cut)
    def after_solve(
        self,
        solver,
        instance,
        model,
        results,
        training_data,
    ):
        pass
    def fit(self, training_instances):
        logger.debug(&#34;Fitting...&#34;)
        features = InstanceFeaturesExtractor().extract(training_instances)
        self.classifiers = {}
        violation_to_instance_idx = {}
        for (idx, instance) in enumerate(training_instances):
            if not hasattr(instance, &#34;found_violated_user_cuts&#34;):
                continue
            for v in instance.found_violated_user_cuts:
                if v not in self.classifiers:
                    self.classifiers[v] = deepcopy(self.classifier_prototype)
                    violation_to_instance_idx[v] = []
                violation_to_instance_idx[v] += [idx]
        for (v, classifier) in tqdm(
            self.classifiers.items(),
            desc=&#34;Fit (user cuts)&#34;,
            disable=not sys.stdout.isatty(),
        ):
            logger.debug(&#34;Training: %s&#34; % (str(v)))
            label = np.zeros(len(training_instances))
            label[violation_to_instance_idx[v]] = 1.0
            classifier.fit(features, label)
    def predict(self, instance):
        violations = []
        features = InstanceFeaturesExtractor().extract([instance])
        for (v, classifier) in self.classifiers.items():
            proba = classifier.predict_proba(features)
            if proba[0][1] &gt; self.threshold:
                violations += [v]
        return violations
    def evaluate(self, instances):
        results = {}
        all_violations = set()
        for instance in instances:
            all_violations |= set(instance.found_violated_user_cuts)
        for idx in tqdm(
            range(len(instances)),
            desc=&#34;Evaluate (lazy)&#34;,
            disable=not sys.stdout.isatty(),
        ):
            instance = instances[idx]
            condition_positive = set(instance.found_violated_user_cuts)
            condition_negative = all_violations - condition_positive
            pred_positive = set(self.predict(instance)) &amp; all_violations
            pred_negative = all_violations - pred_positive
            tp = len(pred_positive &amp; condition_positive)
            tn = len(pred_negative &amp; condition_negative)
            fp = len(pred_positive &amp; condition_negative)
            fn = len(pred_negative &amp; condition_positive)
            results[idx] = classifier_evaluation_dict(tp, tn, fp, fn)
        return results</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.components.cuts.UserCutsComponent"><code class="flex name class">
 <span>class <span class="ident">UserCutsComponent</span></span>
 <span>(</span><span>classifier=CountingClassifier(mean=None), threshold=0.05)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>A component that predicts which user cuts to enforce.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class UserCutsComponent(Component):
    &#34;&#34;&#34;
    A component that predicts which user cuts to enforce.
    &#34;&#34;&#34;
    def __init__(
        self,
        classifier: Classifier = CountingClassifier(),
        threshold: float = 0.05,
    ):
        self.threshold: float = threshold
        self.classifier_prototype: Classifier = classifier
        self.classifiers: Dict[Any, Classifier] = {}
    def before_solve(self, solver, instance, model):
        instance.found_violated_user_cuts = []
        logger.info(&#34;Predicting violated user cuts...&#34;)
        violations = self.predict(instance)
        logger.info(&#34;Enforcing %d user cuts...&#34; % len(violations))
        for v in violations:
            cut = instance.build_user_cut(model, v)
            solver.internal_solver.add_constraint(cut)
    def after_solve(
        self,
        solver,
        instance,
        model,
        results,
        training_data,
    ):
        pass
    def fit(self, training_instances):
        logger.debug(&#34;Fitting...&#34;)
        features = InstanceFeaturesExtractor().extract(training_instances)
        self.classifiers = {}
        violation_to_instance_idx = {}
        for (idx, instance) in enumerate(training_instances):
            if not hasattr(instance, &#34;found_violated_user_cuts&#34;):
                continue
            for v in instance.found_violated_user_cuts:
                if v not in self.classifiers:
                    self.classifiers[v] = deepcopy(self.classifier_prototype)
                    violation_to_instance_idx[v] = []
                violation_to_instance_idx[v] += [idx]
        for (v, classifier) in tqdm(
            self.classifiers.items(),
            desc=&#34;Fit (user cuts)&#34;,
            disable=not sys.stdout.isatty(),
        ):
            logger.debug(&#34;Training: %s&#34; % (str(v)))
            label = np.zeros(len(training_instances))
            label[violation_to_instance_idx[v]] = 1.0
            classifier.fit(features, label)
    def predict(self, instance):
        violations = []
        features = InstanceFeaturesExtractor().extract([instance])
        for (v, classifier) in self.classifiers.items():
            proba = classifier.predict_proba(features)
            if proba[0][1] &gt; self.threshold:
                violations += [v]
        return violations
    def evaluate(self, instances):
        results = {}
        all_violations = set()
        for instance in instances:
            all_violations |= set(instance.found_violated_user_cuts)
        for idx in tqdm(
            range(len(instances)),
            desc=&#34;Evaluate (lazy)&#34;,
            disable=not sys.stdout.isatty(),
        ):
            instance = instances[idx]
            condition_positive = set(instance.found_violated_user_cuts)
            condition_negative = all_violations - condition_positive
            pred_positive = set(self.predict(instance)) &amp; all_violations
            pred_negative = all_violations - pred_positive
            tp = len(pred_positive &amp; condition_positive)
            tn = len(pred_negative &amp; condition_negative)
            fp = len(pred_positive &amp; condition_negative)
            fn = len(pred_negative &amp; condition_positive)
            results[idx] = classifier_evaluation_dict(tp, tn, fp, fn)
        return results</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.components.component.Component" href="component.html#miplearn.components.component.Component">Component</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.components.cuts.UserCutsComponent.evaluate"><code class="name flex">
 <span>def <span class="ident">evaluate</span></span>(<span>self, instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def evaluate(self, instances):
    results = {}
    all_violations = set()
    for instance in instances:
        all_violations |= set(instance.found_violated_user_cuts)
    for idx in tqdm(
        range(len(instances)),
        desc=&#34;Evaluate (lazy)&#34;,
        disable=not sys.stdout.isatty(),
    ):
        instance = instances[idx]
        condition_positive = set(instance.found_violated_user_cuts)
        condition_negative = all_violations - condition_positive
        pred_positive = set(self.predict(instance)) &amp; all_violations
        pred_negative = all_violations - pred_positive
        tp = len(pred_positive &amp; condition_positive)
        tn = len(pred_negative &amp; condition_negative)
        fp = len(pred_positive &amp; condition_negative)
        fn = len(pred_negative &amp; condition_positive)
        results[idx] = classifier_evaluation_dict(tp, tn, fp, fn)
    return results</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.cuts.UserCutsComponent.fit"><code class="name flex">
 <span>def <span class="ident">fit</span></span>(<span>self, training_instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def fit(self, training_instances):
    logger.debug(&#34;Fitting...&#34;)
    features = InstanceFeaturesExtractor().extract(training_instances)
    self.classifiers = {}
    violation_to_instance_idx = {}
    for (idx, instance) in enumerate(training_instances):
        if not hasattr(instance, &#34;found_violated_user_cuts&#34;):
            continue
        for v in instance.found_violated_user_cuts:
            if v not in self.classifiers:
                self.classifiers[v] = deepcopy(self.classifier_prototype)
                violation_to_instance_idx[v] = []
            violation_to_instance_idx[v] += [idx]
    for (v, classifier) in tqdm(
        self.classifiers.items(),
        desc=&#34;Fit (user cuts)&#34;,
        disable=not sys.stdout.isatty(),
    ):
        logger.debug(&#34;Training: %s&#34; % (str(v)))
        label = np.zeros(len(training_instances))
        label[violation_to_instance_idx[v]] = 1.0
        classifier.fit(features, label)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.cuts.UserCutsComponent.predict"><code class="name flex">
 <span>def <span class="ident">predict</span></span>(<span>self, instance)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def predict(self, instance):
    violations = []
    features = InstanceFeaturesExtractor().extract([instance])
    for (v, classifier) in self.classifiers.items():
        proba = classifier.predict_proba(features)
        if proba[0][1] &gt; self.threshold:
            violations += [v]
    return violations</code></pre>
 </details>
 </dd>
 </dl>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.components.component.Component" href="component.html#miplearn.components.component.Component">Component</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.components.component.Component.after_solve" href="component.html#miplearn.components.component.Component.after_solve">after_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.before_solve" href="component.html#miplearn.components.component.Component.before_solve">before_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.iteration_cb" href="component.html#miplearn.components.component.Component.iteration_cb">iteration_cb</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.components" href="index.html">miplearn.components</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.components.cuts.UserCutsComponent" href="#miplearn.components.cuts.UserCutsComponent">UserCutsComponent</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.components.cuts.UserCutsComponent.evaluate" href="#miplearn.components.cuts.UserCutsComponent.evaluate">evaluate</a></code></li>
 <li><code><a title="miplearn.components.cuts.UserCutsComponent.fit" href="#miplearn.components.cuts.UserCutsComponent.fit">fit</a></code></li>
 <li><code><a title="miplearn.components.cuts.UserCutsComponent.predict" href="#miplearn.components.cuts.UserCutsComponent.predict">predict</a></code></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/components/index.html
+++ b/0.2/api/miplearn/components/index.html
@ -1,206 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.components API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.components</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 def classifier_evaluation_dict(tp, tn, fp, fn):
    p = tp + fn
    n = fp + tn
    d = {
        &#34;Predicted positive&#34;: fp + tp,
        &#34;Predicted negative&#34;: fn + tn,
        &#34;Condition positive&#34;: p,
        &#34;Condition negative&#34;: n,
        &#34;True positive&#34;: tp,
        &#34;True negative&#34;: tn,
        &#34;False positive&#34;: fp,
        &#34;False negative&#34;: fn,
        &#34;Accuracy&#34;: (tp + tn) / (p + n),
        &#34;F1 score&#34;: (2 * tp) / (2 * tp + fp + fn),
    }
    if p &gt; 0:
        d[&#34;Recall&#34;] = tp / p
    else:
        d[&#34;Recall&#34;] = 1.0
    if tp + fp &gt; 0:
        d[&#34;Precision&#34;] = tp / (tp + fp)
    else:
        d[&#34;Precision&#34;] = 1.0
    t = (p + n) / 100.0
    d[&#34;Predicted positive (%)&#34;] = d[&#34;Predicted positive&#34;] / t
    d[&#34;Predicted negative (%)&#34;] = d[&#34;Predicted negative&#34;] / t
    d[&#34;Condition positive (%)&#34;] = d[&#34;Condition positive&#34;] / t
    d[&#34;Condition negative (%)&#34;] = d[&#34;Condition negative&#34;] / t
    d[&#34;True positive (%)&#34;] = d[&#34;True positive&#34;] / t
    d[&#34;True negative (%)&#34;] = d[&#34;True negative&#34;] / t
    d[&#34;False positive (%)&#34;] = d[&#34;False positive&#34;] / t
    d[&#34;False negative (%)&#34;] = d[&#34;False negative&#34;] / t
    return d</code></pre>
 </details>
 </section>
 <section>
 <h2 class="section-title" id="header-submodules">Sub-modules</h2>
 <dl>
 <dt><code class="name"><a title="miplearn.components.component" href="component.html">miplearn.components.component</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.components.composite" href="composite.html">miplearn.components.composite</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.components.cuts" href="cuts.html">miplearn.components.cuts</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.components.lazy_dynamic" href="lazy_dynamic.html">miplearn.components.lazy_dynamic</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.components.lazy_static" href="lazy_static.html">miplearn.components.lazy_static</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.components.objective" href="objective.html">miplearn.components.objective</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.components.primal" href="primal.html">miplearn.components.primal</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.components.relaxation" href="relaxation.html">miplearn.components.relaxation</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.components.steps" href="steps/index.html">miplearn.components.steps</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 </dl>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-functions">Functions</h2>
 <dl>
 <dt id="miplearn.components.classifier_evaluation_dict"><code class="name flex">
 <span>def <span class="ident">classifier_evaluation_dict</span></span>(<span>tp, tn, fp, fn)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def classifier_evaluation_dict(tp, tn, fp, fn):
    p = tp + fn
    n = fp + tn
    d = {
        &#34;Predicted positive&#34;: fp + tp,
        &#34;Predicted negative&#34;: fn + tn,
        &#34;Condition positive&#34;: p,
        &#34;Condition negative&#34;: n,
        &#34;True positive&#34;: tp,
        &#34;True negative&#34;: tn,
        &#34;False positive&#34;: fp,
        &#34;False negative&#34;: fn,
        &#34;Accuracy&#34;: (tp + tn) / (p + n),
        &#34;F1 score&#34;: (2 * tp) / (2 * tp + fp + fn),
    }
    if p &gt; 0:
        d[&#34;Recall&#34;] = tp / p
    else:
        d[&#34;Recall&#34;] = 1.0
    if tp + fp &gt; 0:
        d[&#34;Precision&#34;] = tp / (tp + fp)
    else:
        d[&#34;Precision&#34;] = 1.0
    t = (p + n) / 100.0
    d[&#34;Predicted positive (%)&#34;] = d[&#34;Predicted positive&#34;] / t
    d[&#34;Predicted negative (%)&#34;] = d[&#34;Predicted negative&#34;] / t
    d[&#34;Condition positive (%)&#34;] = d[&#34;Condition positive&#34;] / t
    d[&#34;Condition negative (%)&#34;] = d[&#34;Condition negative&#34;] / t
    d[&#34;True positive (%)&#34;] = d[&#34;True positive&#34;] / t
    d[&#34;True negative (%)&#34;] = d[&#34;True negative&#34;] / t
    d[&#34;False positive (%)&#34;] = d[&#34;False positive&#34;] / t
    d[&#34;False negative (%)&#34;] = d[&#34;False negative&#34;] / t
    return d</code></pre>
 </details>
 </dd>
 </dl>
 </section>
 <section>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn" href="../index.html">miplearn</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-submodules">Sub-modules</a></h3>
 <ul>
 <li><code><a title="miplearn.components.component" href="component.html">miplearn.components.component</a></code></li>
 <li><code><a title="miplearn.components.composite" href="composite.html">miplearn.components.composite</a></code></li>
 <li><code><a title="miplearn.components.cuts" href="cuts.html">miplearn.components.cuts</a></code></li>
 <li><code><a title="miplearn.components.lazy_dynamic" href="lazy_dynamic.html">miplearn.components.lazy_dynamic</a></code></li>
 <li><code><a title="miplearn.components.lazy_static" href="lazy_static.html">miplearn.components.lazy_static</a></code></li>
 <li><code><a title="miplearn.components.objective" href="objective.html">miplearn.components.objective</a></code></li>
 <li><code><a title="miplearn.components.primal" href="primal.html">miplearn.components.primal</a></code></li>
 <li><code><a title="miplearn.components.relaxation" href="relaxation.html">miplearn.components.relaxation</a></code></li>
 <li><code><a title="miplearn.components.steps" href="steps/index.html">miplearn.components.steps</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-functions">Functions</a></h3>
 <ul class="">
 <li><code><a title="miplearn.components.classifier_evaluation_dict" href="#miplearn.components.classifier_evaluation_dict">classifier_evaluation_dict</a></code></li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/components/lazy_dynamic.html
+++ b/0.2/api/miplearn/components/lazy_dynamic.html
@ -1,410 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.components.lazy_dynamic API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.components.lazy_dynamic</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import logging
 import sys
 from copy import deepcopy
 from typing import Any, Dict
 import numpy as np
 from tqdm.auto import tqdm
 from miplearn.classifiers import Classifier
 from miplearn.classifiers.counting import CountingClassifier
 from miplearn.components import classifier_evaluation_dict
 from miplearn.components.component import Component
 from miplearn.extractors import InstanceFeaturesExtractor, InstanceIterator
 logger = logging.getLogger(__name__)
 class DynamicLazyConstraintsComponent(Component):
    &#34;&#34;&#34;
    A component that predicts which lazy constraints to enforce.
    &#34;&#34;&#34;
    def __init__(
        self,
        classifier: Classifier = CountingClassifier(),
        threshold: float = 0.05,
    ):
        self.threshold: float = threshold
        self.classifier_prototype: Classifier = classifier
        self.classifiers: Dict[Any, Classifier] = {}
    def before_solve(self, solver, instance, model):
        instance.found_violated_lazy_constraints = []
        logger.info(&#34;Predicting violated lazy constraints...&#34;)
        violations = self.predict(instance)
        logger.info(&#34;Enforcing %d lazy constraints...&#34; % len(violations))
        for v in violations:
            cut = instance.build_lazy_constraint(model, v)
            solver.internal_solver.add_constraint(cut)
    def iteration_cb(self, solver, instance, model):
        logger.debug(&#34;Finding violated (dynamic) lazy constraints...&#34;)
        violations = instance.find_violated_lazy_constraints(model)
        if len(violations) == 0:
            return False
        instance.found_violated_lazy_constraints += violations
        logger.debug(&#34;    %d violations found&#34; % len(violations))
        for v in violations:
            cut = instance.build_lazy_constraint(model, v)
            solver.internal_solver.add_constraint(cut)
        return True
    def after_solve(
        self,
        solver,
        instance,
        model,
        stats,
        training_data,
    ):
        pass
    def fit(self, training_instances):
        logger.debug(&#34;Fitting...&#34;)
        features = InstanceFeaturesExtractor().extract(training_instances)
        self.classifiers = {}
        violation_to_instance_idx = {}
        for (idx, instance) in enumerate(InstanceIterator(training_instances)):
            for v in instance.found_violated_lazy_constraints:
                if isinstance(v, list):
                    v = tuple(v)
                if v not in self.classifiers:
                    self.classifiers[v] = deepcopy(self.classifier_prototype)
                    violation_to_instance_idx[v] = []
                violation_to_instance_idx[v] += [idx]
        for (v, classifier) in tqdm(
            self.classifiers.items(),
            desc=&#34;Fit (lazy)&#34;,
            disable=not sys.stdout.isatty(),
        ):
            logger.debug(&#34;Training: %s&#34; % (str(v)))
            label = np.zeros(len(training_instances))
            label[violation_to_instance_idx[v]] = 1.0
            classifier.fit(features, label)
    def predict(self, instance):
        violations = []
        features = InstanceFeaturesExtractor().extract([instance])
        for (v, classifier) in self.classifiers.items():
            proba = classifier.predict_proba(features)
            if proba[0][1] &gt; self.threshold:
                violations += [v]
        return violations
    def evaluate(self, instances):
        results = {}
        all_violations = set()
        for instance in instances:
            all_violations |= set(instance.found_violated_lazy_constraints)
        for idx in tqdm(
            range(len(instances)),
            desc=&#34;Evaluate (lazy)&#34;,
            disable=not sys.stdout.isatty(),
        ):
            instance = instances[idx]
            condition_positive = set(instance.found_violated_lazy_constraints)
            condition_negative = all_violations - condition_positive
            pred_positive = set(self.predict(instance)) &amp; all_violations
            pred_negative = all_violations - pred_positive
            tp = len(pred_positive &amp; condition_positive)
            tn = len(pred_negative &amp; condition_negative)
            fp = len(pred_positive &amp; condition_negative)
            fn = len(pred_negative &amp; condition_positive)
            results[idx] = classifier_evaluation_dict(tp, tn, fp, fn)
        return results</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.components.lazy_dynamic.DynamicLazyConstraintsComponent"><code class="flex name class">
 <span>class <span class="ident">DynamicLazyConstraintsComponent</span></span>
 <span>(</span><span>classifier=CountingClassifier(mean=None), threshold=0.05)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>A component that predicts which lazy constraints to enforce.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class DynamicLazyConstraintsComponent(Component):
    &#34;&#34;&#34;
    A component that predicts which lazy constraints to enforce.
    &#34;&#34;&#34;
    def __init__(
        self,
        classifier: Classifier = CountingClassifier(),
        threshold: float = 0.05,
    ):
        self.threshold: float = threshold
        self.classifier_prototype: Classifier = classifier
        self.classifiers: Dict[Any, Classifier] = {}
    def before_solve(self, solver, instance, model):
        instance.found_violated_lazy_constraints = []
        logger.info(&#34;Predicting violated lazy constraints...&#34;)
        violations = self.predict(instance)
        logger.info(&#34;Enforcing %d lazy constraints...&#34; % len(violations))
        for v in violations:
            cut = instance.build_lazy_constraint(model, v)
            solver.internal_solver.add_constraint(cut)
    def iteration_cb(self, solver, instance, model):
        logger.debug(&#34;Finding violated (dynamic) lazy constraints...&#34;)
        violations = instance.find_violated_lazy_constraints(model)
        if len(violations) == 0:
            return False
        instance.found_violated_lazy_constraints += violations
        logger.debug(&#34;    %d violations found&#34; % len(violations))
        for v in violations:
            cut = instance.build_lazy_constraint(model, v)
            solver.internal_solver.add_constraint(cut)
        return True
    def after_solve(
        self,
        solver,
        instance,
        model,
        stats,
        training_data,
    ):
        pass
    def fit(self, training_instances):
        logger.debug(&#34;Fitting...&#34;)
        features = InstanceFeaturesExtractor().extract(training_instances)
        self.classifiers = {}
        violation_to_instance_idx = {}
        for (idx, instance) in enumerate(InstanceIterator(training_instances)):
            for v in instance.found_violated_lazy_constraints:
                if isinstance(v, list):
                    v = tuple(v)
                if v not in self.classifiers:
                    self.classifiers[v] = deepcopy(self.classifier_prototype)
                    violation_to_instance_idx[v] = []
                violation_to_instance_idx[v] += [idx]
        for (v, classifier) in tqdm(
            self.classifiers.items(),
            desc=&#34;Fit (lazy)&#34;,
            disable=not sys.stdout.isatty(),
        ):
            logger.debug(&#34;Training: %s&#34; % (str(v)))
            label = np.zeros(len(training_instances))
            label[violation_to_instance_idx[v]] = 1.0
            classifier.fit(features, label)
    def predict(self, instance):
        violations = []
        features = InstanceFeaturesExtractor().extract([instance])
        for (v, classifier) in self.classifiers.items():
            proba = classifier.predict_proba(features)
            if proba[0][1] &gt; self.threshold:
                violations += [v]
        return violations
    def evaluate(self, instances):
        results = {}
        all_violations = set()
        for instance in instances:
            all_violations |= set(instance.found_violated_lazy_constraints)
        for idx in tqdm(
            range(len(instances)),
            desc=&#34;Evaluate (lazy)&#34;,
            disable=not sys.stdout.isatty(),
        ):
            instance = instances[idx]
            condition_positive = set(instance.found_violated_lazy_constraints)
            condition_negative = all_violations - condition_positive
            pred_positive = set(self.predict(instance)) &amp; all_violations
            pred_negative = all_violations - pred_positive
            tp = len(pred_positive &amp; condition_positive)
            tn = len(pred_negative &amp; condition_negative)
            fp = len(pred_positive &amp; condition_negative)
            fn = len(pred_negative &amp; condition_positive)
            results[idx] = classifier_evaluation_dict(tp, tn, fp, fn)
        return results</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.components.component.Component" href="component.html#miplearn.components.component.Component">Component</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.components.lazy_dynamic.DynamicLazyConstraintsComponent.evaluate"><code class="name flex">
 <span>def <span class="ident">evaluate</span></span>(<span>self, instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def evaluate(self, instances):
    results = {}
    all_violations = set()
    for instance in instances:
        all_violations |= set(instance.found_violated_lazy_constraints)
    for idx in tqdm(
        range(len(instances)),
        desc=&#34;Evaluate (lazy)&#34;,
        disable=not sys.stdout.isatty(),
    ):
        instance = instances[idx]
        condition_positive = set(instance.found_violated_lazy_constraints)
        condition_negative = all_violations - condition_positive
        pred_positive = set(self.predict(instance)) &amp; all_violations
        pred_negative = all_violations - pred_positive
        tp = len(pred_positive &amp; condition_positive)
        tn = len(pred_negative &amp; condition_negative)
        fp = len(pred_positive &amp; condition_negative)
        fn = len(pred_negative &amp; condition_positive)
        results[idx] = classifier_evaluation_dict(tp, tn, fp, fn)
    return results</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.lazy_dynamic.DynamicLazyConstraintsComponent.fit"><code class="name flex">
 <span>def <span class="ident">fit</span></span>(<span>self, training_instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def fit(self, training_instances):
    logger.debug(&#34;Fitting...&#34;)
    features = InstanceFeaturesExtractor().extract(training_instances)
    self.classifiers = {}
    violation_to_instance_idx = {}
    for (idx, instance) in enumerate(InstanceIterator(training_instances)):
        for v in instance.found_violated_lazy_constraints:
            if isinstance(v, list):
                v = tuple(v)
            if v not in self.classifiers:
                self.classifiers[v] = deepcopy(self.classifier_prototype)
                violation_to_instance_idx[v] = []
            violation_to_instance_idx[v] += [idx]
    for (v, classifier) in tqdm(
        self.classifiers.items(),
        desc=&#34;Fit (lazy)&#34;,
        disable=not sys.stdout.isatty(),
    ):
        logger.debug(&#34;Training: %s&#34; % (str(v)))
        label = np.zeros(len(training_instances))
        label[violation_to_instance_idx[v]] = 1.0
        classifier.fit(features, label)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.lazy_dynamic.DynamicLazyConstraintsComponent.predict"><code class="name flex">
 <span>def <span class="ident">predict</span></span>(<span>self, instance)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def predict(self, instance):
    violations = []
    features = InstanceFeaturesExtractor().extract([instance])
    for (v, classifier) in self.classifiers.items():
        proba = classifier.predict_proba(features)
        if proba[0][1] &gt; self.threshold:
            violations += [v]
    return violations</code></pre>
 </details>
 </dd>
 </dl>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.components.component.Component" href="component.html#miplearn.components.component.Component">Component</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.components.component.Component.after_solve" href="component.html#miplearn.components.component.Component.after_solve">after_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.before_solve" href="component.html#miplearn.components.component.Component.before_solve">before_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.iteration_cb" href="component.html#miplearn.components.component.Component.iteration_cb">iteration_cb</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.components" href="index.html">miplearn.components</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.components.lazy_dynamic.DynamicLazyConstraintsComponent" href="#miplearn.components.lazy_dynamic.DynamicLazyConstraintsComponent">DynamicLazyConstraintsComponent</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.components.lazy_dynamic.DynamicLazyConstraintsComponent.evaluate" href="#miplearn.components.lazy_dynamic.DynamicLazyConstraintsComponent.evaluate">evaluate</a></code></li>
 <li><code><a title="miplearn.components.lazy_dynamic.DynamicLazyConstraintsComponent.fit" href="#miplearn.components.lazy_dynamic.DynamicLazyConstraintsComponent.fit">fit</a></code></li>
 <li><code><a title="miplearn.components.lazy_dynamic.DynamicLazyConstraintsComponent.predict" href="#miplearn.components.lazy_dynamic.DynamicLazyConstraintsComponent.predict">predict</a></code></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/components/lazy_static.html
+++ b/0.2/api/miplearn/components/lazy_static.html
@ -1,624 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.components.lazy_static API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.components.lazy_static</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import logging
 import sys
 from copy import deepcopy
 import numpy as np
 from tqdm.auto import tqdm
 from miplearn.classifiers.counting import CountingClassifier
 from miplearn.components.component import Component
 logger = logging.getLogger(__name__)
 class LazyConstraint:
    def __init__(self, cid, obj):
        self.cid = cid
        self.obj = obj
 class StaticLazyConstraintsComponent(Component):
    def __init__(
        self,
        classifier=CountingClassifier(),
        threshold=0.05,
        use_two_phase_gap=True,
        large_gap=1e-2,
        violation_tolerance=-0.5,
    ):
        self.threshold = threshold
        self.classifier_prototype = classifier
        self.classifiers = {}
        self.pool = []
        self.original_gap = None
        self.large_gap = large_gap
        self.is_gap_large = False
        self.use_two_phase_gap = use_two_phase_gap
        self.violation_tolerance = violation_tolerance
    def before_solve(self, solver, instance, model):
        self.pool = []
        if not solver.use_lazy_cb and self.use_two_phase_gap:
            logger.info(&#34;Increasing gap tolerance to %f&#34;, self.large_gap)
            self.original_gap = solver.gap_tolerance
            self.is_gap_large = True
            solver.internal_solver.set_gap_tolerance(self.large_gap)
        instance.found_violated_lazy_constraints = []
        if instance.has_static_lazy_constraints():
            self._extract_and_predict_static(solver, instance)
    def after_solve(
        self,
        solver,
        instance,
        model,
        stats,
        training_data,
    ):
        pass
    def iteration_cb(self, solver, instance, model):
        if solver.use_lazy_cb:
            return False
        else:
            should_repeat = self._check_and_add(instance, solver)
            if should_repeat:
                return True
            else:
                if self.is_gap_large:
                    logger.info(&#34;Restoring gap tolerance to %f&#34;, self.original_gap)
                    solver.internal_solver.set_gap_tolerance(self.original_gap)
                    self.is_gap_large = False
                    return True
                else:
                    return False
    def lazy_cb(self, solver, instance, model):
        self._check_and_add(instance, solver)
    def _check_and_add(self, instance, solver):
        logger.debug(&#34;Finding violated lazy constraints...&#34;)
        constraints_to_add = []
        for c in self.pool:
            if not solver.internal_solver.is_constraint_satisfied(
                c.obj, tol=self.violation_tolerance
            ):
                constraints_to_add.append(c)
        for c in constraints_to_add:
            self.pool.remove(c)
            solver.internal_solver.add_constraint(c.obj)
            instance.found_violated_lazy_constraints += [c.cid]
        if len(constraints_to_add) &gt; 0:
            logger.info(
                &#34;%8d lazy constraints added %8d in the pool&#34;
                % (len(constraints_to_add), len(self.pool))
            )
            return True
        else:
            return False
    def fit(self, training_instances):
        training_instances = [
            t
            for t in training_instances
            if hasattr(t, &#34;found_violated_lazy_constraints&#34;)
        ]
        logger.debug(&#34;Extracting x and y...&#34;)
        x = self.x(training_instances)
        y = self.y(training_instances)
        logger.debug(&#34;Fitting...&#34;)
        for category in tqdm(
            x.keys(), desc=&#34;Fit (lazy)&#34;, disable=not sys.stdout.isatty()
        ):
            if category not in self.classifiers:
                self.classifiers[category] = deepcopy(self.classifier_prototype)
            self.classifiers[category].fit(x[category], y[category])
    def predict(self, instance):
        pass
    def evaluate(self, instances):
        pass
    def _extract_and_predict_static(self, solver, instance):
        x = {}
        constraints = {}
        logger.info(&#34;Extracting lazy constraints...&#34;)
        for cid in solver.internal_solver.get_constraint_ids():
            if instance.is_constraint_lazy(cid):
                category = instance.get_constraint_category(cid)
                if category not in x:
                    x[category] = []
                    constraints[category] = []
                x[category] += [instance.get_constraint_features(cid)]
                c = LazyConstraint(
                    cid=cid,
                    obj=solver.internal_solver.extract_constraint(cid),
                )
                constraints[category] += [c]
                self.pool.append(c)
        logger.info(&#34;%8d lazy constraints extracted&#34; % len(self.pool))
        logger.info(&#34;Predicting required lazy constraints...&#34;)
        n_added = 0
        for (category, x_values) in x.items():
            if category not in self.classifiers:
                continue
            if isinstance(x_values[0], np.ndarray):
                x[category] = np.array(x_values)
            proba = self.classifiers[category].predict_proba(x[category])
            for i in range(len(proba)):
                if proba[i][1] &gt; self.threshold:
                    n_added += 1
                    c = constraints[category][i]
                    self.pool.remove(c)
                    solver.internal_solver.add_constraint(c.obj)
                    instance.found_violated_lazy_constraints += [c.cid]
        logger.info(
            &#34;%8d lazy constraints added %8d in the pool&#34;
            % (
                n_added,
                len(self.pool),
            )
        )
    def _collect_constraints(self, train_instances):
        constraints = {}
        for instance in train_instances:
            for cid in instance.found_violated_lazy_constraints:
                category = instance.get_constraint_category(cid)
                if category not in constraints:
                    constraints[category] = set()
                constraints[category].add(cid)
        for (category, cids) in constraints.items():
            constraints[category] = sorted(list(cids))
        return constraints
    def x(self, train_instances):
        result = {}
        constraints = self._collect_constraints(train_instances)
        for (category, cids) in constraints.items():
            result[category] = []
            for instance in train_instances:
                for cid in cids:
                    result[category].append(instance.get_constraint_features(cid))
        return result
    def y(self, train_instances):
        result = {}
        constraints = self._collect_constraints(train_instances)
        for (category, cids) in constraints.items():
            result[category] = []
            for instance in train_instances:
                for cid in cids:
                    if cid in instance.found_violated_lazy_constraints:
                        result[category].append([0, 1])
                    else:
                        result[category].append([1, 0])
        return result</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.components.lazy_static.LazyConstraint"><code class="flex name class">
 <span>class <span class="ident">LazyConstraint</span></span>
 <span>(</span><span>cid, obj)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class LazyConstraint:
    def __init__(self, cid, obj):
        self.cid = cid
        self.obj = obj</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.lazy_static.StaticLazyConstraintsComponent"><code class="flex name class">
 <span>class <span class="ident">StaticLazyConstraintsComponent</span></span>
 <span>(</span><span>classifier=CountingClassifier(mean=None), threshold=0.05, use_two_phase_gap=True, large_gap=0.01, violation_tolerance=-0.5)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>A Component is an object which adds functionality to a LearningSolver.</p>
 <p>For better code maintainability, LearningSolver simply delegates most of its
 functionality to Components. Each Component is responsible for exactly one ML
 strategy.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class StaticLazyConstraintsComponent(Component):
    def __init__(
        self,
        classifier=CountingClassifier(),
        threshold=0.05,
        use_two_phase_gap=True,
        large_gap=1e-2,
        violation_tolerance=-0.5,
    ):
        self.threshold = threshold
        self.classifier_prototype = classifier
        self.classifiers = {}
        self.pool = []
        self.original_gap = None
        self.large_gap = large_gap
        self.is_gap_large = False
        self.use_two_phase_gap = use_two_phase_gap
        self.violation_tolerance = violation_tolerance
    def before_solve(self, solver, instance, model):
        self.pool = []
        if not solver.use_lazy_cb and self.use_two_phase_gap:
            logger.info(&#34;Increasing gap tolerance to %f&#34;, self.large_gap)
            self.original_gap = solver.gap_tolerance
            self.is_gap_large = True
            solver.internal_solver.set_gap_tolerance(self.large_gap)
        instance.found_violated_lazy_constraints = []
        if instance.has_static_lazy_constraints():
            self._extract_and_predict_static(solver, instance)
    def after_solve(
        self,
        solver,
        instance,
        model,
        stats,
        training_data,
    ):
        pass
    def iteration_cb(self, solver, instance, model):
        if solver.use_lazy_cb:
            return False
        else:
            should_repeat = self._check_and_add(instance, solver)
            if should_repeat:
                return True
            else:
                if self.is_gap_large:
                    logger.info(&#34;Restoring gap tolerance to %f&#34;, self.original_gap)
                    solver.internal_solver.set_gap_tolerance(self.original_gap)
                    self.is_gap_large = False
                    return True
                else:
                    return False
    def lazy_cb(self, solver, instance, model):
        self._check_and_add(instance, solver)
    def _check_and_add(self, instance, solver):
        logger.debug(&#34;Finding violated lazy constraints...&#34;)
        constraints_to_add = []
        for c in self.pool:
            if not solver.internal_solver.is_constraint_satisfied(
                c.obj, tol=self.violation_tolerance
            ):
                constraints_to_add.append(c)
        for c in constraints_to_add:
            self.pool.remove(c)
            solver.internal_solver.add_constraint(c.obj)
            instance.found_violated_lazy_constraints += [c.cid]
        if len(constraints_to_add) &gt; 0:
            logger.info(
                &#34;%8d lazy constraints added %8d in the pool&#34;
                % (len(constraints_to_add), len(self.pool))
            )
            return True
        else:
            return False
    def fit(self, training_instances):
        training_instances = [
            t
            for t in training_instances
            if hasattr(t, &#34;found_violated_lazy_constraints&#34;)
        ]
        logger.debug(&#34;Extracting x and y...&#34;)
        x = self.x(training_instances)
        y = self.y(training_instances)
        logger.debug(&#34;Fitting...&#34;)
        for category in tqdm(
            x.keys(), desc=&#34;Fit (lazy)&#34;, disable=not sys.stdout.isatty()
        ):
            if category not in self.classifiers:
                self.classifiers[category] = deepcopy(self.classifier_prototype)
            self.classifiers[category].fit(x[category], y[category])
    def predict(self, instance):
        pass
    def evaluate(self, instances):
        pass
    def _extract_and_predict_static(self, solver, instance):
        x = {}
        constraints = {}
        logger.info(&#34;Extracting lazy constraints...&#34;)
        for cid in solver.internal_solver.get_constraint_ids():
            if instance.is_constraint_lazy(cid):
                category = instance.get_constraint_category(cid)
                if category not in x:
                    x[category] = []
                    constraints[category] = []
                x[category] += [instance.get_constraint_features(cid)]
                c = LazyConstraint(
                    cid=cid,
                    obj=solver.internal_solver.extract_constraint(cid),
                )
                constraints[category] += [c]
                self.pool.append(c)
        logger.info(&#34;%8d lazy constraints extracted&#34; % len(self.pool))
        logger.info(&#34;Predicting required lazy constraints...&#34;)
        n_added = 0
        for (category, x_values) in x.items():
            if category not in self.classifiers:
                continue
            if isinstance(x_values[0], np.ndarray):
                x[category] = np.array(x_values)
            proba = self.classifiers[category].predict_proba(x[category])
            for i in range(len(proba)):
                if proba[i][1] &gt; self.threshold:
                    n_added += 1
                    c = constraints[category][i]
                    self.pool.remove(c)
                    solver.internal_solver.add_constraint(c.obj)
                    instance.found_violated_lazy_constraints += [c.cid]
        logger.info(
            &#34;%8d lazy constraints added %8d in the pool&#34;
            % (
                n_added,
                len(self.pool),
            )
        )
    def _collect_constraints(self, train_instances):
        constraints = {}
        for instance in train_instances:
            for cid in instance.found_violated_lazy_constraints:
                category = instance.get_constraint_category(cid)
                if category not in constraints:
                    constraints[category] = set()
                constraints[category].add(cid)
        for (category, cids) in constraints.items():
            constraints[category] = sorted(list(cids))
        return constraints
    def x(self, train_instances):
        result = {}
        constraints = self._collect_constraints(train_instances)
        for (category, cids) in constraints.items():
            result[category] = []
            for instance in train_instances:
                for cid in cids:
                    result[category].append(instance.get_constraint_features(cid))
        return result
    def y(self, train_instances):
        result = {}
        constraints = self._collect_constraints(train_instances)
        for (category, cids) in constraints.items():
            result[category] = []
            for instance in train_instances:
                for cid in cids:
                    if cid in instance.found_violated_lazy_constraints:
                        result[category].append([0, 1])
                    else:
                        result[category].append([1, 0])
        return result</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.components.component.Component" href="component.html#miplearn.components.component.Component">Component</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.components.lazy_static.StaticLazyConstraintsComponent.evaluate"><code class="name flex">
 <span>def <span class="ident">evaluate</span></span>(<span>self, instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def evaluate(self, instances):
    pass</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.lazy_static.StaticLazyConstraintsComponent.fit"><code class="name flex">
 <span>def <span class="ident">fit</span></span>(<span>self, training_instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def fit(self, training_instances):
    training_instances = [
        t
        for t in training_instances
        if hasattr(t, &#34;found_violated_lazy_constraints&#34;)
    ]
    logger.debug(&#34;Extracting x and y...&#34;)
    x = self.x(training_instances)
    y = self.y(training_instances)
    logger.debug(&#34;Fitting...&#34;)
    for category in tqdm(
        x.keys(), desc=&#34;Fit (lazy)&#34;, disable=not sys.stdout.isatty()
    ):
        if category not in self.classifiers:
            self.classifiers[category] = deepcopy(self.classifier_prototype)
        self.classifiers[category].fit(x[category], y[category])</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.lazy_static.StaticLazyConstraintsComponent.lazy_cb"><code class="name flex">
 <span>def <span class="ident">lazy_cb</span></span>(<span>self, solver, instance, model)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def lazy_cb(self, solver, instance, model):
    self._check_and_add(instance, solver)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.lazy_static.StaticLazyConstraintsComponent.predict"><code class="name flex">
 <span>def <span class="ident">predict</span></span>(<span>self, instance)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def predict(self, instance):
    pass</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.lazy_static.StaticLazyConstraintsComponent.x"><code class="name flex">
 <span>def <span class="ident">x</span></span>(<span>self, train_instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def x(self, train_instances):
    result = {}
    constraints = self._collect_constraints(train_instances)
    for (category, cids) in constraints.items():
        result[category] = []
        for instance in train_instances:
            for cid in cids:
                result[category].append(instance.get_constraint_features(cid))
    return result</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.lazy_static.StaticLazyConstraintsComponent.y"><code class="name flex">
 <span>def <span class="ident">y</span></span>(<span>self, train_instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def y(self, train_instances):
    result = {}
    constraints = self._collect_constraints(train_instances)
    for (category, cids) in constraints.items():
        result[category] = []
        for instance in train_instances:
            for cid in cids:
                if cid in instance.found_violated_lazy_constraints:
                    result[category].append([0, 1])
                else:
                    result[category].append([1, 0])
    return result</code></pre>
 </details>
 </dd>
 </dl>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.components.component.Component" href="component.html#miplearn.components.component.Component">Component</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.components.component.Component.after_solve" href="component.html#miplearn.components.component.Component.after_solve">after_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.before_solve" href="component.html#miplearn.components.component.Component.before_solve">before_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.iteration_cb" href="component.html#miplearn.components.component.Component.iteration_cb">iteration_cb</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.components" href="index.html">miplearn.components</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.components.lazy_static.LazyConstraint" href="#miplearn.components.lazy_static.LazyConstraint">LazyConstraint</a></code></h4>
 </li>
 <li>
 <h4><code><a title="miplearn.components.lazy_static.StaticLazyConstraintsComponent" href="#miplearn.components.lazy_static.StaticLazyConstraintsComponent">StaticLazyConstraintsComponent</a></code></h4>
 <ul class="two-column">
 <li><code><a title="miplearn.components.lazy_static.StaticLazyConstraintsComponent.evaluate" href="#miplearn.components.lazy_static.StaticLazyConstraintsComponent.evaluate">evaluate</a></code></li>
 <li><code><a title="miplearn.components.lazy_static.StaticLazyConstraintsComponent.fit" href="#miplearn.components.lazy_static.StaticLazyConstraintsComponent.fit">fit</a></code></li>
 <li><code><a title="miplearn.components.lazy_static.StaticLazyConstraintsComponent.lazy_cb" href="#miplearn.components.lazy_static.StaticLazyConstraintsComponent.lazy_cb">lazy_cb</a></code></li>
 <li><code><a title="miplearn.components.lazy_static.StaticLazyConstraintsComponent.predict" href="#miplearn.components.lazy_static.StaticLazyConstraintsComponent.predict">predict</a></code></li>
 <li><code><a title="miplearn.components.lazy_static.StaticLazyConstraintsComponent.x" href="#miplearn.components.lazy_static.StaticLazyConstraintsComponent.x">x</a></code></li>
 <li><code><a title="miplearn.components.lazy_static.StaticLazyConstraintsComponent.y" href="#miplearn.components.lazy_static.StaticLazyConstraintsComponent.y">y</a></code></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/components/objective.html
+++ b/0.2/api/miplearn/components/objective.html
@ -1,392 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.components.objective API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.components.objective</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import logging
 from copy import deepcopy
 import numpy as np
 from sklearn.linear_model import LinearRegression
 from sklearn.metrics import (
    mean_squared_error,
    explained_variance_score,
    max_error,
    mean_absolute_error,
    r2_score,
 )
 from miplearn.classifiers import Regressor
 from miplearn.components.component import Component
 from miplearn.extractors import InstanceFeaturesExtractor, ObjectiveValueExtractor
 logger = logging.getLogger(__name__)
 class ObjectiveValueComponent(Component):
    &#34;&#34;&#34;
    A Component which predicts the optimal objective value of the problem.
    &#34;&#34;&#34;
    def __init__(
        self,
        regressor: Regressor = LinearRegression(),
    ) -&gt; None:
        self.ub_regressor = None
        self.lb_regressor = None
        self.regressor_prototype = regressor
    def before_solve(self, solver, instance, model):
        if self.ub_regressor is not None:
            logger.info(&#34;Predicting optimal value...&#34;)
            lb, ub = self.predict([instance])[0]
            instance.predicted_ub = ub
            instance.predicted_lb = lb
            logger.info(&#34;Predicted values: lb=%.2f, ub=%.2f&#34; % (lb, ub))
    def after_solve(
        self,
        solver,
        instance,
        model,
        stats,
        training_data,
    ):
        if self.ub_regressor is not None:
            stats[&#34;Predicted UB&#34;] = instance.predicted_ub
            stats[&#34;Predicted LB&#34;] = instance.predicted_lb
        else:
            stats[&#34;Predicted UB&#34;] = None
            stats[&#34;Predicted LB&#34;] = None
    def fit(self, training_instances):
        logger.debug(&#34;Extracting features...&#34;)
        features = InstanceFeaturesExtractor().extract(training_instances)
        ub = ObjectiveValueExtractor(kind=&#34;upper bound&#34;).extract(training_instances)
        lb = ObjectiveValueExtractor(kind=&#34;lower bound&#34;).extract(training_instances)
        assert ub.shape == (len(training_instances), 1)
        assert lb.shape == (len(training_instances), 1)
        self.ub_regressor = deepcopy(self.regressor_prototype)
        self.lb_regressor = deepcopy(self.regressor_prototype)
        logger.debug(&#34;Fitting ub_regressor...&#34;)
        self.ub_regressor.fit(features, ub.ravel())
        logger.debug(&#34;Fitting ub_regressor...&#34;)
        self.lb_regressor.fit(features, lb.ravel())
    def predict(self, instances):
        features = InstanceFeaturesExtractor().extract(instances)
        lb = self.lb_regressor.predict(features)
        ub = self.ub_regressor.predict(features)
        assert lb.shape == (len(instances),)
        assert ub.shape == (len(instances),)
        return np.array([lb, ub]).T
    def evaluate(self, instances):
        y_pred = self.predict(instances)
        y_true = np.array(
            [
                [
                    inst.training_data[0][&#34;Lower bound&#34;],
                    inst.training_data[0][&#34;Upper bound&#34;],
                ]
                for inst in instances
            ]
        )
        y_true_lb, y_true_ub = y_true[:, 0], y_true[:, 1]
        y_pred_lb, y_pred_ub = y_pred[:, 1], y_pred[:, 1]
        ev = {
            &#34;Lower bound&#34;: {
                &#34;Mean squared error&#34;: mean_squared_error(y_true_lb, y_pred_lb),
                &#34;Explained variance&#34;: explained_variance_score(y_true_lb, y_pred_lb),
                &#34;Max error&#34;: max_error(y_true_lb, y_pred_lb),
                &#34;Mean absolute error&#34;: mean_absolute_error(y_true_lb, y_pred_lb),
                &#34;R2&#34;: r2_score(y_true_lb, y_pred_lb),
                &#34;Median absolute error&#34;: mean_absolute_error(y_true_lb, y_pred_lb),
            },
            &#34;Upper bound&#34;: {
                &#34;Mean squared error&#34;: mean_squared_error(y_true_ub, y_pred_ub),
                &#34;Explained variance&#34;: explained_variance_score(y_true_ub, y_pred_ub),
                &#34;Max error&#34;: max_error(y_true_ub, y_pred_ub),
                &#34;Mean absolute error&#34;: mean_absolute_error(y_true_ub, y_pred_ub),
                &#34;R2&#34;: r2_score(y_true_ub, y_pred_ub),
                &#34;Median absolute error&#34;: mean_absolute_error(y_true_ub, y_pred_ub),
            },
        }
        return ev</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.components.objective.ObjectiveValueComponent"><code class="flex name class">
 <span>class <span class="ident">ObjectiveValueComponent</span></span>
 <span>(</span><span>regressor=LinearRegression())</span>
 </code></dt>
 <dd>
 <section class="desc"><p>A Component which predicts the optimal objective value of the problem.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class ObjectiveValueComponent(Component):
    &#34;&#34;&#34;
    A Component which predicts the optimal objective value of the problem.
    &#34;&#34;&#34;
    def __init__(
        self,
        regressor: Regressor = LinearRegression(),
    ) -&gt; None:
        self.ub_regressor = None
        self.lb_regressor = None
        self.regressor_prototype = regressor
    def before_solve(self, solver, instance, model):
        if self.ub_regressor is not None:
            logger.info(&#34;Predicting optimal value...&#34;)
            lb, ub = self.predict([instance])[0]
            instance.predicted_ub = ub
            instance.predicted_lb = lb
            logger.info(&#34;Predicted values: lb=%.2f, ub=%.2f&#34; % (lb, ub))
    def after_solve(
        self,
        solver,
        instance,
        model,
        stats,
        training_data,
    ):
        if self.ub_regressor is not None:
            stats[&#34;Predicted UB&#34;] = instance.predicted_ub
            stats[&#34;Predicted LB&#34;] = instance.predicted_lb
        else:
            stats[&#34;Predicted UB&#34;] = None
            stats[&#34;Predicted LB&#34;] = None
    def fit(self, training_instances):
        logger.debug(&#34;Extracting features...&#34;)
        features = InstanceFeaturesExtractor().extract(training_instances)
        ub = ObjectiveValueExtractor(kind=&#34;upper bound&#34;).extract(training_instances)
        lb = ObjectiveValueExtractor(kind=&#34;lower bound&#34;).extract(training_instances)
        assert ub.shape == (len(training_instances), 1)
        assert lb.shape == (len(training_instances), 1)
        self.ub_regressor = deepcopy(self.regressor_prototype)
        self.lb_regressor = deepcopy(self.regressor_prototype)
        logger.debug(&#34;Fitting ub_regressor...&#34;)
        self.ub_regressor.fit(features, ub.ravel())
        logger.debug(&#34;Fitting ub_regressor...&#34;)
        self.lb_regressor.fit(features, lb.ravel())
    def predict(self, instances):
        features = InstanceFeaturesExtractor().extract(instances)
        lb = self.lb_regressor.predict(features)
        ub = self.ub_regressor.predict(features)
        assert lb.shape == (len(instances),)
        assert ub.shape == (len(instances),)
        return np.array([lb, ub]).T
    def evaluate(self, instances):
        y_pred = self.predict(instances)
        y_true = np.array(
            [
                [
                    inst.training_data[0][&#34;Lower bound&#34;],
                    inst.training_data[0][&#34;Upper bound&#34;],
                ]
                for inst in instances
            ]
        )
        y_true_lb, y_true_ub = y_true[:, 0], y_true[:, 1]
        y_pred_lb, y_pred_ub = y_pred[:, 1], y_pred[:, 1]
        ev = {
            &#34;Lower bound&#34;: {
                &#34;Mean squared error&#34;: mean_squared_error(y_true_lb, y_pred_lb),
                &#34;Explained variance&#34;: explained_variance_score(y_true_lb, y_pred_lb),
                &#34;Max error&#34;: max_error(y_true_lb, y_pred_lb),
                &#34;Mean absolute error&#34;: mean_absolute_error(y_true_lb, y_pred_lb),
                &#34;R2&#34;: r2_score(y_true_lb, y_pred_lb),
                &#34;Median absolute error&#34;: mean_absolute_error(y_true_lb, y_pred_lb),
            },
            &#34;Upper bound&#34;: {
                &#34;Mean squared error&#34;: mean_squared_error(y_true_ub, y_pred_ub),
                &#34;Explained variance&#34;: explained_variance_score(y_true_ub, y_pred_ub),
                &#34;Max error&#34;: max_error(y_true_ub, y_pred_ub),
                &#34;Mean absolute error&#34;: mean_absolute_error(y_true_ub, y_pred_ub),
                &#34;R2&#34;: r2_score(y_true_ub, y_pred_ub),
                &#34;Median absolute error&#34;: mean_absolute_error(y_true_ub, y_pred_ub),
            },
        }
        return ev</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.components.component.Component" href="component.html#miplearn.components.component.Component">Component</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.components.objective.ObjectiveValueComponent.evaluate"><code class="name flex">
 <span>def <span class="ident">evaluate</span></span>(<span>self, instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def evaluate(self, instances):
    y_pred = self.predict(instances)
    y_true = np.array(
        [
            [
                inst.training_data[0][&#34;Lower bound&#34;],
                inst.training_data[0][&#34;Upper bound&#34;],
            ]
            for inst in instances
        ]
    )
    y_true_lb, y_true_ub = y_true[:, 0], y_true[:, 1]
    y_pred_lb, y_pred_ub = y_pred[:, 1], y_pred[:, 1]
    ev = {
        &#34;Lower bound&#34;: {
            &#34;Mean squared error&#34;: mean_squared_error(y_true_lb, y_pred_lb),
            &#34;Explained variance&#34;: explained_variance_score(y_true_lb, y_pred_lb),
            &#34;Max error&#34;: max_error(y_true_lb, y_pred_lb),
            &#34;Mean absolute error&#34;: mean_absolute_error(y_true_lb, y_pred_lb),
            &#34;R2&#34;: r2_score(y_true_lb, y_pred_lb),
            &#34;Median absolute error&#34;: mean_absolute_error(y_true_lb, y_pred_lb),
        },
        &#34;Upper bound&#34;: {
            &#34;Mean squared error&#34;: mean_squared_error(y_true_ub, y_pred_ub),
            &#34;Explained variance&#34;: explained_variance_score(y_true_ub, y_pred_ub),
            &#34;Max error&#34;: max_error(y_true_ub, y_pred_ub),
            &#34;Mean absolute error&#34;: mean_absolute_error(y_true_ub, y_pred_ub),
            &#34;R2&#34;: r2_score(y_true_ub, y_pred_ub),
            &#34;Median absolute error&#34;: mean_absolute_error(y_true_ub, y_pred_ub),
        },
    }
    return ev</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.objective.ObjectiveValueComponent.fit"><code class="name flex">
 <span>def <span class="ident">fit</span></span>(<span>self, training_instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def fit(self, training_instances):
    logger.debug(&#34;Extracting features...&#34;)
    features = InstanceFeaturesExtractor().extract(training_instances)
    ub = ObjectiveValueExtractor(kind=&#34;upper bound&#34;).extract(training_instances)
    lb = ObjectiveValueExtractor(kind=&#34;lower bound&#34;).extract(training_instances)
    assert ub.shape == (len(training_instances), 1)
    assert lb.shape == (len(training_instances), 1)
    self.ub_regressor = deepcopy(self.regressor_prototype)
    self.lb_regressor = deepcopy(self.regressor_prototype)
    logger.debug(&#34;Fitting ub_regressor...&#34;)
    self.ub_regressor.fit(features, ub.ravel())
    logger.debug(&#34;Fitting ub_regressor...&#34;)
    self.lb_regressor.fit(features, lb.ravel())</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.objective.ObjectiveValueComponent.predict"><code class="name flex">
 <span>def <span class="ident">predict</span></span>(<span>self, instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def predict(self, instances):
    features = InstanceFeaturesExtractor().extract(instances)
    lb = self.lb_regressor.predict(features)
    ub = self.ub_regressor.predict(features)
    assert lb.shape == (len(instances),)
    assert ub.shape == (len(instances),)
    return np.array([lb, ub]).T</code></pre>
 </details>
 </dd>
 </dl>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.components.component.Component" href="component.html#miplearn.components.component.Component">Component</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.components.component.Component.after_solve" href="component.html#miplearn.components.component.Component.after_solve">after_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.before_solve" href="component.html#miplearn.components.component.Component.before_solve">before_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.iteration_cb" href="component.html#miplearn.components.component.Component.iteration_cb">iteration_cb</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.components" href="index.html">miplearn.components</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.components.objective.ObjectiveValueComponent" href="#miplearn.components.objective.ObjectiveValueComponent">ObjectiveValueComponent</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.components.objective.ObjectiveValueComponent.evaluate" href="#miplearn.components.objective.ObjectiveValueComponent.evaluate">evaluate</a></code></li>
 <li><code><a title="miplearn.components.objective.ObjectiveValueComponent.fit" href="#miplearn.components.objective.ObjectiveValueComponent.fit">fit</a></code></li>
 <li><code><a title="miplearn.components.objective.ObjectiveValueComponent.predict" href="#miplearn.components.objective.ObjectiveValueComponent.predict">predict</a></code></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/components/primal.html
+++ b/0.2/api/miplearn/components/primal.html
@ -1,610 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.components.primal API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.components.primal</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import logging
 from copy import deepcopy
 from typing import Union, Dict, Any
 import numpy as np
 from tqdm.auto import tqdm
 from miplearn.classifiers import Classifier
 from miplearn.classifiers.adaptive import AdaptiveClassifier
 from miplearn.classifiers.threshold import MinPrecisionThreshold, DynamicThreshold
 from miplearn.components import classifier_evaluation_dict
 from miplearn.components.component import Component
 from miplearn.extractors import VariableFeaturesExtractor, SolutionExtractor, Extractor
 logger = logging.getLogger(__name__)
 class PrimalSolutionComponent(Component):
    &#34;&#34;&#34;
    A component that predicts primal solutions.
    &#34;&#34;&#34;
    def __init__(
        self,
        classifier: Classifier = AdaptiveClassifier(),
        mode: str = &#34;exact&#34;,
        threshold: Union[float, DynamicThreshold] = MinPrecisionThreshold(0.98),
    ) -&gt; None:
        self.mode = mode
        self.classifiers: Dict[Any, Classifier] = {}
        self.thresholds: Dict[Any, Union[float, DynamicThreshold]] = {}
        self.threshold_prototype = threshold
        self.classifier_prototype = classifier
    def before_solve(self, solver, instance, model):
        logger.info(&#34;Predicting primal solution...&#34;)
        solution = self.predict(instance)
        if self.mode == &#34;heuristic&#34;:
            solver.internal_solver.fix(solution)
        else:
            solver.internal_solver.set_warm_start(solution)
    def after_solve(
        self,
        solver,
        instance,
        model,
        stats,
        training_data,
    ):
        pass
    def x(self, training_instances):
        return VariableFeaturesExtractor().extract(training_instances)
    def y(self, training_instances):
        return SolutionExtractor().extract(training_instances)
    def fit(self, training_instances, n_jobs=1):
        logger.debug(&#34;Extracting features...&#34;)
        features = VariableFeaturesExtractor().extract(training_instances)
        solutions = SolutionExtractor().extract(training_instances)
        for category in tqdm(
            features.keys(),
            desc=&#34;Fit (primal)&#34;,
        ):
            x_train = features[category]
            for label in [0, 1]:
                y_train = solutions[category][:, label].astype(int)
                # If all samples are either positive or negative, make constant
                # predictions
                y_avg = np.average(y_train)
                if y_avg &lt; 0.001 or y_avg &gt;= 0.999:
                    self.classifiers[category, label] = round(y_avg)
                    self.thresholds[category, label] = 0.50
                    continue
                # Create a copy of classifier prototype and train it
                if isinstance(self.classifier_prototype, list):
                    clf = deepcopy(self.classifier_prototype[label])
                else:
                    clf = deepcopy(self.classifier_prototype)
                clf.fit(x_train, y_train)
                # Find threshold (dynamic or static)
                if isinstance(self.threshold_prototype, DynamicThreshold):
                    self.thresholds[category, label] = self.threshold_prototype.find(
                        clf,
                        x_train,
                        y_train,
                    )
                else:
                    self.thresholds[category, label] = deepcopy(
                        self.threshold_prototype
                    )
                self.classifiers[category, label] = clf
    def predict(self, instance):
        solution = {}
        x_test = VariableFeaturesExtractor().extract([instance])
        var_split = Extractor.split_variables(instance)
        for category in var_split.keys():
            n = len(var_split[category])
            for (i, (var, index)) in enumerate(var_split[category]):
                if var not in solution.keys():
                    solution[var] = {}
                solution[var][index] = None
            for label in [0, 1]:
                if (category, label) not in self.classifiers.keys():
                    continue
                clf = self.classifiers[category, label]
                if isinstance(clf, float) or isinstance(clf, int):
                    ws = np.array([[1 - clf, clf] for _ in range(n)])
                else:
                    ws = clf.predict_proba(x_test[category])
                assert ws.shape == (n, 2), &#34;ws.shape should be (%d, 2) not %s&#34; % (
                    n,
                    ws.shape,
                )
                for (i, (var, index)) in enumerate(var_split[category]):
                    if ws[i, 1] &gt;= self.thresholds[category, label]:
                        solution[var][index] = label
        return solution
    def evaluate(self, instances):
        ev = {&#34;Fix zero&#34;: {}, &#34;Fix one&#34;: {}}
        for instance_idx in tqdm(
            range(len(instances)),
            desc=&#34;Evaluate (primal)&#34;,
        ):
            instance = instances[instance_idx]
            solution_actual = instance.training_data[0][&#34;Solution&#34;]
            solution_pred = self.predict(instance)
            vars_all, vars_one, vars_zero = set(), set(), set()
            pred_one_positive, pred_zero_positive = set(), set()
            for (varname, var_dict) in solution_actual.items():
                if varname not in solution_pred.keys():
                    continue
                for (idx, value) in var_dict.items():
                    vars_all.add((varname, idx))
                    if value &gt; 0.5:
                        vars_one.add((varname, idx))
                    else:
                        vars_zero.add((varname, idx))
                    if solution_pred[varname][idx] is not None:
                        if solution_pred[varname][idx] &gt; 0.5:
                            pred_one_positive.add((varname, idx))
                        else:
                            pred_zero_positive.add((varname, idx))
            pred_one_negative = vars_all - pred_one_positive
            pred_zero_negative = vars_all - pred_zero_positive
            tp_zero = len(pred_zero_positive &amp; vars_zero)
            fp_zero = len(pred_zero_positive &amp; vars_one)
            tn_zero = len(pred_zero_negative &amp; vars_one)
            fn_zero = len(pred_zero_negative &amp; vars_zero)
            tp_one = len(pred_one_positive &amp; vars_one)
            fp_one = len(pred_one_positive &amp; vars_zero)
            tn_one = len(pred_one_negative &amp; vars_zero)
            fn_one = len(pred_one_negative &amp; vars_one)
            ev[&#34;Fix zero&#34;][instance_idx] = classifier_evaluation_dict(
                tp_zero, tn_zero, fp_zero, fn_zero
            )
            ev[&#34;Fix one&#34;][instance_idx] = classifier_evaluation_dict(
                tp_one, tn_one, fp_one, fn_one
            )
        return ev</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.components.primal.PrimalSolutionComponent"><code class="flex name class">
 <span>class <span class="ident">PrimalSolutionComponent</span></span>
 <span>(</span><span>classifier=&lt;miplearn.classifiers.adaptive.AdaptiveClassifier object&gt;, mode='exact', threshold=&lt;miplearn.classifiers.threshold.MinPrecisionThreshold object&gt;)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>A component that predicts primal solutions.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class PrimalSolutionComponent(Component):
    &#34;&#34;&#34;
    A component that predicts primal solutions.
    &#34;&#34;&#34;
    def __init__(
        self,
        classifier: Classifier = AdaptiveClassifier(),
        mode: str = &#34;exact&#34;,
        threshold: Union[float, DynamicThreshold] = MinPrecisionThreshold(0.98),
    ) -&gt; None:
        self.mode = mode
        self.classifiers: Dict[Any, Classifier] = {}
        self.thresholds: Dict[Any, Union[float, DynamicThreshold]] = {}
        self.threshold_prototype = threshold
        self.classifier_prototype = classifier
    def before_solve(self, solver, instance, model):
        logger.info(&#34;Predicting primal solution...&#34;)
        solution = self.predict(instance)
        if self.mode == &#34;heuristic&#34;:
            solver.internal_solver.fix(solution)
        else:
            solver.internal_solver.set_warm_start(solution)
    def after_solve(
        self,
        solver,
        instance,
        model,
        stats,
        training_data,
    ):
        pass
    def x(self, training_instances):
        return VariableFeaturesExtractor().extract(training_instances)
    def y(self, training_instances):
        return SolutionExtractor().extract(training_instances)
    def fit(self, training_instances, n_jobs=1):
        logger.debug(&#34;Extracting features...&#34;)
        features = VariableFeaturesExtractor().extract(training_instances)
        solutions = SolutionExtractor().extract(training_instances)
        for category in tqdm(
            features.keys(),
            desc=&#34;Fit (primal)&#34;,
        ):
            x_train = features[category]
            for label in [0, 1]:
                y_train = solutions[category][:, label].astype(int)
                # If all samples are either positive or negative, make constant
                # predictions
                y_avg = np.average(y_train)
                if y_avg &lt; 0.001 or y_avg &gt;= 0.999:
                    self.classifiers[category, label] = round(y_avg)
                    self.thresholds[category, label] = 0.50
                    continue
                # Create a copy of classifier prototype and train it
                if isinstance(self.classifier_prototype, list):
                    clf = deepcopy(self.classifier_prototype[label])
                else:
                    clf = deepcopy(self.classifier_prototype)
                clf.fit(x_train, y_train)
                # Find threshold (dynamic or static)
                if isinstance(self.threshold_prototype, DynamicThreshold):
                    self.thresholds[category, label] = self.threshold_prototype.find(
                        clf,
                        x_train,
                        y_train,
                    )
                else:
                    self.thresholds[category, label] = deepcopy(
                        self.threshold_prototype
                    )
                self.classifiers[category, label] = clf
    def predict(self, instance):
        solution = {}
        x_test = VariableFeaturesExtractor().extract([instance])
        var_split = Extractor.split_variables(instance)
        for category in var_split.keys():
            n = len(var_split[category])
            for (i, (var, index)) in enumerate(var_split[category]):
                if var not in solution.keys():
                    solution[var] = {}
                solution[var][index] = None
            for label in [0, 1]:
                if (category, label) not in self.classifiers.keys():
                    continue
                clf = self.classifiers[category, label]
                if isinstance(clf, float) or isinstance(clf, int):
                    ws = np.array([[1 - clf, clf] for _ in range(n)])
                else:
                    ws = clf.predict_proba(x_test[category])
                assert ws.shape == (n, 2), &#34;ws.shape should be (%d, 2) not %s&#34; % (
                    n,
                    ws.shape,
                )
                for (i, (var, index)) in enumerate(var_split[category]):
                    if ws[i, 1] &gt;= self.thresholds[category, label]:
                        solution[var][index] = label
        return solution
    def evaluate(self, instances):
        ev = {&#34;Fix zero&#34;: {}, &#34;Fix one&#34;: {}}
        for instance_idx in tqdm(
            range(len(instances)),
            desc=&#34;Evaluate (primal)&#34;,
        ):
            instance = instances[instance_idx]
            solution_actual = instance.training_data[0][&#34;Solution&#34;]
            solution_pred = self.predict(instance)
            vars_all, vars_one, vars_zero = set(), set(), set()
            pred_one_positive, pred_zero_positive = set(), set()
            for (varname, var_dict) in solution_actual.items():
                if varname not in solution_pred.keys():
                    continue
                for (idx, value) in var_dict.items():
                    vars_all.add((varname, idx))
                    if value &gt; 0.5:
                        vars_one.add((varname, idx))
                    else:
                        vars_zero.add((varname, idx))
                    if solution_pred[varname][idx] is not None:
                        if solution_pred[varname][idx] &gt; 0.5:
                            pred_one_positive.add((varname, idx))
                        else:
                            pred_zero_positive.add((varname, idx))
            pred_one_negative = vars_all - pred_one_positive
            pred_zero_negative = vars_all - pred_zero_positive
            tp_zero = len(pred_zero_positive &amp; vars_zero)
            fp_zero = len(pred_zero_positive &amp; vars_one)
            tn_zero = len(pred_zero_negative &amp; vars_one)
            fn_zero = len(pred_zero_negative &amp; vars_zero)
            tp_one = len(pred_one_positive &amp; vars_one)
            fp_one = len(pred_one_positive &amp; vars_zero)
            tn_one = len(pred_one_negative &amp; vars_zero)
            fn_one = len(pred_one_negative &amp; vars_one)
            ev[&#34;Fix zero&#34;][instance_idx] = classifier_evaluation_dict(
                tp_zero, tn_zero, fp_zero, fn_zero
            )
            ev[&#34;Fix one&#34;][instance_idx] = classifier_evaluation_dict(
                tp_one, tn_one, fp_one, fn_one
            )
        return ev</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.components.component.Component" href="component.html#miplearn.components.component.Component">Component</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.components.primal.PrimalSolutionComponent.evaluate"><code class="name flex">
 <span>def <span class="ident">evaluate</span></span>(<span>self, instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def evaluate(self, instances):
    ev = {&#34;Fix zero&#34;: {}, &#34;Fix one&#34;: {}}
    for instance_idx in tqdm(
        range(len(instances)),
        desc=&#34;Evaluate (primal)&#34;,
    ):
        instance = instances[instance_idx]
        solution_actual = instance.training_data[0][&#34;Solution&#34;]
        solution_pred = self.predict(instance)
        vars_all, vars_one, vars_zero = set(), set(), set()
        pred_one_positive, pred_zero_positive = set(), set()
        for (varname, var_dict) in solution_actual.items():
            if varname not in solution_pred.keys():
                continue
            for (idx, value) in var_dict.items():
                vars_all.add((varname, idx))
                if value &gt; 0.5:
                    vars_one.add((varname, idx))
                else:
                    vars_zero.add((varname, idx))
                if solution_pred[varname][idx] is not None:
                    if solution_pred[varname][idx] &gt; 0.5:
                        pred_one_positive.add((varname, idx))
                    else:
                        pred_zero_positive.add((varname, idx))
        pred_one_negative = vars_all - pred_one_positive
        pred_zero_negative = vars_all - pred_zero_positive
        tp_zero = len(pred_zero_positive &amp; vars_zero)
        fp_zero = len(pred_zero_positive &amp; vars_one)
        tn_zero = len(pred_zero_negative &amp; vars_one)
        fn_zero = len(pred_zero_negative &amp; vars_zero)
        tp_one = len(pred_one_positive &amp; vars_one)
        fp_one = len(pred_one_positive &amp; vars_zero)
        tn_one = len(pred_one_negative &amp; vars_zero)
        fn_one = len(pred_one_negative &amp; vars_one)
        ev[&#34;Fix zero&#34;][instance_idx] = classifier_evaluation_dict(
            tp_zero, tn_zero, fp_zero, fn_zero
        )
        ev[&#34;Fix one&#34;][instance_idx] = classifier_evaluation_dict(
            tp_one, tn_one, fp_one, fn_one
        )
    return ev</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.primal.PrimalSolutionComponent.fit"><code class="name flex">
 <span>def <span class="ident">fit</span></span>(<span>self, training_instances, n_jobs=1)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def fit(self, training_instances, n_jobs=1):
    logger.debug(&#34;Extracting features...&#34;)
    features = VariableFeaturesExtractor().extract(training_instances)
    solutions = SolutionExtractor().extract(training_instances)
    for category in tqdm(
        features.keys(),
        desc=&#34;Fit (primal)&#34;,
    ):
        x_train = features[category]
        for label in [0, 1]:
            y_train = solutions[category][:, label].astype(int)
            # If all samples are either positive or negative, make constant
            # predictions
            y_avg = np.average(y_train)
            if y_avg &lt; 0.001 or y_avg &gt;= 0.999:
                self.classifiers[category, label] = round(y_avg)
                self.thresholds[category, label] = 0.50
                continue
            # Create a copy of classifier prototype and train it
            if isinstance(self.classifier_prototype, list):
                clf = deepcopy(self.classifier_prototype[label])
            else:
                clf = deepcopy(self.classifier_prototype)
            clf.fit(x_train, y_train)
            # Find threshold (dynamic or static)
            if isinstance(self.threshold_prototype, DynamicThreshold):
                self.thresholds[category, label] = self.threshold_prototype.find(
                    clf,
                    x_train,
                    y_train,
                )
            else:
                self.thresholds[category, label] = deepcopy(
                    self.threshold_prototype
                )
            self.classifiers[category, label] = clf</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.primal.PrimalSolutionComponent.predict"><code class="name flex">
 <span>def <span class="ident">predict</span></span>(<span>self, instance)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def predict(self, instance):
    solution = {}
    x_test = VariableFeaturesExtractor().extract([instance])
    var_split = Extractor.split_variables(instance)
    for category in var_split.keys():
        n = len(var_split[category])
        for (i, (var, index)) in enumerate(var_split[category]):
            if var not in solution.keys():
                solution[var] = {}
            solution[var][index] = None
        for label in [0, 1]:
            if (category, label) not in self.classifiers.keys():
                continue
            clf = self.classifiers[category, label]
            if isinstance(clf, float) or isinstance(clf, int):
                ws = np.array([[1 - clf, clf] for _ in range(n)])
            else:
                ws = clf.predict_proba(x_test[category])
            assert ws.shape == (n, 2), &#34;ws.shape should be (%d, 2) not %s&#34; % (
                n,
                ws.shape,
            )
            for (i, (var, index)) in enumerate(var_split[category]):
                if ws[i, 1] &gt;= self.thresholds[category, label]:
                    solution[var][index] = label
    return solution</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.primal.PrimalSolutionComponent.x"><code class="name flex">
 <span>def <span class="ident">x</span></span>(<span>self, training_instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def x(self, training_instances):
    return VariableFeaturesExtractor().extract(training_instances)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.primal.PrimalSolutionComponent.y"><code class="name flex">
 <span>def <span class="ident">y</span></span>(<span>self, training_instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def y(self, training_instances):
    return SolutionExtractor().extract(training_instances)</code></pre>
 </details>
 </dd>
 </dl>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.components.component.Component" href="component.html#miplearn.components.component.Component">Component</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.components.component.Component.after_solve" href="component.html#miplearn.components.component.Component.after_solve">after_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.before_solve" href="component.html#miplearn.components.component.Component.before_solve">before_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.iteration_cb" href="component.html#miplearn.components.component.Component.iteration_cb">iteration_cb</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.components" href="index.html">miplearn.components</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.components.primal.PrimalSolutionComponent" href="#miplearn.components.primal.PrimalSolutionComponent">PrimalSolutionComponent</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.components.primal.PrimalSolutionComponent.evaluate" href="#miplearn.components.primal.PrimalSolutionComponent.evaluate">evaluate</a></code></li>
 <li><code><a title="miplearn.components.primal.PrimalSolutionComponent.fit" href="#miplearn.components.primal.PrimalSolutionComponent.fit">fit</a></code></li>
 <li><code><a title="miplearn.components.primal.PrimalSolutionComponent.predict" href="#miplearn.components.primal.PrimalSolutionComponent.predict">predict</a></code></li>
 <li><code><a title="miplearn.components.primal.PrimalSolutionComponent.x" href="#miplearn.components.primal.PrimalSolutionComponent.x">x</a></code></li>
 <li><code><a title="miplearn.components.primal.PrimalSolutionComponent.y" href="#miplearn.components.primal.PrimalSolutionComponent.y">y</a></code></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/components/relaxation.html
+++ b/0.2/api/miplearn/components/relaxation.html
@ -1,326 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.components.relaxation API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.components.relaxation</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import logging
 from miplearn.classifiers.counting import CountingClassifier
 from miplearn.components.component import Component
 from miplearn.components.composite import CompositeComponent
 from miplearn.components.steps.convert_tight import ConvertTightIneqsIntoEqsStep
 from miplearn.components.steps.drop_redundant import DropRedundantInequalitiesStep
 from miplearn.components.steps.relax_integrality import RelaxIntegralityStep
 logger = logging.getLogger(__name__)
 class RelaxationComponent(Component):
    &#34;&#34;&#34;
    A Component that tries to build a relaxation that is simultaneously strong and easy
    to solve. Currently, this component is composed by three steps:
    - RelaxIntegralityStep
    - DropRedundantInequalitiesStep
    - ConvertTightIneqsIntoEqsStep
    Parameters
    ----------
    redundant_classifier : Classifier, optional
        Classifier used to predict if a constraint is likely redundant. One deep
        copy of this classifier is made for each constraint category.
    redundant_threshold : float, optional
        If the probability that a constraint is redundant exceeds this threshold, the
        constraint is dropped from the linear relaxation.
    tight_classifier : Classifier, optional
        Classifier used to predict if a constraint is likely to be tight. One deep
        copy of this classifier is made for each constraint category.
    tight_threshold : float, optional
        If the probability that a constraint is tight exceeds this threshold, the
        constraint is converted into an equality constraint.
    slack_tolerance : float, optional
        If a constraint has slack greater than this threshold, then the constraint is
        considered loose. By default, this threshold equals a small positive number to
        compensate for numerical issues.
    check_feasibility : bool, optional
        If true, after the problem is solved, the component verifies that all dropped
        constraints are still satisfied, re-adds the violated ones and resolves the
        problem. This loop continues until either no violations are found, or a maximum
        number of iterations is reached.
    violation_tolerance : float, optional
        If `check_dropped` is true, a constraint is considered satisfied during the
        check if its violation is smaller than this tolerance.
    max_check_iterations : int
        If `check_dropped` is true, set the maximum number of iterations in the lazy
        constraint loop.
    &#34;&#34;&#34;
    def __init__(
        self,
        redundant_classifier=CountingClassifier(),
        redundant_threshold=0.95,
        tight_classifier=CountingClassifier(),
        tight_threshold=0.95,
        slack_tolerance=1e-5,
        check_feasibility=False,
        violation_tolerance=1e-5,
        max_check_iterations=3,
    ):
        self.steps = [
            RelaxIntegralityStep(),
            DropRedundantInequalitiesStep(
                classifier=redundant_classifier,
                threshold=redundant_threshold,
                slack_tolerance=slack_tolerance,
                violation_tolerance=violation_tolerance,
                max_iterations=max_check_iterations,
                check_feasibility=check_feasibility,
            ),
            ConvertTightIneqsIntoEqsStep(
                classifier=tight_classifier,
                threshold=tight_threshold,
                slack_tolerance=slack_tolerance,
            ),
        ]
        self.composite = CompositeComponent(self.steps)
    def before_solve(self, solver, instance, model):
        self.composite.before_solve(solver, instance, model)
    def after_solve(self, solver, instance, model, stats, training_data):
        self.composite.after_solve(solver, instance, model, stats, training_data)
    def fit(self, training_instances):
        self.composite.fit(training_instances)
    def iteration_cb(self, solver, instance, model):
        return self.composite.iteration_cb(solver, instance, model)</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.components.relaxation.RelaxationComponent"><code class="flex name class">
 <span>class <span class="ident">RelaxationComponent</span></span>
 <span>(</span><span>redundant_classifier=CountingClassifier(mean=None), redundant_threshold=0.95, tight_classifier=CountingClassifier(mean=None), tight_threshold=0.95, slack_tolerance=1e-05, check_feasibility=False, violation_tolerance=1e-05, max_check_iterations=3)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>A Component that tries to build a relaxation that is simultaneously strong and easy
 to solve. Currently, this component is composed by three steps:</p>
 <ul>
 <li>RelaxIntegralityStep</li>
 <li>DropRedundantInequalitiesStep</li>
 <li>ConvertTightIneqsIntoEqsStep</li>
 </ul>
 <h2 id="parameters">Parameters</h2>
 <dl>
 <dt><strong><code>redundant_classifier</code></strong> :&ensp;<code>Classifier</code>, optional</dt>
 <dd>Classifier used to predict if a constraint is likely redundant. One deep
 copy of this classifier is made for each constraint category.</dd>
 <dt><strong><code>redundant_threshold</code></strong> :&ensp;<code>float</code>, optional</dt>
 <dd>If the probability that a constraint is redundant exceeds this threshold, the
 constraint is dropped from the linear relaxation.</dd>
 <dt><strong><code>tight_classifier</code></strong> :&ensp;<code>Classifier</code>, optional</dt>
 <dd>Classifier used to predict if a constraint is likely to be tight. One deep
 copy of this classifier is made for each constraint category.</dd>
 <dt><strong><code>tight_threshold</code></strong> :&ensp;<code>float</code>, optional</dt>
 <dd>If the probability that a constraint is tight exceeds this threshold, the
 constraint is converted into an equality constraint.</dd>
 <dt><strong><code>slack_tolerance</code></strong> :&ensp;<code>float</code>, optional</dt>
 <dd>If a constraint has slack greater than this threshold, then the constraint is
 considered loose. By default, this threshold equals a small positive number to
 compensate for numerical issues.</dd>
 <dt><strong><code>check_feasibility</code></strong> :&ensp;<code>bool</code>, optional</dt>
 <dd>If true, after the problem is solved, the component verifies that all dropped
 constraints are still satisfied, re-adds the violated ones and resolves the
 problem. This loop continues until either no violations are found, or a maximum
 number of iterations is reached.</dd>
 <dt><strong><code>violation_tolerance</code></strong> :&ensp;<code>float</code>, optional</dt>
 <dd>If <code>check_dropped</code> is true, a constraint is considered satisfied during the
 check if its violation is smaller than this tolerance.</dd>
 <dt><strong><code>max_check_iterations</code></strong> :&ensp;<code>int</code></dt>
 <dd>If <code>check_dropped</code> is true, set the maximum number of iterations in the lazy
 constraint loop.</dd>
 </dl></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class RelaxationComponent(Component):
    &#34;&#34;&#34;
    A Component that tries to build a relaxation that is simultaneously strong and easy
    to solve. Currently, this component is composed by three steps:
    - RelaxIntegralityStep
    - DropRedundantInequalitiesStep
    - ConvertTightIneqsIntoEqsStep
    Parameters
    ----------
    redundant_classifier : Classifier, optional
        Classifier used to predict if a constraint is likely redundant. One deep
        copy of this classifier is made for each constraint category.
    redundant_threshold : float, optional
        If the probability that a constraint is redundant exceeds this threshold, the
        constraint is dropped from the linear relaxation.
    tight_classifier : Classifier, optional
        Classifier used to predict if a constraint is likely to be tight. One deep
        copy of this classifier is made for each constraint category.
    tight_threshold : float, optional
        If the probability that a constraint is tight exceeds this threshold, the
        constraint is converted into an equality constraint.
    slack_tolerance : float, optional
        If a constraint has slack greater than this threshold, then the constraint is
        considered loose. By default, this threshold equals a small positive number to
        compensate for numerical issues.
    check_feasibility : bool, optional
        If true, after the problem is solved, the component verifies that all dropped
        constraints are still satisfied, re-adds the violated ones and resolves the
        problem. This loop continues until either no violations are found, or a maximum
        number of iterations is reached.
    violation_tolerance : float, optional
        If `check_dropped` is true, a constraint is considered satisfied during the
        check if its violation is smaller than this tolerance.
    max_check_iterations : int
        If `check_dropped` is true, set the maximum number of iterations in the lazy
        constraint loop.
    &#34;&#34;&#34;
    def __init__(
        self,
        redundant_classifier=CountingClassifier(),
        redundant_threshold=0.95,
        tight_classifier=CountingClassifier(),
        tight_threshold=0.95,
        slack_tolerance=1e-5,
        check_feasibility=False,
        violation_tolerance=1e-5,
        max_check_iterations=3,
    ):
        self.steps = [
            RelaxIntegralityStep(),
            DropRedundantInequalitiesStep(
                classifier=redundant_classifier,
                threshold=redundant_threshold,
                slack_tolerance=slack_tolerance,
                violation_tolerance=violation_tolerance,
                max_iterations=max_check_iterations,
                check_feasibility=check_feasibility,
            ),
            ConvertTightIneqsIntoEqsStep(
                classifier=tight_classifier,
                threshold=tight_threshold,
                slack_tolerance=slack_tolerance,
            ),
        ]
        self.composite = CompositeComponent(self.steps)
    def before_solve(self, solver, instance, model):
        self.composite.before_solve(solver, instance, model)
    def after_solve(self, solver, instance, model, stats, training_data):
        self.composite.after_solve(solver, instance, model, stats, training_data)
    def fit(self, training_instances):
        self.composite.fit(training_instances)
    def iteration_cb(self, solver, instance, model):
        return self.composite.iteration_cb(solver, instance, model)</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.components.component.Component" href="component.html#miplearn.components.component.Component">Component</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.components.relaxation.RelaxationComponent.fit"><code class="name flex">
 <span>def <span class="ident">fit</span></span>(<span>self, training_instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def fit(self, training_instances):
    self.composite.fit(training_instances)</code></pre>
 </details>
 </dd>
 </dl>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.components.component.Component" href="component.html#miplearn.components.component.Component">Component</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.components.component.Component.after_solve" href="component.html#miplearn.components.component.Component.after_solve">after_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.before_solve" href="component.html#miplearn.components.component.Component.before_solve">before_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.iteration_cb" href="component.html#miplearn.components.component.Component.iteration_cb">iteration_cb</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.components" href="index.html">miplearn.components</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.components.relaxation.RelaxationComponent" href="#miplearn.components.relaxation.RelaxationComponent">RelaxationComponent</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.components.relaxation.RelaxationComponent.fit" href="#miplearn.components.relaxation.RelaxationComponent.fit">fit</a></code></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/components/steps/convert_tight.html
+++ b/0.2/api/miplearn/components/steps/convert_tight.html
@ -1,635 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.components.steps.convert_tight API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.components.steps.convert_tight</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import logging
 import random
 from copy import deepcopy
 import numpy as np
 from tqdm import tqdm
 from miplearn.classifiers.counting import CountingClassifier
 from miplearn.components import classifier_evaluation_dict
 from miplearn.components.component import Component
 from miplearn.components.steps.drop_redundant import DropRedundantInequalitiesStep
 from miplearn.extractors import InstanceIterator
 logger = logging.getLogger(__name__)
 class ConvertTightIneqsIntoEqsStep(Component):
    &#34;&#34;&#34;
    Component that predicts which inequality constraints are likely to be binding in
    the LP relaxation of the problem and converts them into equality constraints.
    This component always makes sure that the conversion process does not affect the
    feasibility of the problem. It can also, optionally, make sure that it does not affect
    the optimality, but this may be expensive.
    This component does not work on MIPs. All integrality constraints must be relaxed
    before this component is used.
    &#34;&#34;&#34;
    def __init__(
        self,
        classifier=CountingClassifier(),
        threshold=0.95,
        slack_tolerance=0.0,
        check_optimality=False,
    ):
        self.classifiers = {}
        self.classifier_prototype = classifier
        self.threshold = threshold
        self.slack_tolerance = slack_tolerance
        self.check_optimality = check_optimality
        self.converted = []
        self.original_sense = {}
    def before_solve(self, solver, instance, _):
        logger.info(&#34;Predicting tight LP constraints...&#34;)
        x, constraints = DropRedundantInequalitiesStep._x_test(
            instance,
            constraint_ids=solver.internal_solver.get_constraint_ids(),
        )
        y = self.predict(x)
        self.n_converted = 0
        self.n_restored = 0
        self.n_kept = 0
        self.n_infeasible_iterations = 0
        self.n_suboptimal_iterations = 0
        for category in y.keys():
            for i in range(len(y[category])):
                if y[category][i][0] == 1:
                    cid = constraints[category][i]
                    s = solver.internal_solver.get_constraint_sense(cid)
                    self.original_sense[cid] = s
                    solver.internal_solver.set_constraint_sense(cid, &#34;=&#34;)
                    self.converted += [cid]
                    self.n_converted += 1
                else:
                    self.n_kept += 1
        logger.info(f&#34;Converted {self.n_converted} inequalities&#34;)
    def after_solve(
        self,
        solver,
        instance,
        model,
        stats,
        training_data,
    ):
        if &#34;slacks&#34; not in training_data.keys():
            training_data[&#34;slacks&#34;] = solver.internal_solver.get_inequality_slacks()
        stats[&#34;ConvertTight: Kept&#34;] = self.n_kept
        stats[&#34;ConvertTight: Converted&#34;] = self.n_converted
        stats[&#34;ConvertTight: Restored&#34;] = self.n_restored
        stats[&#34;ConvertTight: Inf iterations&#34;] = self.n_infeasible_iterations
        stats[&#34;ConvertTight: Subopt iterations&#34;] = self.n_suboptimal_iterations
    def fit(self, training_instances):
        logger.debug(&#34;Extracting x and y...&#34;)
        x = self.x(training_instances)
        y = self.y(training_instances)
        logger.debug(&#34;Fitting...&#34;)
        for category in tqdm(x.keys(), desc=&#34;Fit (rlx:conv_ineqs)&#34;):
            if category not in self.classifiers:
                self.classifiers[category] = deepcopy(self.classifier_prototype)
            self.classifiers[category].fit(x[category], y[category])
    def x(self, instances):
        return DropRedundantInequalitiesStep._x_train(instances)
    def y(self, instances):
        y = {}
        for instance in tqdm(
            InstanceIterator(instances),
            desc=&#34;Extract (rlx:conv_ineqs:y)&#34;,
            disable=len(instances) &lt; 5,
        ):
            for (cid, slack) in instance.training_data[0][&#34;slacks&#34;].items():
                category = instance.get_constraint_category(cid)
                if category is None:
                    continue
                if category not in y:
                    y[category] = []
                if 0 &lt;= slack &lt;= self.slack_tolerance:
                    y[category] += [[1]]
                else:
                    y[category] += [[0]]
        return y
    def predict(self, x):
        y = {}
        for (category, x_cat) in x.items():
            if category not in self.classifiers:
                continue
            y[category] = []
            x_cat = np.array(x_cat)
            proba = self.classifiers[category].predict_proba(x_cat)
            for i in range(len(proba)):
                if proba[i][1] &gt;= self.threshold:
                    y[category] += [[1]]
                else:
                    y[category] += [[0]]
        return y
    def evaluate(self, instance):
        x = self.x([instance])
        y_true = self.y([instance])
        y_pred = self.predict(x)
        tp, tn, fp, fn = 0, 0, 0, 0
        for category in y_true.keys():
            for i in range(len(y_true[category])):
                if y_pred[category][i][0] == 1:
                    if y_true[category][i][0] == 1:
                        tp += 1
                    else:
                        fp += 1
                else:
                    if y_true[category][i][0] == 1:
                        fn += 1
                    else:
                        tn += 1
        return classifier_evaluation_dict(tp, tn, fp, fn)
    def iteration_cb(self, solver, instance, model):
        is_infeasible, is_suboptimal = False, False
        restored = []
        def check_pi(msense, csense, pi):
            if csense == &#34;=&#34;:
                return True
            if msense == &#34;max&#34;:
                if csense == &#34;&lt;&#34;:
                    return pi &gt;= 0
                else:
                    return pi &lt;= 0
            else:
                if csense == &#34;&gt;&#34;:
                    return pi &gt;= 0
                else:
                    return pi &lt;= 0
        def restore(cid):
            nonlocal restored
            csense = self.original_sense[cid]
            solver.internal_solver.set_constraint_sense(cid, csense)
            restored += [cid]
        if solver.internal_solver.is_infeasible():
            for cid in self.converted:
                pi = solver.internal_solver.get_dual(cid)
                if abs(pi) &gt; 0:
                    is_infeasible = True
                    restore(cid)
        elif self.check_optimality:
            random.shuffle(self.converted)
            n_restored = 0
            for cid in self.converted:
                if n_restored &gt;= 100:
                    break
                pi = solver.internal_solver.get_dual(cid)
                csense = self.original_sense[cid]
                msense = solver.internal_solver.get_sense()
                if not check_pi(msense, csense, pi):
                    is_suboptimal = True
                    restore(cid)
                    n_restored += 1
        for cid in restored:
            self.converted.remove(cid)
        if len(restored) &gt; 0:
            self.n_restored += len(restored)
            if is_infeasible:
                self.n_infeasible_iterations += 1
            if is_suboptimal:
                self.n_suboptimal_iterations += 1
            logger.info(f&#34;Restored {len(restored)} inequalities&#34;)
            return True
        else:
            return False</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.components.steps.convert_tight.ConvertTightIneqsIntoEqsStep"><code class="flex name class">
 <span>class <span class="ident">ConvertTightIneqsIntoEqsStep</span></span>
 <span>(</span><span>classifier=CountingClassifier(mean=None), threshold=0.95, slack_tolerance=0.0, check_optimality=False)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Component that predicts which inequality constraints are likely to be binding in
 the LP relaxation of the problem and converts them into equality constraints.</p>
 <p>This component always makes sure that the conversion process does not affect the
 feasibility of the problem. It can also, optionally, make sure that it does not affect
 the optimality, but this may be expensive.</p>
 <p>This component does not work on MIPs. All integrality constraints must be relaxed
 before this component is used.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class ConvertTightIneqsIntoEqsStep(Component):
    &#34;&#34;&#34;
    Component that predicts which inequality constraints are likely to be binding in
    the LP relaxation of the problem and converts them into equality constraints.
    This component always makes sure that the conversion process does not affect the
    feasibility of the problem. It can also, optionally, make sure that it does not affect
    the optimality, but this may be expensive.
    This component does not work on MIPs. All integrality constraints must be relaxed
    before this component is used.
    &#34;&#34;&#34;
    def __init__(
        self,
        classifier=CountingClassifier(),
        threshold=0.95,
        slack_tolerance=0.0,
        check_optimality=False,
    ):
        self.classifiers = {}
        self.classifier_prototype = classifier
        self.threshold = threshold
        self.slack_tolerance = slack_tolerance
        self.check_optimality = check_optimality
        self.converted = []
        self.original_sense = {}
    def before_solve(self, solver, instance, _):
        logger.info(&#34;Predicting tight LP constraints...&#34;)
        x, constraints = DropRedundantInequalitiesStep._x_test(
            instance,
            constraint_ids=solver.internal_solver.get_constraint_ids(),
        )
        y = self.predict(x)
        self.n_converted = 0
        self.n_restored = 0
        self.n_kept = 0
        self.n_infeasible_iterations = 0
        self.n_suboptimal_iterations = 0
        for category in y.keys():
            for i in range(len(y[category])):
                if y[category][i][0] == 1:
                    cid = constraints[category][i]
                    s = solver.internal_solver.get_constraint_sense(cid)
                    self.original_sense[cid] = s
                    solver.internal_solver.set_constraint_sense(cid, &#34;=&#34;)
                    self.converted += [cid]
                    self.n_converted += 1
                else:
                    self.n_kept += 1
        logger.info(f&#34;Converted {self.n_converted} inequalities&#34;)
    def after_solve(
        self,
        solver,
        instance,
        model,
        stats,
        training_data,
    ):
        if &#34;slacks&#34; not in training_data.keys():
            training_data[&#34;slacks&#34;] = solver.internal_solver.get_inequality_slacks()
        stats[&#34;ConvertTight: Kept&#34;] = self.n_kept
        stats[&#34;ConvertTight: Converted&#34;] = self.n_converted
        stats[&#34;ConvertTight: Restored&#34;] = self.n_restored
        stats[&#34;ConvertTight: Inf iterations&#34;] = self.n_infeasible_iterations
        stats[&#34;ConvertTight: Subopt iterations&#34;] = self.n_suboptimal_iterations
    def fit(self, training_instances):
        logger.debug(&#34;Extracting x and y...&#34;)
        x = self.x(training_instances)
        y = self.y(training_instances)
        logger.debug(&#34;Fitting...&#34;)
        for category in tqdm(x.keys(), desc=&#34;Fit (rlx:conv_ineqs)&#34;):
            if category not in self.classifiers:
                self.classifiers[category] = deepcopy(self.classifier_prototype)
            self.classifiers[category].fit(x[category], y[category])
    def x(self, instances):
        return DropRedundantInequalitiesStep._x_train(instances)
    def y(self, instances):
        y = {}
        for instance in tqdm(
            InstanceIterator(instances),
            desc=&#34;Extract (rlx:conv_ineqs:y)&#34;,
            disable=len(instances) &lt; 5,
        ):
            for (cid, slack) in instance.training_data[0][&#34;slacks&#34;].items():
                category = instance.get_constraint_category(cid)
                if category is None:
                    continue
                if category not in y:
                    y[category] = []
                if 0 &lt;= slack &lt;= self.slack_tolerance:
                    y[category] += [[1]]
                else:
                    y[category] += [[0]]
        return y
    def predict(self, x):
        y = {}
        for (category, x_cat) in x.items():
            if category not in self.classifiers:
                continue
            y[category] = []
            x_cat = np.array(x_cat)
            proba = self.classifiers[category].predict_proba(x_cat)
            for i in range(len(proba)):
                if proba[i][1] &gt;= self.threshold:
                    y[category] += [[1]]
                else:
                    y[category] += [[0]]
        return y
    def evaluate(self, instance):
        x = self.x([instance])
        y_true = self.y([instance])
        y_pred = self.predict(x)
        tp, tn, fp, fn = 0, 0, 0, 0
        for category in y_true.keys():
            for i in range(len(y_true[category])):
                if y_pred[category][i][0] == 1:
                    if y_true[category][i][0] == 1:
                        tp += 1
                    else:
                        fp += 1
                else:
                    if y_true[category][i][0] == 1:
                        fn += 1
                    else:
                        tn += 1
        return classifier_evaluation_dict(tp, tn, fp, fn)
    def iteration_cb(self, solver, instance, model):
        is_infeasible, is_suboptimal = False, False
        restored = []
        def check_pi(msense, csense, pi):
            if csense == &#34;=&#34;:
                return True
            if msense == &#34;max&#34;:
                if csense == &#34;&lt;&#34;:
                    return pi &gt;= 0
                else:
                    return pi &lt;= 0
            else:
                if csense == &#34;&gt;&#34;:
                    return pi &gt;= 0
                else:
                    return pi &lt;= 0
        def restore(cid):
            nonlocal restored
            csense = self.original_sense[cid]
            solver.internal_solver.set_constraint_sense(cid, csense)
            restored += [cid]
        if solver.internal_solver.is_infeasible():
            for cid in self.converted:
                pi = solver.internal_solver.get_dual(cid)
                if abs(pi) &gt; 0:
                    is_infeasible = True
                    restore(cid)
        elif self.check_optimality:
            random.shuffle(self.converted)
            n_restored = 0
            for cid in self.converted:
                if n_restored &gt;= 100:
                    break
                pi = solver.internal_solver.get_dual(cid)
                csense = self.original_sense[cid]
                msense = solver.internal_solver.get_sense()
                if not check_pi(msense, csense, pi):
                    is_suboptimal = True
                    restore(cid)
                    n_restored += 1
        for cid in restored:
            self.converted.remove(cid)
        if len(restored) &gt; 0:
            self.n_restored += len(restored)
            if is_infeasible:
                self.n_infeasible_iterations += 1
            if is_suboptimal:
                self.n_suboptimal_iterations += 1
            logger.info(f&#34;Restored {len(restored)} inequalities&#34;)
            return True
        else:
            return False</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.components.component.Component" href="../component.html#miplearn.components.component.Component">Component</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.components.steps.convert_tight.ConvertTightIneqsIntoEqsStep.evaluate"><code class="name flex">
 <span>def <span class="ident">evaluate</span></span>(<span>self, instance)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def evaluate(self, instance):
    x = self.x([instance])
    y_true = self.y([instance])
    y_pred = self.predict(x)
    tp, tn, fp, fn = 0, 0, 0, 0
    for category in y_true.keys():
        for i in range(len(y_true[category])):
            if y_pred[category][i][0] == 1:
                if y_true[category][i][0] == 1:
                    tp += 1
                else:
                    fp += 1
            else:
                if y_true[category][i][0] == 1:
                    fn += 1
                else:
                    tn += 1
    return classifier_evaluation_dict(tp, tn, fp, fn)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.steps.convert_tight.ConvertTightIneqsIntoEqsStep.fit"><code class="name flex">
 <span>def <span class="ident">fit</span></span>(<span>self, training_instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def fit(self, training_instances):
    logger.debug(&#34;Extracting x and y...&#34;)
    x = self.x(training_instances)
    y = self.y(training_instances)
    logger.debug(&#34;Fitting...&#34;)
    for category in tqdm(x.keys(), desc=&#34;Fit (rlx:conv_ineqs)&#34;):
        if category not in self.classifiers:
            self.classifiers[category] = deepcopy(self.classifier_prototype)
        self.classifiers[category].fit(x[category], y[category])</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.steps.convert_tight.ConvertTightIneqsIntoEqsStep.predict"><code class="name flex">
 <span>def <span class="ident">predict</span></span>(<span>self, x)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def predict(self, x):
    y = {}
    for (category, x_cat) in x.items():
        if category not in self.classifiers:
            continue
        y[category] = []
        x_cat = np.array(x_cat)
        proba = self.classifiers[category].predict_proba(x_cat)
        for i in range(len(proba)):
            if proba[i][1] &gt;= self.threshold:
                y[category] += [[1]]
            else:
                y[category] += [[0]]
    return y</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.steps.convert_tight.ConvertTightIneqsIntoEqsStep.x"><code class="name flex">
 <span>def <span class="ident">x</span></span>(<span>self, instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def x(self, instances):
    return DropRedundantInequalitiesStep._x_train(instances)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.steps.convert_tight.ConvertTightIneqsIntoEqsStep.y"><code class="name flex">
 <span>def <span class="ident">y</span></span>(<span>self, instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def y(self, instances):
    y = {}
    for instance in tqdm(
        InstanceIterator(instances),
        desc=&#34;Extract (rlx:conv_ineqs:y)&#34;,
        disable=len(instances) &lt; 5,
    ):
        for (cid, slack) in instance.training_data[0][&#34;slacks&#34;].items():
            category = instance.get_constraint_category(cid)
            if category is None:
                continue
            if category not in y:
                y[category] = []
            if 0 &lt;= slack &lt;= self.slack_tolerance:
                y[category] += [[1]]
            else:
                y[category] += [[0]]
    return y</code></pre>
 </details>
 </dd>
 </dl>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.components.component.Component" href="../component.html#miplearn.components.component.Component">Component</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.components.component.Component.after_solve" href="../component.html#miplearn.components.component.Component.after_solve">after_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.before_solve" href="../component.html#miplearn.components.component.Component.before_solve">before_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.iteration_cb" href="../component.html#miplearn.components.component.Component.iteration_cb">iteration_cb</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.components.steps" href="index.html">miplearn.components.steps</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.components.steps.convert_tight.ConvertTightIneqsIntoEqsStep" href="#miplearn.components.steps.convert_tight.ConvertTightIneqsIntoEqsStep">ConvertTightIneqsIntoEqsStep</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.components.steps.convert_tight.ConvertTightIneqsIntoEqsStep.evaluate" href="#miplearn.components.steps.convert_tight.ConvertTightIneqsIntoEqsStep.evaluate">evaluate</a></code></li>
 <li><code><a title="miplearn.components.steps.convert_tight.ConvertTightIneqsIntoEqsStep.fit" href="#miplearn.components.steps.convert_tight.ConvertTightIneqsIntoEqsStep.fit">fit</a></code></li>
 <li><code><a title="miplearn.components.steps.convert_tight.ConvertTightIneqsIntoEqsStep.predict" href="#miplearn.components.steps.convert_tight.ConvertTightIneqsIntoEqsStep.predict">predict</a></code></li>
 <li><code><a title="miplearn.components.steps.convert_tight.ConvertTightIneqsIntoEqsStep.x" href="#miplearn.components.steps.convert_tight.ConvertTightIneqsIntoEqsStep.x">x</a></code></li>
 <li><code><a title="miplearn.components.steps.convert_tight.ConvertTightIneqsIntoEqsStep.y" href="#miplearn.components.steps.convert_tight.ConvertTightIneqsIntoEqsStep.y">y</a></code></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/components/steps/drop_redundant.html
+++ b/0.2/api/miplearn/components/steps/drop_redundant.html
@ -1,663 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.components.steps.drop_redundant API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.components.steps.drop_redundant</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import logging
 from copy import deepcopy
 import numpy as np
 from tqdm import tqdm
 from miplearn.classifiers.counting import CountingClassifier
 from miplearn.components import classifier_evaluation_dict
 from miplearn.components.component import Component
 from miplearn.components.lazy_static import LazyConstraint
 from miplearn.extractors import InstanceIterator
 logger = logging.getLogger(__name__)
 class DropRedundantInequalitiesStep(Component):
    &#34;&#34;&#34;
    Component that predicts which inequalities are likely loose in the LP and removes
    them. Optionally, double checks after the problem is solved that all dropped
    inequalities were in fact redundant, and, if not, re-adds them to the problem.
    This component does not work on MIPs. All integrality constraints must be relaxed
    before this component is used.
    &#34;&#34;&#34;
    def __init__(
        self,
        classifier=CountingClassifier(),
        threshold=0.95,
        slack_tolerance=1e-5,
        check_feasibility=False,
        violation_tolerance=1e-5,
        max_iterations=3,
    ):
        self.classifiers = {}
        self.classifier_prototype = classifier
        self.threshold = threshold
        self.slack_tolerance = slack_tolerance
        self.pool = []
        self.check_feasibility = check_feasibility
        self.violation_tolerance = violation_tolerance
        self.max_iterations = max_iterations
        self.current_iteration = 0
    def before_solve(self, solver, instance, _):
        self.current_iteration = 0
        logger.info(&#34;Predicting redundant LP constraints...&#34;)
        x, constraints = self._x_test(
            instance,
            constraint_ids=solver.internal_solver.get_constraint_ids(),
        )
        y = self.predict(x)
        self.total_dropped = 0
        self.total_restored = 0
        self.total_kept = 0
        self.total_iterations = 0
        for category in y.keys():
            for i in range(len(y[category])):
                if y[category][i][0] == 1:
                    cid = constraints[category][i]
                    c = LazyConstraint(
                        cid=cid,
                        obj=solver.internal_solver.extract_constraint(cid),
                    )
                    self.pool += [c]
                    self.total_dropped += 1
                else:
                    self.total_kept += 1
        logger.info(f&#34;Extracted {self.total_dropped} predicted constraints&#34;)
    def after_solve(
        self,
        solver,
        instance,
        model,
        stats,
        training_data,
    ):
        if &#34;slacks&#34; not in training_data.keys():
            training_data[&#34;slacks&#34;] = solver.internal_solver.get_inequality_slacks()
        stats.update(
            {
                &#34;DropRedundant: Kept&#34;: self.total_kept,
                &#34;DropRedundant: Dropped&#34;: self.total_dropped,
                &#34;DropRedundant: Restored&#34;: self.total_restored,
                &#34;DropRedundant: Iterations&#34;: self.total_iterations,
            }
        )
    def fit(self, training_instances):
        logger.debug(&#34;Extracting x and y...&#34;)
        x = self.x(training_instances)
        y = self.y(training_instances)
        logger.debug(&#34;Fitting...&#34;)
        for category in tqdm(x.keys(), desc=&#34;Fit (rlx:drop_ineq)&#34;):
            if category not in self.classifiers:
                self.classifiers[category] = deepcopy(self.classifier_prototype)
            self.classifiers[category].fit(x[category], y[category])
    @staticmethod
    def _x_test(instance, constraint_ids):
        x = {}
        constraints = {}
        cids = constraint_ids
        for cid in cids:
            category = instance.get_constraint_category(cid)
            if category is None:
                continue
            if category not in x:
                x[category] = []
                constraints[category] = []
            x[category] += [instance.get_constraint_features(cid)]
            constraints[category] += [cid]
        for category in x.keys():
            x[category] = np.array(x[category])
        return x, constraints
    @staticmethod
    def _x_train(instances):
        x = {}
        for instance in tqdm(
            InstanceIterator(instances),
            desc=&#34;Extract (rlx:drop_ineq:x)&#34;,
            disable=len(instances) &lt; 5,
        ):
            for training_data in instance.training_data:
                cids = training_data[&#34;slacks&#34;].keys()
                for cid in cids:
                    category = instance.get_constraint_category(cid)
                    if category is None:
                        continue
                    if category not in x:
                        x[category] = []
                    x[category] += [instance.get_constraint_features(cid)]
        for category in x.keys():
            x[category] = np.array(x[category])
        return x
    def x(self, instances):
        return self._x_train(instances)
    def y(self, instances):
        y = {}
        for instance in tqdm(
            InstanceIterator(instances),
            desc=&#34;Extract (rlx:drop_ineq:y)&#34;,
            disable=len(instances) &lt; 5,
        ):
            for training_data in instance.training_data:
                for (cid, slack) in training_data[&#34;slacks&#34;].items():
                    category = instance.get_constraint_category(cid)
                    if category is None:
                        continue
                    if category not in y:
                        y[category] = []
                    if slack &gt; self.slack_tolerance:
                        y[category] += [[1]]
                    else:
                        y[category] += [[0]]
        return y
    def predict(self, x):
        y = {}
        for (category, x_cat) in x.items():
            if category not in self.classifiers:
                continue
            y[category] = []
            x_cat = np.array(x_cat)
            proba = self.classifiers[category].predict_proba(x_cat)
            for i in range(len(proba)):
                if proba[i][1] &gt;= self.threshold:
                    y[category] += [[1]]
                else:
                    y[category] += [[0]]
        return y
    def evaluate(self, instance):
        x = self.x([instance])
        y_true = self.y([instance])
        y_pred = self.predict(x)
        tp, tn, fp, fn = 0, 0, 0, 0
        for category in y_true.keys():
            for i in range(len(y_true[category])):
                if y_pred[category][i][0] == 1:
                    if y_true[category][i][0] == 1:
                        tp += 1
                    else:
                        fp += 1
                else:
                    if y_true[category][i][0] == 1:
                        fn += 1
                    else:
                        tn += 1
        return classifier_evaluation_dict(tp, tn, fp, fn)
    def iteration_cb(self, solver, instance, model):
        if not self.check_feasibility:
            return False
        if self.current_iteration &gt;= self.max_iterations:
            return False
        self.current_iteration += 1
        logger.debug(&#34;Checking that dropped constraints are satisfied...&#34;)
        constraints_to_add = []
        for c in self.pool:
            if not solver.internal_solver.is_constraint_satisfied(
                c.obj,
                self.violation_tolerance,
            ):
                constraints_to_add.append(c)
        for c in constraints_to_add:
            self.pool.remove(c)
            solver.internal_solver.add_constraint(c.obj)
        if len(constraints_to_add) &gt; 0:
            self.total_restored += len(constraints_to_add)
            logger.info(
                &#34;%8d constraints %8d in the pool&#34;
                % (len(constraints_to_add), len(self.pool))
            )
            self.total_iterations += 1
            return True
        else:
            return False</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.components.steps.drop_redundant.DropRedundantInequalitiesStep"><code class="flex name class">
 <span>class <span class="ident">DropRedundantInequalitiesStep</span></span>
 <span>(</span><span>classifier=CountingClassifier(mean=None), threshold=0.95, slack_tolerance=1e-05, check_feasibility=False, violation_tolerance=1e-05, max_iterations=3)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Component that predicts which inequalities are likely loose in the LP and removes
 them. Optionally, double checks after the problem is solved that all dropped
 inequalities were in fact redundant, and, if not, re-adds them to the problem.</p>
 <p>This component does not work on MIPs. All integrality constraints must be relaxed
 before this component is used.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class DropRedundantInequalitiesStep(Component):
    &#34;&#34;&#34;
    Component that predicts which inequalities are likely loose in the LP and removes
    them. Optionally, double checks after the problem is solved that all dropped
    inequalities were in fact redundant, and, if not, re-adds them to the problem.
    This component does not work on MIPs. All integrality constraints must be relaxed
    before this component is used.
    &#34;&#34;&#34;
    def __init__(
        self,
        classifier=CountingClassifier(),
        threshold=0.95,
        slack_tolerance=1e-5,
        check_feasibility=False,
        violation_tolerance=1e-5,
        max_iterations=3,
    ):
        self.classifiers = {}
        self.classifier_prototype = classifier
        self.threshold = threshold
        self.slack_tolerance = slack_tolerance
        self.pool = []
        self.check_feasibility = check_feasibility
        self.violation_tolerance = violation_tolerance
        self.max_iterations = max_iterations
        self.current_iteration = 0
    def before_solve(self, solver, instance, _):
        self.current_iteration = 0
        logger.info(&#34;Predicting redundant LP constraints...&#34;)
        x, constraints = self._x_test(
            instance,
            constraint_ids=solver.internal_solver.get_constraint_ids(),
        )
        y = self.predict(x)
        self.total_dropped = 0
        self.total_restored = 0
        self.total_kept = 0
        self.total_iterations = 0
        for category in y.keys():
            for i in range(len(y[category])):
                if y[category][i][0] == 1:
                    cid = constraints[category][i]
                    c = LazyConstraint(
                        cid=cid,
                        obj=solver.internal_solver.extract_constraint(cid),
                    )
                    self.pool += [c]
                    self.total_dropped += 1
                else:
                    self.total_kept += 1
        logger.info(f&#34;Extracted {self.total_dropped} predicted constraints&#34;)
    def after_solve(
        self,
        solver,
        instance,
        model,
        stats,
        training_data,
    ):
        if &#34;slacks&#34; not in training_data.keys():
            training_data[&#34;slacks&#34;] = solver.internal_solver.get_inequality_slacks()
        stats.update(
            {
                &#34;DropRedundant: Kept&#34;: self.total_kept,
                &#34;DropRedundant: Dropped&#34;: self.total_dropped,
                &#34;DropRedundant: Restored&#34;: self.total_restored,
                &#34;DropRedundant: Iterations&#34;: self.total_iterations,
            }
        )
    def fit(self, training_instances):
        logger.debug(&#34;Extracting x and y...&#34;)
        x = self.x(training_instances)
        y = self.y(training_instances)
        logger.debug(&#34;Fitting...&#34;)
        for category in tqdm(x.keys(), desc=&#34;Fit (rlx:drop_ineq)&#34;):
            if category not in self.classifiers:
                self.classifiers[category] = deepcopy(self.classifier_prototype)
            self.classifiers[category].fit(x[category], y[category])
    @staticmethod
    def _x_test(instance, constraint_ids):
        x = {}
        constraints = {}
        cids = constraint_ids
        for cid in cids:
            category = instance.get_constraint_category(cid)
            if category is None:
                continue
            if category not in x:
                x[category] = []
                constraints[category] = []
            x[category] += [instance.get_constraint_features(cid)]
            constraints[category] += [cid]
        for category in x.keys():
            x[category] = np.array(x[category])
        return x, constraints
    @staticmethod
    def _x_train(instances):
        x = {}
        for instance in tqdm(
            InstanceIterator(instances),
            desc=&#34;Extract (rlx:drop_ineq:x)&#34;,
            disable=len(instances) &lt; 5,
        ):
            for training_data in instance.training_data:
                cids = training_data[&#34;slacks&#34;].keys()
                for cid in cids:
                    category = instance.get_constraint_category(cid)
                    if category is None:
                        continue
                    if category not in x:
                        x[category] = []
                    x[category] += [instance.get_constraint_features(cid)]
        for category in x.keys():
            x[category] = np.array(x[category])
        return x
    def x(self, instances):
        return self._x_train(instances)
    def y(self, instances):
        y = {}
        for instance in tqdm(
            InstanceIterator(instances),
            desc=&#34;Extract (rlx:drop_ineq:y)&#34;,
            disable=len(instances) &lt; 5,
        ):
            for training_data in instance.training_data:
                for (cid, slack) in training_data[&#34;slacks&#34;].items():
                    category = instance.get_constraint_category(cid)
                    if category is None:
                        continue
                    if category not in y:
                        y[category] = []
                    if slack &gt; self.slack_tolerance:
                        y[category] += [[1]]
                    else:
                        y[category] += [[0]]
        return y
    def predict(self, x):
        y = {}
        for (category, x_cat) in x.items():
            if category not in self.classifiers:
                continue
            y[category] = []
            x_cat = np.array(x_cat)
            proba = self.classifiers[category].predict_proba(x_cat)
            for i in range(len(proba)):
                if proba[i][1] &gt;= self.threshold:
                    y[category] += [[1]]
                else:
                    y[category] += [[0]]
        return y
    def evaluate(self, instance):
        x = self.x([instance])
        y_true = self.y([instance])
        y_pred = self.predict(x)
        tp, tn, fp, fn = 0, 0, 0, 0
        for category in y_true.keys():
            for i in range(len(y_true[category])):
                if y_pred[category][i][0] == 1:
                    if y_true[category][i][0] == 1:
                        tp += 1
                    else:
                        fp += 1
                else:
                    if y_true[category][i][0] == 1:
                        fn += 1
                    else:
                        tn += 1
        return classifier_evaluation_dict(tp, tn, fp, fn)
    def iteration_cb(self, solver, instance, model):
        if not self.check_feasibility:
            return False
        if self.current_iteration &gt;= self.max_iterations:
            return False
        self.current_iteration += 1
        logger.debug(&#34;Checking that dropped constraints are satisfied...&#34;)
        constraints_to_add = []
        for c in self.pool:
            if not solver.internal_solver.is_constraint_satisfied(
                c.obj,
                self.violation_tolerance,
            ):
                constraints_to_add.append(c)
        for c in constraints_to_add:
            self.pool.remove(c)
            solver.internal_solver.add_constraint(c.obj)
        if len(constraints_to_add) &gt; 0:
            self.total_restored += len(constraints_to_add)
            logger.info(
                &#34;%8d constraints %8d in the pool&#34;
                % (len(constraints_to_add), len(self.pool))
            )
            self.total_iterations += 1
            return True
        else:
            return False</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.components.component.Component" href="../component.html#miplearn.components.component.Component">Component</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.components.steps.drop_redundant.DropRedundantInequalitiesStep.evaluate"><code class="name flex">
 <span>def <span class="ident">evaluate</span></span>(<span>self, instance)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def evaluate(self, instance):
    x = self.x([instance])
    y_true = self.y([instance])
    y_pred = self.predict(x)
    tp, tn, fp, fn = 0, 0, 0, 0
    for category in y_true.keys():
        for i in range(len(y_true[category])):
            if y_pred[category][i][0] == 1:
                if y_true[category][i][0] == 1:
                    tp += 1
                else:
                    fp += 1
            else:
                if y_true[category][i][0] == 1:
                    fn += 1
                else:
                    tn += 1
    return classifier_evaluation_dict(tp, tn, fp, fn)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.steps.drop_redundant.DropRedundantInequalitiesStep.fit"><code class="name flex">
 <span>def <span class="ident">fit</span></span>(<span>self, training_instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def fit(self, training_instances):
    logger.debug(&#34;Extracting x and y...&#34;)
    x = self.x(training_instances)
    y = self.y(training_instances)
    logger.debug(&#34;Fitting...&#34;)
    for category in tqdm(x.keys(), desc=&#34;Fit (rlx:drop_ineq)&#34;):
        if category not in self.classifiers:
            self.classifiers[category] = deepcopy(self.classifier_prototype)
        self.classifiers[category].fit(x[category], y[category])</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.steps.drop_redundant.DropRedundantInequalitiesStep.predict"><code class="name flex">
 <span>def <span class="ident">predict</span></span>(<span>self, x)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def predict(self, x):
    y = {}
    for (category, x_cat) in x.items():
        if category not in self.classifiers:
            continue
        y[category] = []
        x_cat = np.array(x_cat)
        proba = self.classifiers[category].predict_proba(x_cat)
        for i in range(len(proba)):
            if proba[i][1] &gt;= self.threshold:
                y[category] += [[1]]
            else:
                y[category] += [[0]]
    return y</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.steps.drop_redundant.DropRedundantInequalitiesStep.x"><code class="name flex">
 <span>def <span class="ident">x</span></span>(<span>self, instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def x(self, instances):
    return self._x_train(instances)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.components.steps.drop_redundant.DropRedundantInequalitiesStep.y"><code class="name flex">
 <span>def <span class="ident">y</span></span>(<span>self, instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def y(self, instances):
    y = {}
    for instance in tqdm(
        InstanceIterator(instances),
        desc=&#34;Extract (rlx:drop_ineq:y)&#34;,
        disable=len(instances) &lt; 5,
    ):
        for training_data in instance.training_data:
            for (cid, slack) in training_data[&#34;slacks&#34;].items():
                category = instance.get_constraint_category(cid)
                if category is None:
                    continue
                if category not in y:
                    y[category] = []
                if slack &gt; self.slack_tolerance:
                    y[category] += [[1]]
                else:
                    y[category] += [[0]]
    return y</code></pre>
 </details>
 </dd>
 </dl>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.components.component.Component" href="../component.html#miplearn.components.component.Component">Component</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.components.component.Component.after_solve" href="../component.html#miplearn.components.component.Component.after_solve">after_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.before_solve" href="../component.html#miplearn.components.component.Component.before_solve">before_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.iteration_cb" href="../component.html#miplearn.components.component.Component.iteration_cb">iteration_cb</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.components.steps" href="index.html">miplearn.components.steps</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.components.steps.drop_redundant.DropRedundantInequalitiesStep" href="#miplearn.components.steps.drop_redundant.DropRedundantInequalitiesStep">DropRedundantInequalitiesStep</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.components.steps.drop_redundant.DropRedundantInequalitiesStep.evaluate" href="#miplearn.components.steps.drop_redundant.DropRedundantInequalitiesStep.evaluate">evaluate</a></code></li>
 <li><code><a title="miplearn.components.steps.drop_redundant.DropRedundantInequalitiesStep.fit" href="#miplearn.components.steps.drop_redundant.DropRedundantInequalitiesStep.fit">fit</a></code></li>
 <li><code><a title="miplearn.components.steps.drop_redundant.DropRedundantInequalitiesStep.predict" href="#miplearn.components.steps.drop_redundant.DropRedundantInequalitiesStep.predict">predict</a></code></li>
 <li><code><a title="miplearn.components.steps.drop_redundant.DropRedundantInequalitiesStep.x" href="#miplearn.components.steps.drop_redundant.DropRedundantInequalitiesStep.x">x</a></code></li>
 <li><code><a title="miplearn.components.steps.drop_redundant.DropRedundantInequalitiesStep.y" href="#miplearn.components.steps.drop_redundant.DropRedundantInequalitiesStep.y">y</a></code></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/components/steps/index.html
+++ b/0.2/api/miplearn/components/steps/index.html
@ -1,75 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.components.steps API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.components.steps</code></h1>
 </header>
 <section id="section-intro">
 </section>
 <section>
 <h2 class="section-title" id="header-submodules">Sub-modules</h2>
 <dl>
 <dt><code class="name"><a title="miplearn.components.steps.convert_tight" href="convert_tight.html">miplearn.components.steps.convert_tight</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.components.steps.drop_redundant" href="drop_redundant.html">miplearn.components.steps.drop_redundant</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.components.steps.relax_integrality" href="relax_integrality.html">miplearn.components.steps.relax_integrality</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 </dl>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.components" href="../index.html">miplearn.components</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-submodules">Sub-modules</a></h3>
 <ul>
 <li><code><a title="miplearn.components.steps.convert_tight" href="convert_tight.html">miplearn.components.steps.convert_tight</a></code></li>
 <li><code><a title="miplearn.components.steps.drop_redundant" href="drop_redundant.html">miplearn.components.steps.drop_redundant</a></code></li>
 <li><code><a title="miplearn.components.steps.relax_integrality" href="relax_integrality.html">miplearn.components.steps.relax_integrality</a></code></li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/components/steps/relax_integrality.html
+++ b/0.2/api/miplearn/components/steps/relax_integrality.html
@ -1,141 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.components.steps.relax_integrality API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.components.steps.relax_integrality</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import logging
 from miplearn.components.component import Component
 logger = logging.getLogger(__name__)
 class RelaxIntegralityStep(Component):
    &#34;&#34;&#34;
    Component that relaxes all integrality constraints before the problem is solved.
    &#34;&#34;&#34;
    def before_solve(self, solver, instance, _):
        logger.info(&#34;Relaxing integrality...&#34;)
        solver.internal_solver.relax()
    def after_solve(
        self,
        solver,
        instance,
        model,
        stats,
        training_data,
    ):
        return</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.components.steps.relax_integrality.RelaxIntegralityStep"><code class="flex name class">
 <span>class <span class="ident">RelaxIntegralityStep</span></span>
 </code></dt>
 <dd>
 <section class="desc"><p>Component that relaxes all integrality constraints before the problem is solved.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class RelaxIntegralityStep(Component):
    &#34;&#34;&#34;
    Component that relaxes all integrality constraints before the problem is solved.
    &#34;&#34;&#34;
    def before_solve(self, solver, instance, _):
        logger.info(&#34;Relaxing integrality...&#34;)
        solver.internal_solver.relax()
    def after_solve(
        self,
        solver,
        instance,
        model,
        stats,
        training_data,
    ):
        return</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.components.component.Component" href="../component.html#miplearn.components.component.Component">Component</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.components.component.Component" href="../component.html#miplearn.components.component.Component">Component</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.components.component.Component.after_solve" href="../component.html#miplearn.components.component.Component.after_solve">after_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.before_solve" href="../component.html#miplearn.components.component.Component.before_solve">before_solve</a></code></li>
 <li><code><a title="miplearn.components.component.Component.iteration_cb" href="../component.html#miplearn.components.component.Component.iteration_cb">iteration_cb</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.components.steps" href="index.html">miplearn.components.steps</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.components.steps.relax_integrality.RelaxIntegralityStep" href="#miplearn.components.steps.relax_integrality.RelaxIntegralityStep">RelaxIntegralityStep</a></code></h4>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/extractors.html
+++ b/0.2/api/miplearn/extractors.html
@ -1,677 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.extractors API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.extractors</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import gzip
 import logging
 import pickle
 from abc import ABC, abstractmethod
 import numpy as np
 from tqdm.auto import tqdm
 logger = logging.getLogger(__name__)
 class InstanceIterator:
    def __init__(self, instances):
        self.instances = instances
        self.current = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.current &gt;= len(self.instances):
            raise StopIteration
        result = self.instances[self.current]
        self.current += 1
        if isinstance(result, str):
            logger.debug(&#34;Read: %s&#34; % result)
            try:
                if result.endswith(&#34;.gz&#34;):
                    with gzip.GzipFile(result, &#34;rb&#34;) as file:
                        result = pickle.load(file)
                else:
                    with open(result, &#34;rb&#34;) as file:
                        result = pickle.load(file)
            except pickle.UnpicklingError:
                raise Exception(f&#34;Invalid instance file: {result}&#34;)
        return result
 class Extractor(ABC):
    @abstractmethod
    def extract(self, instances):
        pass
    @staticmethod
    def split_variables(instance):
        result = {}
        lp_solution = instance.training_data[0][&#34;LP solution&#34;]
        for var_name in lp_solution:
            for index in lp_solution[var_name]:
                category = instance.get_variable_category(var_name, index)
                if category is None:
                    continue
                if category not in result:
                    result[category] = []
                result[category] += [(var_name, index)]
        return result
 class VariableFeaturesExtractor(Extractor):
    def extract(self, instances):
        result = {}
        for instance in tqdm(
            InstanceIterator(instances),
            desc=&#34;Extract (vars)&#34;,
            disable=len(instances) &lt; 5,
        ):
            instance_features = instance.get_instance_features()
            var_split = self.split_variables(instance)
            lp_solution = instance.training_data[0][&#34;LP solution&#34;]
            for (category, var_index_pairs) in var_split.items():
                if category not in result:
                    result[category] = []
                for (var_name, index) in var_index_pairs:
                    result[category] += [
                        instance_features.tolist()
                        + instance.get_variable_features(var_name, index).tolist()
                        + [lp_solution[var_name][index]]
                    ]
        for category in result:
            result[category] = np.array(result[category])
        return result
 class SolutionExtractor(Extractor):
    def __init__(self, relaxation=False):
        self.relaxation = relaxation
    def extract(self, instances):
        result = {}
        for instance in tqdm(
            InstanceIterator(instances),
            desc=&#34;Extract (solution)&#34;,
            disable=len(instances) &lt; 5,
        ):
            var_split = self.split_variables(instance)
            if self.relaxation:
                solution = instance.training_data[0][&#34;LP solution&#34;]
            else:
                solution = instance.training_data[0][&#34;Solution&#34;]
            for (category, var_index_pairs) in var_split.items():
                if category not in result:
                    result[category] = []
                for (var_name, index) in var_index_pairs:
                    v = solution[var_name][index]
                    if v is None:
                        result[category] += [[0, 0]]
                    else:
                        result[category] += [[1 - v, v]]
        for category in result:
            result[category] = np.array(result[category])
        return result
 class InstanceFeaturesExtractor(Extractor):
    def extract(self, instances):
        return np.vstack(
            [
                np.hstack(
                    [
                        instance.get_instance_features(),
                        instance.training_data[0][&#34;LP value&#34;],
                    ]
                )
                for instance in InstanceIterator(instances)
            ]
        )
 class ObjectiveValueExtractor(Extractor):
    def __init__(self, kind=&#34;lp&#34;):
        assert kind in [&#34;lower bound&#34;, &#34;upper bound&#34;, &#34;lp&#34;]
        self.kind = kind
    def extract(self, instances):
        if self.kind == &#34;lower bound&#34;:
            return np.array(
                [
                    [instance.training_data[0][&#34;Lower bound&#34;]]
                    for instance in InstanceIterator(instances)
                ]
            )
        if self.kind == &#34;upper bound&#34;:
            return np.array(
                [
                    [instance.training_data[0][&#34;Upper bound&#34;]]
                    for instance in InstanceIterator(instances)
                ]
            )
        if self.kind == &#34;lp&#34;:
            return np.array(
                [
                    [instance.training_data[0][&#34;LP value&#34;]]
                    for instance in InstanceIterator(instances)
                ]
            )</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.extractors.Extractor"><code class="flex name class">
 <span>class <span class="ident">Extractor</span></span>
 </code></dt>
 <dd>
 <section class="desc"><p>Helper class that provides a standard way to create an ABC using
 inheritance.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class Extractor(ABC):
    @abstractmethod
    def extract(self, instances):
        pass
    @staticmethod
    def split_variables(instance):
        result = {}
        lp_solution = instance.training_data[0][&#34;LP solution&#34;]
        for var_name in lp_solution:
            for index in lp_solution[var_name]:
                category = instance.get_variable_category(var_name, index)
                if category is None:
                    continue
                if category not in result:
                    result[category] = []
                result[category] += [(var_name, index)]
        return result</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li>abc.ABC</li>
 </ul>
 <h3>Subclasses</h3>
 <ul class="hlist">
 <li><a title="miplearn.extractors.InstanceFeaturesExtractor" href="#miplearn.extractors.InstanceFeaturesExtractor">InstanceFeaturesExtractor</a></li>
 <li><a title="miplearn.extractors.ObjectiveValueExtractor" href="#miplearn.extractors.ObjectiveValueExtractor">ObjectiveValueExtractor</a></li>
 <li><a title="miplearn.extractors.SolutionExtractor" href="#miplearn.extractors.SolutionExtractor">SolutionExtractor</a></li>
 <li><a title="miplearn.extractors.VariableFeaturesExtractor" href="#miplearn.extractors.VariableFeaturesExtractor">VariableFeaturesExtractor</a></li>
 </ul>
 <h3>Static methods</h3>
 <dl>
 <dt id="miplearn.extractors.Extractor.split_variables"><code class="name flex">
 <span>def <span class="ident">split_variables</span></span>(<span>instance)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">@staticmethod
 def split_variables(instance):
    result = {}
    lp_solution = instance.training_data[0][&#34;LP solution&#34;]
    for var_name in lp_solution:
        for index in lp_solution[var_name]:
            category = instance.get_variable_category(var_name, index)
            if category is None:
                continue
            if category not in result:
                result[category] = []
            result[category] += [(var_name, index)]
    return result</code></pre>
 </details>
 </dd>
 </dl>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.extractors.Extractor.extract"><code class="name flex">
 <span>def <span class="ident">extract</span></span>(<span>self, instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">@abstractmethod
 def extract(self, instances):
    pass</code></pre>
 </details>
 </dd>
 </dl>
 </dd>
 <dt id="miplearn.extractors.InstanceFeaturesExtractor"><code class="flex name class">
 <span>class <span class="ident">InstanceFeaturesExtractor</span></span>
 </code></dt>
 <dd>
 <section class="desc"><p>Helper class that provides a standard way to create an ABC using
 inheritance.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class InstanceFeaturesExtractor(Extractor):
    def extract(self, instances):
        return np.vstack(
            [
                np.hstack(
                    [
                        instance.get_instance_features(),
                        instance.training_data[0][&#34;LP value&#34;],
                    ]
                )
                for instance in InstanceIterator(instances)
            ]
        )</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.extractors.Extractor" href="#miplearn.extractors.Extractor">Extractor</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.extractors.InstanceFeaturesExtractor.extract"><code class="name flex">
 <span>def <span class="ident">extract</span></span>(<span>self, instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def extract(self, instances):
    return np.vstack(
        [
            np.hstack(
                [
                    instance.get_instance_features(),
                    instance.training_data[0][&#34;LP value&#34;],
                ]
            )
            for instance in InstanceIterator(instances)
        ]
    )</code></pre>
 </details>
 </dd>
 </dl>
 </dd>
 <dt id="miplearn.extractors.InstanceIterator"><code class="flex name class">
 <span>class <span class="ident">InstanceIterator</span></span>
 <span>(</span><span>instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class InstanceIterator:
    def __init__(self, instances):
        self.instances = instances
        self.current = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.current &gt;= len(self.instances):
            raise StopIteration
        result = self.instances[self.current]
        self.current += 1
        if isinstance(result, str):
            logger.debug(&#34;Read: %s&#34; % result)
            try:
                if result.endswith(&#34;.gz&#34;):
                    with gzip.GzipFile(result, &#34;rb&#34;) as file:
                        result = pickle.load(file)
                else:
                    with open(result, &#34;rb&#34;) as file:
                        result = pickle.load(file)
            except pickle.UnpicklingError:
                raise Exception(f&#34;Invalid instance file: {result}&#34;)
        return result</code></pre>
 </details>
 </dd>
 <dt id="miplearn.extractors.ObjectiveValueExtractor"><code class="flex name class">
 <span>class <span class="ident">ObjectiveValueExtractor</span></span>
 <span>(</span><span>kind='lp')</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Helper class that provides a standard way to create an ABC using
 inheritance.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class ObjectiveValueExtractor(Extractor):
    def __init__(self, kind=&#34;lp&#34;):
        assert kind in [&#34;lower bound&#34;, &#34;upper bound&#34;, &#34;lp&#34;]
        self.kind = kind
    def extract(self, instances):
        if self.kind == &#34;lower bound&#34;:
            return np.array(
                [
                    [instance.training_data[0][&#34;Lower bound&#34;]]
                    for instance in InstanceIterator(instances)
                ]
            )
        if self.kind == &#34;upper bound&#34;:
            return np.array(
                [
                    [instance.training_data[0][&#34;Upper bound&#34;]]
                    for instance in InstanceIterator(instances)
                ]
            )
        if self.kind == &#34;lp&#34;:
            return np.array(
                [
                    [instance.training_data[0][&#34;LP value&#34;]]
                    for instance in InstanceIterator(instances)
                ]
            )</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.extractors.Extractor" href="#miplearn.extractors.Extractor">Extractor</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.extractors.ObjectiveValueExtractor.extract"><code class="name flex">
 <span>def <span class="ident">extract</span></span>(<span>self, instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def extract(self, instances):
    if self.kind == &#34;lower bound&#34;:
        return np.array(
            [
                [instance.training_data[0][&#34;Lower bound&#34;]]
                for instance in InstanceIterator(instances)
            ]
        )
    if self.kind == &#34;upper bound&#34;:
        return np.array(
            [
                [instance.training_data[0][&#34;Upper bound&#34;]]
                for instance in InstanceIterator(instances)
            ]
        )
    if self.kind == &#34;lp&#34;:
        return np.array(
            [
                [instance.training_data[0][&#34;LP value&#34;]]
                for instance in InstanceIterator(instances)
            ]
        )</code></pre>
 </details>
 </dd>
 </dl>
 </dd>
 <dt id="miplearn.extractors.SolutionExtractor"><code class="flex name class">
 <span>class <span class="ident">SolutionExtractor</span></span>
 <span>(</span><span>relaxation=False)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Helper class that provides a standard way to create an ABC using
 inheritance.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class SolutionExtractor(Extractor):
    def __init__(self, relaxation=False):
        self.relaxation = relaxation
    def extract(self, instances):
        result = {}
        for instance in tqdm(
            InstanceIterator(instances),
            desc=&#34;Extract (solution)&#34;,
            disable=len(instances) &lt; 5,
        ):
            var_split = self.split_variables(instance)
            if self.relaxation:
                solution = instance.training_data[0][&#34;LP solution&#34;]
            else:
                solution = instance.training_data[0][&#34;Solution&#34;]
            for (category, var_index_pairs) in var_split.items():
                if category not in result:
                    result[category] = []
                for (var_name, index) in var_index_pairs:
                    v = solution[var_name][index]
                    if v is None:
                        result[category] += [[0, 0]]
                    else:
                        result[category] += [[1 - v, v]]
        for category in result:
            result[category] = np.array(result[category])
        return result</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.extractors.Extractor" href="#miplearn.extractors.Extractor">Extractor</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.extractors.SolutionExtractor.extract"><code class="name flex">
 <span>def <span class="ident">extract</span></span>(<span>self, instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def extract(self, instances):
    result = {}
    for instance in tqdm(
        InstanceIterator(instances),
        desc=&#34;Extract (solution)&#34;,
        disable=len(instances) &lt; 5,
    ):
        var_split = self.split_variables(instance)
        if self.relaxation:
            solution = instance.training_data[0][&#34;LP solution&#34;]
        else:
            solution = instance.training_data[0][&#34;Solution&#34;]
        for (category, var_index_pairs) in var_split.items():
            if category not in result:
                result[category] = []
            for (var_name, index) in var_index_pairs:
                v = solution[var_name][index]
                if v is None:
                    result[category] += [[0, 0]]
                else:
                    result[category] += [[1 - v, v]]
    for category in result:
        result[category] = np.array(result[category])
    return result</code></pre>
 </details>
 </dd>
 </dl>
 </dd>
 <dt id="miplearn.extractors.VariableFeaturesExtractor"><code class="flex name class">
 <span>class <span class="ident">VariableFeaturesExtractor</span></span>
 </code></dt>
 <dd>
 <section class="desc"><p>Helper class that provides a standard way to create an ABC using
 inheritance.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class VariableFeaturesExtractor(Extractor):
    def extract(self, instances):
        result = {}
        for instance in tqdm(
            InstanceIterator(instances),
            desc=&#34;Extract (vars)&#34;,
            disable=len(instances) &lt; 5,
        ):
            instance_features = instance.get_instance_features()
            var_split = self.split_variables(instance)
            lp_solution = instance.training_data[0][&#34;LP solution&#34;]
            for (category, var_index_pairs) in var_split.items():
                if category not in result:
                    result[category] = []
                for (var_name, index) in var_index_pairs:
                    result[category] += [
                        instance_features.tolist()
                        + instance.get_variable_features(var_name, index).tolist()
                        + [lp_solution[var_name][index]]
                    ]
        for category in result:
            result[category] = np.array(result[category])
        return result</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.extractors.Extractor" href="#miplearn.extractors.Extractor">Extractor</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.extractors.VariableFeaturesExtractor.extract"><code class="name flex">
 <span>def <span class="ident">extract</span></span>(<span>self, instances)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def extract(self, instances):
    result = {}
    for instance in tqdm(
        InstanceIterator(instances),
        desc=&#34;Extract (vars)&#34;,
        disable=len(instances) &lt; 5,
    ):
        instance_features = instance.get_instance_features()
        var_split = self.split_variables(instance)
        lp_solution = instance.training_data[0][&#34;LP solution&#34;]
        for (category, var_index_pairs) in var_split.items():
            if category not in result:
                result[category] = []
            for (var_name, index) in var_index_pairs:
                result[category] += [
                    instance_features.tolist()
                    + instance.get_variable_features(var_name, index).tolist()
                    + [lp_solution[var_name][index]]
                ]
    for category in result:
        result[category] = np.array(result[category])
    return result</code></pre>
 </details>
 </dd>
 </dl>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn" href="index.html">miplearn</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.extractors.Extractor" href="#miplearn.extractors.Extractor">Extractor</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.extractors.Extractor.extract" href="#miplearn.extractors.Extractor.extract">extract</a></code></li>
 <li><code><a title="miplearn.extractors.Extractor.split_variables" href="#miplearn.extractors.Extractor.split_variables">split_variables</a></code></li>
 </ul>
 </li>
 <li>
 <h4><code><a title="miplearn.extractors.InstanceFeaturesExtractor" href="#miplearn.extractors.InstanceFeaturesExtractor">InstanceFeaturesExtractor</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.extractors.InstanceFeaturesExtractor.extract" href="#miplearn.extractors.InstanceFeaturesExtractor.extract">extract</a></code></li>
 </ul>
 </li>
 <li>
 <h4><code><a title="miplearn.extractors.InstanceIterator" href="#miplearn.extractors.InstanceIterator">InstanceIterator</a></code></h4>
 </li>
 <li>
 <h4><code><a title="miplearn.extractors.ObjectiveValueExtractor" href="#miplearn.extractors.ObjectiveValueExtractor">ObjectiveValueExtractor</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.extractors.ObjectiveValueExtractor.extract" href="#miplearn.extractors.ObjectiveValueExtractor.extract">extract</a></code></li>
 </ul>
 </li>
 <li>
 <h4><code><a title="miplearn.extractors.SolutionExtractor" href="#miplearn.extractors.SolutionExtractor">SolutionExtractor</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.extractors.SolutionExtractor.extract" href="#miplearn.extractors.SolutionExtractor.extract">extract</a></code></li>
 </ul>
 </li>
 <li>
 <h4><code><a title="miplearn.extractors.VariableFeaturesExtractor" href="#miplearn.extractors.VariableFeaturesExtractor">VariableFeaturesExtractor</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.extractors.VariableFeaturesExtractor.extract" href="#miplearn.extractors.VariableFeaturesExtractor.extract">extract</a></code></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/index.html
+++ b/0.2/api/miplearn/index.html
@ -1,137 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 from .benchmark import BenchmarkRunner
 from .classifiers import Classifier, Regressor
 from .classifiers.adaptive import AdaptiveClassifier
 from .classifiers.threshold import MinPrecisionThreshold
 from .components.component import Component
 from .components.cuts import UserCutsComponent
 from .components.lazy_dynamic import DynamicLazyConstraintsComponent
 from .components.lazy_static import StaticLazyConstraintsComponent
 from .components.objective import ObjectiveValueComponent
 from .components.primal import PrimalSolutionComponent
 from .components.relaxation import RelaxationComponent
 from .components.steps.convert_tight import ConvertTightIneqsIntoEqsStep
 from .components.steps.drop_redundant import DropRedundantInequalitiesStep
 from .components.steps.relax_integrality import RelaxIntegralityStep
 from .extractors import (
    SolutionExtractor,
    InstanceFeaturesExtractor,
    ObjectiveValueExtractor,
    VariableFeaturesExtractor,
 )
 from .instance import Instance
 from .log import setup_logger
 from .solvers.gurobi import GurobiSolver
 from .solvers.internal import InternalSolver
 from .solvers.learning import LearningSolver
 from .solvers.pyomo.base import BasePyomoSolver
 from .solvers.pyomo.cplex import CplexPyomoSolver
 from .solvers.pyomo.gurobi import GurobiPyomoSolver</code></pre>
 </details>
 </section>
 <section>
 <h2 class="section-title" id="header-submodules">Sub-modules</h2>
 <dl>
 <dt><code class="name"><a title="miplearn.benchmark" href="benchmark.html">miplearn.benchmark</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.classifiers" href="classifiers/index.html">miplearn.classifiers</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.components" href="components/index.html">miplearn.components</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.extractors" href="extractors.html">miplearn.extractors</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.instance" href="instance.html">miplearn.instance</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.log" href="log.html">miplearn.log</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.problems" href="problems/index.html">miplearn.problems</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.solvers" href="solvers/index.html">miplearn.solvers</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.types" href="types.html">miplearn.types</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 </dl>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3><a href="#header-submodules">Sub-modules</a></h3>
 <ul>
 <li><code><a title="miplearn.benchmark" href="benchmark.html">miplearn.benchmark</a></code></li>
 <li><code><a title="miplearn.classifiers" href="classifiers/index.html">miplearn.classifiers</a></code></li>
 <li><code><a title="miplearn.components" href="components/index.html">miplearn.components</a></code></li>
 <li><code><a title="miplearn.extractors" href="extractors.html">miplearn.extractors</a></code></li>
 <li><code><a title="miplearn.instance" href="instance.html">miplearn.instance</a></code></li>
 <li><code><a title="miplearn.log" href="log.html">miplearn.log</a></code></li>
 <li><code><a title="miplearn.problems" href="problems/index.html">miplearn.problems</a></code></li>
 <li><code><a title="miplearn.solvers" href="solvers/index.html">miplearn.solvers</a></code></li>
 <li><code><a title="miplearn.types" href="types.html">miplearn.types</a></code></li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/instance.html
+++ b/0.2/api/miplearn/instance.html
@ -1,772 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.instance API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.instance</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import gzip
 import json
 from abc import ABC, abstractmethod
 from typing import Any, List
 import numpy as np
 from miplearn.types import TrainingSample
 class Instance(ABC):
    &#34;&#34;&#34;
    Abstract class holding all the data necessary to generate a concrete model of the
    problem.
    In the knapsack problem, for example, this class could hold the number of items,
    their weights and costs, as well as the size of the knapsack. Objects
    implementing this class are able to convert themselves into a concrete
    optimization model, which can be optimized by a solver, or into arrays of
    features, which can be provided as inputs to machine learning models.
    &#34;&#34;&#34;
    def __init__(self):
        self.training_data: List[TrainingSample] = []
    @abstractmethod
    def to_model(self) -&gt; Any:
        &#34;&#34;&#34;
        Returns the optimization model corresponding to this instance.
        &#34;&#34;&#34;
        pass
    def get_instance_features(self):
        &#34;&#34;&#34;
        Returns a 1-dimensional Numpy array of (numerical) features describing the
        entire instance.
        The array is used by LearningSolver to determine how similar two instances
        are. It may also be used to predict, in combination with variable-specific
        features, the values of binary decision variables in the problem.
        There is not necessarily a one-to-one correspondence between models and
        instance features: the features may encode only part of the data necessary to
        generate the complete model. Features may also be statistics computed from
        the original data. For example, in the knapsack problem, an implementation
        may decide to provide as instance features only the average weights, average
        prices, number of items and the size of the knapsack.
        The returned array MUST have the same length for all relevant instances of
        the problem. If two instances map into arrays of different lengths,
        they cannot be solved by the same LearningSolver object.
        By default, returns [0].
        &#34;&#34;&#34;
        return np.zeros(1)
    def get_variable_features(self, var, index):
        &#34;&#34;&#34;
        Returns a 1-dimensional array of (numerical) features describing a particular
        decision variable.
        The argument `var` is a pyomo.core.Var object, which represents a collection
        of decision variables. The argument `index` specifies which variable in the
        collection is the relevant one.
        In combination with instance features, variable features are used by
        LearningSolver to predict, among other things, the optimal value of each
        decision variable before the optimization takes place. In the knapsack
        problem, for example, an implementation could provide as variable features
        the weight and the price of a specific item.
        Like instance features, the arrays returned by this method MUST have the same
        length for all variables within the same category, for all relevant instances
        of the problem.
        By default, returns [0].
        &#34;&#34;&#34;
        return np.zeros(1)
    def get_variable_category(self, var, index):
        &#34;&#34;&#34;
        Returns the category (a string, an integer or any hashable type) for each
        decision variable.
        If two variables have the same category, LearningSolver will use the same
        internal ML model to predict the values of both variables. If the returned
        category is None, ML models will ignore the variable.
        By default, returns &#34;default&#34;.
        &#34;&#34;&#34;
        return &#34;default&#34;
    def get_constraint_features(self, cid):
        return np.zeros(1)
    def get_constraint_category(self, cid):
        return cid
    def has_static_lazy_constraints(self):
        return False
    def has_dynamic_lazy_constraints(self):
        return False
    def is_constraint_lazy(self, cid):
        return False
    def find_violated_lazy_constraints(self, model):
        &#34;&#34;&#34;
        Returns lazy constraint violations found for the current solution.
        After solving a model, LearningSolver will ask the instance to identify which
        lazy constraints are violated by the current solution. For each identified
        violation, LearningSolver will then call the build_lazy_constraint, add the
        generated Pyomo constraint to the model, then resolve the problem. The
        process repeats until no further lazy constraint violations are found.
        Each &#34;violation&#34; is simply a string, a tuple or any other hashable type which
        allows the instance to identify unambiguously which lazy constraint should be
        generated. In the Traveling Salesman Problem, for example, a subtour
        violation could be a frozen set containing the cities in the subtour.
        For a concrete example, see TravelingSalesmanInstance.
        &#34;&#34;&#34;
        return []
    def build_lazy_constraint(self, model, violation):
        &#34;&#34;&#34;
        Returns a Pyomo constraint which fixes a given violation.
        This method is typically called immediately after
        find_violated_lazy_constraints. The violation object provided to this method
        is exactly the same object returned earlier by
        find_violated_lazy_constraints. After some training, LearningSolver may
        decide to proactively build some lazy constraints at the beginning of the
        optimization process, before a solution is even available. In this case,
        build_lazy_constraints will be called without a corresponding call to
        find_violated_lazy_constraints.
        The implementation should not directly add the constraint to the model. The
        constraint will be added by LearningSolver after the method returns.
        For a concrete example, see TravelingSalesmanInstance.
        &#34;&#34;&#34;
        pass
    def find_violated_user_cuts(self, model):
        return []
    def build_user_cut(self, model, violation):
        pass
    def load(self, filename):
        with gzip.GzipFile(filename, &#34;r&#34;) as f:
            data = json.loads(f.read().decode(&#34;utf-8&#34;))
        self.__dict__ = data
    def dump(self, filename):
        data = json.dumps(self.__dict__, indent=2).encode(&#34;utf-8&#34;)
        with gzip.GzipFile(filename, &#34;w&#34;) as f:
            f.write(data)</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.instance.Instance"><code class="flex name class">
 <span>class <span class="ident">Instance</span></span>
 </code></dt>
 <dd>
 <section class="desc"><p>Abstract class holding all the data necessary to generate a concrete model of the
 problem.</p>
 <p>In the knapsack problem, for example, this class could hold the number of items,
 their weights and costs, as well as the size of the knapsack. Objects
 implementing this class are able to convert themselves into a concrete
 optimization model, which can be optimized by a solver, or into arrays of
 features, which can be provided as inputs to machine learning models.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class Instance(ABC):
    &#34;&#34;&#34;
    Abstract class holding all the data necessary to generate a concrete model of the
    problem.
    In the knapsack problem, for example, this class could hold the number of items,
    their weights and costs, as well as the size of the knapsack. Objects
    implementing this class are able to convert themselves into a concrete
    optimization model, which can be optimized by a solver, or into arrays of
    features, which can be provided as inputs to machine learning models.
    &#34;&#34;&#34;
    def __init__(self):
        self.training_data: List[TrainingSample] = []
    @abstractmethod
    def to_model(self) -&gt; Any:
        &#34;&#34;&#34;
        Returns the optimization model corresponding to this instance.
        &#34;&#34;&#34;
        pass
    def get_instance_features(self):
        &#34;&#34;&#34;
        Returns a 1-dimensional Numpy array of (numerical) features describing the
        entire instance.
        The array is used by LearningSolver to determine how similar two instances
        are. It may also be used to predict, in combination with variable-specific
        features, the values of binary decision variables in the problem.
        There is not necessarily a one-to-one correspondence between models and
        instance features: the features may encode only part of the data necessary to
        generate the complete model. Features may also be statistics computed from
        the original data. For example, in the knapsack problem, an implementation
        may decide to provide as instance features only the average weights, average
        prices, number of items and the size of the knapsack.
        The returned array MUST have the same length for all relevant instances of
        the problem. If two instances map into arrays of different lengths,
        they cannot be solved by the same LearningSolver object.
        By default, returns [0].
        &#34;&#34;&#34;
        return np.zeros(1)
    def get_variable_features(self, var, index):
        &#34;&#34;&#34;
        Returns a 1-dimensional array of (numerical) features describing a particular
        decision variable.
        The argument `var` is a pyomo.core.Var object, which represents a collection
        of decision variables. The argument `index` specifies which variable in the
        collection is the relevant one.
        In combination with instance features, variable features are used by
        LearningSolver to predict, among other things, the optimal value of each
        decision variable before the optimization takes place. In the knapsack
        problem, for example, an implementation could provide as variable features
        the weight and the price of a specific item.
        Like instance features, the arrays returned by this method MUST have the same
        length for all variables within the same category, for all relevant instances
        of the problem.
        By default, returns [0].
        &#34;&#34;&#34;
        return np.zeros(1)
    def get_variable_category(self, var, index):
        &#34;&#34;&#34;
        Returns the category (a string, an integer or any hashable type) for each
        decision variable.
        If two variables have the same category, LearningSolver will use the same
        internal ML model to predict the values of both variables. If the returned
        category is None, ML models will ignore the variable.
        By default, returns &#34;default&#34;.
        &#34;&#34;&#34;
        return &#34;default&#34;
    def get_constraint_features(self, cid):
        return np.zeros(1)
    def get_constraint_category(self, cid):
        return cid
    def has_static_lazy_constraints(self):
        return False
    def has_dynamic_lazy_constraints(self):
        return False
    def is_constraint_lazy(self, cid):
        return False
    def find_violated_lazy_constraints(self, model):
        &#34;&#34;&#34;
        Returns lazy constraint violations found for the current solution.
        After solving a model, LearningSolver will ask the instance to identify which
        lazy constraints are violated by the current solution. For each identified
        violation, LearningSolver will then call the build_lazy_constraint, add the
        generated Pyomo constraint to the model, then resolve the problem. The
        process repeats until no further lazy constraint violations are found.
        Each &#34;violation&#34; is simply a string, a tuple or any other hashable type which
        allows the instance to identify unambiguously which lazy constraint should be
        generated. In the Traveling Salesman Problem, for example, a subtour
        violation could be a frozen set containing the cities in the subtour.
        For a concrete example, see TravelingSalesmanInstance.
        &#34;&#34;&#34;
        return []
    def build_lazy_constraint(self, model, violation):
        &#34;&#34;&#34;
        Returns a Pyomo constraint which fixes a given violation.
        This method is typically called immediately after
        find_violated_lazy_constraints. The violation object provided to this method
        is exactly the same object returned earlier by
        find_violated_lazy_constraints. After some training, LearningSolver may
        decide to proactively build some lazy constraints at the beginning of the
        optimization process, before a solution is even available. In this case,
        build_lazy_constraints will be called without a corresponding call to
        find_violated_lazy_constraints.
        The implementation should not directly add the constraint to the model. The
        constraint will be added by LearningSolver after the method returns.
        For a concrete example, see TravelingSalesmanInstance.
        &#34;&#34;&#34;
        pass
    def find_violated_user_cuts(self, model):
        return []
    def build_user_cut(self, model, violation):
        pass
    def load(self, filename):
        with gzip.GzipFile(filename, &#34;r&#34;) as f:
            data = json.loads(f.read().decode(&#34;utf-8&#34;))
        self.__dict__ = data
    def dump(self, filename):
        data = json.dumps(self.__dict__, indent=2).encode(&#34;utf-8&#34;)
        with gzip.GzipFile(filename, &#34;w&#34;) as f:
            f.write(data)</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li>abc.ABC</li>
 </ul>
 <h3>Subclasses</h3>
 <ul class="hlist">
 <li><a title="miplearn.problems.knapsack.KnapsackInstance" href="problems/knapsack.html#miplearn.problems.knapsack.KnapsackInstance">KnapsackInstance</a></li>
 <li><a title="miplearn.problems.knapsack.MultiKnapsackInstance" href="problems/knapsack.html#miplearn.problems.knapsack.MultiKnapsackInstance">MultiKnapsackInstance</a></li>
 <li><a title="miplearn.problems.stab.MaxWeightStableSetInstance" href="problems/stab.html#miplearn.problems.stab.MaxWeightStableSetInstance">MaxWeightStableSetInstance</a></li>
 <li><a title="miplearn.problems.tsp.TravelingSalesmanInstance" href="problems/tsp.html#miplearn.problems.tsp.TravelingSalesmanInstance">TravelingSalesmanInstance</a></li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.instance.Instance.build_lazy_constraint"><code class="name flex">
 <span>def <span class="ident">build_lazy_constraint</span></span>(<span>self, model, violation)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Returns a Pyomo constraint which fixes a given violation.</p>
 <p>This method is typically called immediately after
 find_violated_lazy_constraints. The violation object provided to this method
 is exactly the same object returned earlier by
 find_violated_lazy_constraints. After some training, LearningSolver may
 decide to proactively build some lazy constraints at the beginning of the
 optimization process, before a solution is even available. In this case,
 build_lazy_constraints will be called without a corresponding call to
 find_violated_lazy_constraints.</p>
 <p>The implementation should not directly add the constraint to the model. The
 constraint will be added by LearningSolver after the method returns.</p>
 <p>For a concrete example, see TravelingSalesmanInstance.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def build_lazy_constraint(self, model, violation):
    &#34;&#34;&#34;
    Returns a Pyomo constraint which fixes a given violation.
    This method is typically called immediately after
    find_violated_lazy_constraints. The violation object provided to this method
    is exactly the same object returned earlier by
    find_violated_lazy_constraints. After some training, LearningSolver may
    decide to proactively build some lazy constraints at the beginning of the
    optimization process, before a solution is even available. In this case,
    build_lazy_constraints will be called without a corresponding call to
    find_violated_lazy_constraints.
    The implementation should not directly add the constraint to the model. The
    constraint will be added by LearningSolver after the method returns.
    For a concrete example, see TravelingSalesmanInstance.
    &#34;&#34;&#34;
    pass</code></pre>
 </details>
 </dd>
 <dt id="miplearn.instance.Instance.build_user_cut"><code class="name flex">
 <span>def <span class="ident">build_user_cut</span></span>(<span>self, model, violation)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def build_user_cut(self, model, violation):
    pass</code></pre>
 </details>
 </dd>
 <dt id="miplearn.instance.Instance.dump"><code class="name flex">
 <span>def <span class="ident">dump</span></span>(<span>self, filename)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def dump(self, filename):
    data = json.dumps(self.__dict__, indent=2).encode(&#34;utf-8&#34;)
    with gzip.GzipFile(filename, &#34;w&#34;) as f:
        f.write(data)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.instance.Instance.find_violated_lazy_constraints"><code class="name flex">
 <span>def <span class="ident">find_violated_lazy_constraints</span></span>(<span>self, model)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Returns lazy constraint violations found for the current solution.</p>
 <p>After solving a model, LearningSolver will ask the instance to identify which
 lazy constraints are violated by the current solution. For each identified
 violation, LearningSolver will then call the build_lazy_constraint, add the
 generated Pyomo constraint to the model, then resolve the problem. The
 process repeats until no further lazy constraint violations are found.</p>
 <p>Each "violation" is simply a string, a tuple or any other hashable type which
 allows the instance to identify unambiguously which lazy constraint should be
 generated. In the Traveling Salesman Problem, for example, a subtour
 violation could be a frozen set containing the cities in the subtour.</p>
 <p>For a concrete example, see TravelingSalesmanInstance.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def find_violated_lazy_constraints(self, model):
    &#34;&#34;&#34;
    Returns lazy constraint violations found for the current solution.
    After solving a model, LearningSolver will ask the instance to identify which
    lazy constraints are violated by the current solution. For each identified
    violation, LearningSolver will then call the build_lazy_constraint, add the
    generated Pyomo constraint to the model, then resolve the problem. The
    process repeats until no further lazy constraint violations are found.
    Each &#34;violation&#34; is simply a string, a tuple or any other hashable type which
    allows the instance to identify unambiguously which lazy constraint should be
    generated. In the Traveling Salesman Problem, for example, a subtour
    violation could be a frozen set containing the cities in the subtour.
    For a concrete example, see TravelingSalesmanInstance.
    &#34;&#34;&#34;
    return []</code></pre>
 </details>
 </dd>
 <dt id="miplearn.instance.Instance.find_violated_user_cuts"><code class="name flex">
 <span>def <span class="ident">find_violated_user_cuts</span></span>(<span>self, model)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def find_violated_user_cuts(self, model):
    return []</code></pre>
 </details>
 </dd>
 <dt id="miplearn.instance.Instance.get_constraint_category"><code class="name flex">
 <span>def <span class="ident">get_constraint_category</span></span>(<span>self, cid)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def get_constraint_category(self, cid):
    return cid</code></pre>
 </details>
 </dd>
 <dt id="miplearn.instance.Instance.get_constraint_features"><code class="name flex">
 <span>def <span class="ident">get_constraint_features</span></span>(<span>self, cid)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def get_constraint_features(self, cid):
    return np.zeros(1)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.instance.Instance.get_instance_features"><code class="name flex">
 <span>def <span class="ident">get_instance_features</span></span>(<span>self)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Returns a 1-dimensional Numpy array of (numerical) features describing the
 entire instance.</p>
 <p>The array is used by LearningSolver to determine how similar two instances
 are. It may also be used to predict, in combination with variable-specific
 features, the values of binary decision variables in the problem.</p>
 <p>There is not necessarily a one-to-one correspondence between models and
 instance features: the features may encode only part of the data necessary to
 generate the complete model. Features may also be statistics computed from
 the original data. For example, in the knapsack problem, an implementation
 may decide to provide as instance features only the average weights, average
 prices, number of items and the size of the knapsack.</p>
 <p>The returned array MUST have the same length for all relevant instances of
 the problem. If two instances map into arrays of different lengths,
 they cannot be solved by the same LearningSolver object.</p>
 <p>By default, returns [0].</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def get_instance_features(self):
    &#34;&#34;&#34;
    Returns a 1-dimensional Numpy array of (numerical) features describing the
    entire instance.
    The array is used by LearningSolver to determine how similar two instances
    are. It may also be used to predict, in combination with variable-specific
    features, the values of binary decision variables in the problem.
    There is not necessarily a one-to-one correspondence between models and
    instance features: the features may encode only part of the data necessary to
    generate the complete model. Features may also be statistics computed from
    the original data. For example, in the knapsack problem, an implementation
    may decide to provide as instance features only the average weights, average
    prices, number of items and the size of the knapsack.
    The returned array MUST have the same length for all relevant instances of
    the problem. If two instances map into arrays of different lengths,
    they cannot be solved by the same LearningSolver object.
    By default, returns [0].
    &#34;&#34;&#34;
    return np.zeros(1)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.instance.Instance.get_variable_category"><code class="name flex">
 <span>def <span class="ident">get_variable_category</span></span>(<span>self, var, index)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Returns the category (a string, an integer or any hashable type) for each
 decision variable.</p>
 <p>If two variables have the same category, LearningSolver will use the same
 internal ML model to predict the values of both variables. If the returned
 category is None, ML models will ignore the variable.</p>
 <p>By default, returns "default".</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def get_variable_category(self, var, index):
    &#34;&#34;&#34;
    Returns the category (a string, an integer or any hashable type) for each
    decision variable.
    If two variables have the same category, LearningSolver will use the same
    internal ML model to predict the values of both variables. If the returned
    category is None, ML models will ignore the variable.
    By default, returns &#34;default&#34;.
    &#34;&#34;&#34;
    return &#34;default&#34;</code></pre>
 </details>
 </dd>
 <dt id="miplearn.instance.Instance.get_variable_features"><code class="name flex">
 <span>def <span class="ident">get_variable_features</span></span>(<span>self, var, index)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Returns a 1-dimensional array of (numerical) features describing a particular
 decision variable.</p>
 <p>The argument <code>var</code> is a pyomo.core.Var object, which represents a collection
 of decision variables. The argument <code>index</code> specifies which variable in the
 collection is the relevant one.</p>
 <p>In combination with instance features, variable features are used by
 LearningSolver to predict, among other things, the optimal value of each
 decision variable before the optimization takes place. In the knapsack
 problem, for example, an implementation could provide as variable features
 the weight and the price of a specific item.</p>
 <p>Like instance features, the arrays returned by this method MUST have the same
 length for all variables within the same category, for all relevant instances
 of the problem.</p>
 <p>By default, returns [0].</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def get_variable_features(self, var, index):
    &#34;&#34;&#34;
    Returns a 1-dimensional array of (numerical) features describing a particular
    decision variable.
    The argument `var` is a pyomo.core.Var object, which represents a collection
    of decision variables. The argument `index` specifies which variable in the
    collection is the relevant one.
    In combination with instance features, variable features are used by
    LearningSolver to predict, among other things, the optimal value of each
    decision variable before the optimization takes place. In the knapsack
    problem, for example, an implementation could provide as variable features
    the weight and the price of a specific item.
    Like instance features, the arrays returned by this method MUST have the same
    length for all variables within the same category, for all relevant instances
    of the problem.
    By default, returns [0].
    &#34;&#34;&#34;
    return np.zeros(1)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.instance.Instance.has_dynamic_lazy_constraints"><code class="name flex">
 <span>def <span class="ident">has_dynamic_lazy_constraints</span></span>(<span>self)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def has_dynamic_lazy_constraints(self):
    return False</code></pre>
 </details>
 </dd>
 <dt id="miplearn.instance.Instance.has_static_lazy_constraints"><code class="name flex">
 <span>def <span class="ident">has_static_lazy_constraints</span></span>(<span>self)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def has_static_lazy_constraints(self):
    return False</code></pre>
 </details>
 </dd>
 <dt id="miplearn.instance.Instance.is_constraint_lazy"><code class="name flex">
 <span>def <span class="ident">is_constraint_lazy</span></span>(<span>self, cid)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def is_constraint_lazy(self, cid):
    return False</code></pre>
 </details>
 </dd>
 <dt id="miplearn.instance.Instance.load"><code class="name flex">
 <span>def <span class="ident">load</span></span>(<span>self, filename)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def load(self, filename):
    with gzip.GzipFile(filename, &#34;r&#34;) as f:
        data = json.loads(f.read().decode(&#34;utf-8&#34;))
    self.__dict__ = data</code></pre>
 </details>
 </dd>
 <dt id="miplearn.instance.Instance.to_model"><code class="name flex">
 <span>def <span class="ident">to_model</span></span>(<span>self)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Returns the optimization model corresponding to this instance.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">@abstractmethod
 def to_model(self) -&gt; Any:
    &#34;&#34;&#34;
    Returns the optimization model corresponding to this instance.
    &#34;&#34;&#34;
    pass</code></pre>
 </details>
 </dd>
 </dl>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn" href="index.html">miplearn</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.instance.Instance" href="#miplearn.instance.Instance">Instance</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.instance.Instance.build_lazy_constraint" href="#miplearn.instance.Instance.build_lazy_constraint">build_lazy_constraint</a></code></li>
 <li><code><a title="miplearn.instance.Instance.build_user_cut" href="#miplearn.instance.Instance.build_user_cut">build_user_cut</a></code></li>
 <li><code><a title="miplearn.instance.Instance.dump" href="#miplearn.instance.Instance.dump">dump</a></code></li>
 <li><code><a title="miplearn.instance.Instance.find_violated_lazy_constraints" href="#miplearn.instance.Instance.find_violated_lazy_constraints">find_violated_lazy_constraints</a></code></li>
 <li><code><a title="miplearn.instance.Instance.find_violated_user_cuts" href="#miplearn.instance.Instance.find_violated_user_cuts">find_violated_user_cuts</a></code></li>
 <li><code><a title="miplearn.instance.Instance.get_constraint_category" href="#miplearn.instance.Instance.get_constraint_category">get_constraint_category</a></code></li>
 <li><code><a title="miplearn.instance.Instance.get_constraint_features" href="#miplearn.instance.Instance.get_constraint_features">get_constraint_features</a></code></li>
 <li><code><a title="miplearn.instance.Instance.get_instance_features" href="#miplearn.instance.Instance.get_instance_features">get_instance_features</a></code></li>
 <li><code><a title="miplearn.instance.Instance.get_variable_category" href="#miplearn.instance.Instance.get_variable_category">get_variable_category</a></code></li>
 <li><code><a title="miplearn.instance.Instance.get_variable_features" href="#miplearn.instance.Instance.get_variable_features">get_variable_features</a></code></li>
 <li><code><a title="miplearn.instance.Instance.has_dynamic_lazy_constraints" href="#miplearn.instance.Instance.has_dynamic_lazy_constraints">has_dynamic_lazy_constraints</a></code></li>
 <li><code><a title="miplearn.instance.Instance.has_static_lazy_constraints" href="#miplearn.instance.Instance.has_static_lazy_constraints">has_static_lazy_constraints</a></code></li>
 <li><code><a title="miplearn.instance.Instance.is_constraint_lazy" href="#miplearn.instance.Instance.is_constraint_lazy">is_constraint_lazy</a></code></li>
 <li><code><a title="miplearn.instance.Instance.load" href="#miplearn.instance.Instance.load">load</a></code></li>
 <li><code><a title="miplearn.instance.Instance.to_model" href="#miplearn.instance.Instance.to_model">to_model</a></code></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/log.html
+++ b/0.2/api/miplearn/log.html
@ -1,294 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.log API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.log</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import logging
 import sys
 import time
 class TimeFormatter(logging.Formatter):
    def __init__(self, start_time, log_colors):
        super().__init__()
        self.start_time = start_time
        self.log_colors = log_colors
    def format(self, record):
        if record.levelno &gt;= logging.ERROR:
            color = self.log_colors[&#34;red&#34;]
        elif record.levelno &gt;= logging.WARNING:
            color = self.log_colors[&#34;yellow&#34;]
        else:
            color = self.log_colors[&#34;green&#34;]
        return &#34;%s[%12.3f]%s %s&#34; % (
            color,
            record.created - self.start_time,
            self.log_colors[&#34;reset&#34;],
            record.getMessage(),
        )
 def setup_logger(start_time=None, force_color=False):
    if start_time is None:
        start_time = time.time()
    if sys.stdout.isatty() or force_color:
        log_colors = {
            &#34;green&#34;: &#34;\033[92m&#34;,
            &#34;yellow&#34;: &#34;\033[93m&#34;,
            &#34;red&#34;: &#34;\033[91m&#34;,
            &#34;reset&#34;: &#34;\033[0m&#34;,
        }
    else:
        log_colors = {
            &#34;green&#34;: &#34;&#34;,
            &#34;yellow&#34;: &#34;&#34;,
            &#34;red&#34;: &#34;&#34;,
            &#34;reset&#34;: &#34;&#34;,
        }
    handler = logging.StreamHandler()
    handler.setFormatter(TimeFormatter(start_time, log_colors))
    logging.getLogger().addHandler(handler)
    logging.getLogger(&#34;miplearn&#34;).setLevel(logging.INFO)</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-functions">Functions</h2>
 <dl>
 <dt id="miplearn.log.setup_logger"><code class="name flex">
 <span>def <span class="ident">setup_logger</span></span>(<span>start_time=None, force_color=False)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def setup_logger(start_time=None, force_color=False):
    if start_time is None:
        start_time = time.time()
    if sys.stdout.isatty() or force_color:
        log_colors = {
            &#34;green&#34;: &#34;\033[92m&#34;,
            &#34;yellow&#34;: &#34;\033[93m&#34;,
            &#34;red&#34;: &#34;\033[91m&#34;,
            &#34;reset&#34;: &#34;\033[0m&#34;,
        }
    else:
        log_colors = {
            &#34;green&#34;: &#34;&#34;,
            &#34;yellow&#34;: &#34;&#34;,
            &#34;red&#34;: &#34;&#34;,
            &#34;reset&#34;: &#34;&#34;,
        }
    handler = logging.StreamHandler()
    handler.setFormatter(TimeFormatter(start_time, log_colors))
    logging.getLogger().addHandler(handler)
    logging.getLogger(&#34;miplearn&#34;).setLevel(logging.INFO)</code></pre>
 </details>
 </dd>
 </dl>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.log.TimeFormatter"><code class="flex name class">
 <span>class <span class="ident">TimeFormatter</span></span>
 <span>(</span><span>start_time, log_colors)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Formatter instances are used to convert a LogRecord to text.</p>
 <p>Formatters need to know how a LogRecord is constructed. They are
 responsible for converting a LogRecord to (usually) a string which can
 be interpreted by either a human or an external system. The base Formatter
 allows a formatting string to be specified. If none is supplied, the
 the style-dependent default value, "%(message)s", "{message}", or
 "${message}", is used.</p>
 <p>The Formatter can be initialized with a format string which makes use of
 knowledge of the LogRecord attributes - e.g. the default value mentioned
 above makes use of the fact that the user's message and arguments are pre-
 formatted into a LogRecord's message attribute. Currently, the useful
 attributes in a LogRecord are described by:</p>
 <p>%(name)s
 Name of the logger (logging channel)
 %(levelno)s
 Numeric logging level for the message (DEBUG, INFO,
 WARNING, ERROR, CRITICAL)
 %(levelname)s
 Text logging level for the message ("DEBUG", "INFO",
 "WARNING", "ERROR", "CRITICAL")
 %(pathname)s
 Full pathname of the source file where the logging
 call was issued (if available)
 %(filename)s
 Filename portion of pathname
 %(module)s
 Module (name portion of filename)
 %(lineno)d
 Source line number where the logging call was issued
 (if available)
 %(funcName)s
 Function name
 %(created)f
 Time when the LogRecord was created (time.time()
 return value)
 %(asctime)s
 Textual time when the LogRecord was created
 %(msecs)d
 Millisecond portion of the creation time
 %(relativeCreated)d Time in milliseconds when the LogRecord was created,
 relative to the time the logging module was loaded
 (typically at application startup time)
 %(thread)d
 Thread ID (if available)
 %(threadName)s
 Thread name (if available)
 %(process)d
 Process ID (if available)
 %(message)s
 The result of record.getMessage(), computed just as
 the record is emitted</p>
 <p>Initialize the formatter with specified format strings.</p>
 <p>Initialize the formatter either with the specified format string, or a
 default as described above. Allow for specialized date formatting with
 the optional datefmt argument. If datefmt is omitted, you get an
 ISO8601-like (or RFC 3339-like) format.</p>
 <p>Use a style parameter of '%', '{' or '$' to specify that you want to
 use one of %-formatting, :meth:<code>str.format</code> (<code>{}</code>) formatting or
 :class:<code>string.Template</code> formatting in your format string.</p>
 <div class="admonition versionchanged">
 <p class="admonition-title">Changed in version:&ensp;3.2</p>
 <p>Added the <code>style</code> parameter.</p>
 </div></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class TimeFormatter(logging.Formatter):
    def __init__(self, start_time, log_colors):
        super().__init__()
        self.start_time = start_time
        self.log_colors = log_colors
    def format(self, record):
        if record.levelno &gt;= logging.ERROR:
            color = self.log_colors[&#34;red&#34;]
        elif record.levelno &gt;= logging.WARNING:
            color = self.log_colors[&#34;yellow&#34;]
        else:
            color = self.log_colors[&#34;green&#34;]
        return &#34;%s[%12.3f]%s %s&#34; % (
            color,
            record.created - self.start_time,
            self.log_colors[&#34;reset&#34;],
            record.getMessage(),
        )</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li>logging.Formatter</li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.log.TimeFormatter.format"><code class="name flex">
 <span>def <span class="ident">format</span></span>(<span>self, record)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Format the specified record as text.</p>
 <p>The record's attribute dictionary is used as the operand to a
 string formatting operation which yields the returned string.
 Before formatting the dictionary, a couple of preparatory steps
 are carried out. The message attribute of the record is computed
 using LogRecord.getMessage(). If the formatting string uses the
 time (as determined by a call to usesTime(), formatTime() is
 called to format the event time. If there is exception information,
 it is formatted using formatException() and appended to the message.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def format(self, record):
    if record.levelno &gt;= logging.ERROR:
        color = self.log_colors[&#34;red&#34;]
    elif record.levelno &gt;= logging.WARNING:
        color = self.log_colors[&#34;yellow&#34;]
    else:
        color = self.log_colors[&#34;green&#34;]
    return &#34;%s[%12.3f]%s %s&#34; % (
        color,
        record.created - self.start_time,
        self.log_colors[&#34;reset&#34;],
        record.getMessage(),
    )</code></pre>
 </details>
 </dd>
 </dl>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn" href="index.html">miplearn</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-functions">Functions</a></h3>
 <ul class="">
 <li><code><a title="miplearn.log.setup_logger" href="#miplearn.log.setup_logger">setup_logger</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.log.TimeFormatter" href="#miplearn.log.TimeFormatter">TimeFormatter</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.log.TimeFormatter.format" href="#miplearn.log.TimeFormatter.format">format</a></code></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/problems/index.html
+++ b/0.2/api/miplearn/problems/index.html
@ -1,83 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.problems API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.problems</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.</code></pre>
 </details>
 </section>
 <section>
 <h2 class="section-title" id="header-submodules">Sub-modules</h2>
 <dl>
 <dt><code class="name"><a title="miplearn.problems.knapsack" href="knapsack.html">miplearn.problems.knapsack</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.problems.stab" href="stab.html">miplearn.problems.stab</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.problems.tsp" href="tsp.html">miplearn.problems.tsp</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 </dl>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn" href="../index.html">miplearn</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-submodules">Sub-modules</a></h3>
 <ul>
 <li><code><a title="miplearn.problems.knapsack" href="knapsack.html">miplearn.problems.knapsack</a></code></li>
 <li><code><a title="miplearn.problems.stab" href="stab.html">miplearn.problems.stab</a></code></li>
 <li><code><a title="miplearn.problems.tsp" href="tsp.html">miplearn.problems.tsp</a></code></li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/problems/knapsack.html
+++ b/0.2/api/miplearn/problems/knapsack.html
@ -1,881 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.problems.knapsack API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.problems.knapsack</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import numpy as np
 import pyomo.environ as pe
 from scipy.stats import uniform, randint
 from scipy.stats.distributions import rv_frozen
 from miplearn.instance import Instance
 class ChallengeA:
    &#34;&#34;&#34;
    - 250 variables, 10 constraints, fixed weights
    - w ~ U(0, 1000), jitter ~ U(0.95, 1.05)
    - K = 500, u ~ U(0., 1.)
    - alpha = 0.25
    &#34;&#34;&#34;
    def __init__(
        self,
        seed=42,
        n_training_instances=500,
        n_test_instances=50,
    ):
        np.random.seed(seed)
        self.gen = MultiKnapsackGenerator(
            n=randint(low=250, high=251),
            m=randint(low=10, high=11),
            w=uniform(loc=0.0, scale=1000.0),
            K=uniform(loc=500.0, scale=0.0),
            u=uniform(loc=0.0, scale=1.0),
            alpha=uniform(loc=0.25, scale=0.0),
            fix_w=True,
            w_jitter=uniform(loc=0.95, scale=0.1),
        )
        np.random.seed(seed + 1)
        self.training_instances = self.gen.generate(n_training_instances)
        np.random.seed(seed + 2)
        self.test_instances = self.gen.generate(n_test_instances)
 class MultiKnapsackInstance(Instance):
    &#34;&#34;&#34;Representation of the Multidimensional 0-1 Knapsack Problem.
    Given a set of n items and m knapsacks, the problem is to find a subset of items S maximizing
    sum(prices[i] for i in S). If selected, each item i occupies weights[i,j] units of space in
    each knapsack j. Furthermore, each knapsack j has limited storage space, given by capacities[j].
    This implementation assigns a different category for each decision variable, and therefore
    trains one ML model per variable. It is only suitable when training and test instances have
    same size and items don&#39;t shuffle around.
    &#34;&#34;&#34;
    def __init__(self, prices, capacities, weights):
        super().__init__()
        assert isinstance(prices, np.ndarray)
        assert isinstance(capacities, np.ndarray)
        assert isinstance(weights, np.ndarray)
        assert len(weights.shape) == 2
        self.m, self.n = weights.shape
        assert prices.shape == (self.n,)
        assert capacities.shape == (self.m,)
        self.prices = prices
        self.capacities = capacities
        self.weights = weights
    def to_model(self):
        model = pe.ConcreteModel()
        model.x = pe.Var(range(self.n), domain=pe.Binary)
        model.OBJ = pe.Objective(
            rule=lambda model: sum(model.x[j] * self.prices[j] for j in range(self.n)),
            sense=pe.maximize,
        )
        model.eq_capacity = pe.ConstraintList()
        for i in range(self.m):
            model.eq_capacity.add(
                sum(model.x[j] * self.weights[i, j] for j in range(self.n))
                &lt;= self.capacities[i]
            )
        return model
    def get_instance_features(self):
        return np.hstack(
            [
                np.mean(self.prices),
                self.capacities,
            ]
        )
    def get_variable_features(self, var, index):
        return np.hstack(
            [
                self.prices[index],
                self.weights[:, index],
            ]
        )
 #     def get_variable_category(self, var, index):
 #         return index
 class MultiKnapsackGenerator:
    def __init__(
        self,
        n=randint(low=100, high=101),
        m=randint(low=30, high=31),
        w=randint(low=0, high=1000),
        K=randint(low=500, high=500),
        u=uniform(loc=0.0, scale=1.0),
        alpha=uniform(loc=0.25, scale=0.0),
        fix_w=False,
        w_jitter=uniform(loc=1.0, scale=0.0),
        round=True,
    ):
        &#34;&#34;&#34;Initialize the problem generator.
        Instances have a random number of items (or variables) and a random number of knapsacks
        (or constraints), as specified by the provided probability distributions `n` and `m`,
        respectively. The weight of each item `i` on knapsack `j` is sampled independently from
        the provided distribution `w`. The capacity of knapsack `j` is set to:
            alpha_j * sum(w[i,j] for i in range(n)),
        where `alpha_j`, the tightness ratio, is sampled from the provided probability
        distribution `alpha`. To make the instances more challenging, the costs of the items
        are linearly correlated to their average weights. More specifically, the weight of each
        item `i` is set to:
            sum(w[i,j]/m for j in range(m)) + K * u_i,
        where `K`, the correlation coefficient, and `u_i`, the correlation multiplier, are sampled
        from the provided probability distributions. Note that `K` is only sample once for the
        entire instance.
        If fix_w=True is provided, then w[i,j] are kept the same in all generated instances. This
        also implies that n and m are kept fixed. Although the prices and capacities are derived
        from w[i,j], as long as u and K are not constants, the generated instances will still not
        be completely identical.
        If a probability distribution w_jitter is provided, then item weights will be set to
        w[i,j] * gamma[i,j] where gamma[i,j] is sampled from w_jitter. When combined with
        fix_w=True, this argument may be used to generate instances where the weight of each item
        is roughly the same, but not exactly identical, across all instances. The prices of the
        items and the capacities of the knapsacks will be calculated as above, but using these
        perturbed weights instead.
        By default, all generated prices, weights and capacities are rounded to the nearest integer
        number. If `round=False` is provided, this rounding will be disabled.
        Parameters
        ----------
        n: rv_discrete
            Probability distribution for the number of items (or variables)
        m: rv_discrete
            Probability distribution for the number of knapsacks (or constraints)
        w: rv_continuous
            Probability distribution for the item weights
        K: rv_continuous
            Probability distribution for the profit correlation coefficient
        u: rv_continuous
            Probability distribution for the profit multiplier
        alpha: rv_continuous
            Probability distribution for the tightness ratio
        fix_w: boolean
            If true, weights are kept the same (minus the noise from w_jitter) in all instances
        w_jitter: rv_continuous
            Probability distribution for random noise added to the weights
        round: boolean
            If true, all prices, weights and capacities are rounded to the nearest integer
        &#34;&#34;&#34;
        assert isinstance(n, rv_frozen), &#34;n should be a SciPy probability distribution&#34;
        assert isinstance(m, rv_frozen), &#34;m should be a SciPy probability distribution&#34;
        assert isinstance(w, rv_frozen), &#34;w should be a SciPy probability distribution&#34;
        assert isinstance(K, rv_frozen), &#34;K should be a SciPy probability distribution&#34;
        assert isinstance(u, rv_frozen), &#34;u should be a SciPy probability distribution&#34;
        assert isinstance(
            alpha, rv_frozen
        ), &#34;alpha should be a SciPy probability distribution&#34;
        assert isinstance(fix_w, bool), &#34;fix_w should be boolean&#34;
        assert isinstance(
            w_jitter, rv_frozen
        ), &#34;w_jitter should be a SciPy probability distribution&#34;
        self.n = n
        self.m = m
        self.w = w
        self.K = K
        self.u = u
        self.alpha = alpha
        self.w_jitter = w_jitter
        self.round = round
        if fix_w:
            self.fix_n = self.n.rvs()
            self.fix_m = self.m.rvs()
            self.fix_w = np.array([self.w.rvs(self.fix_n) for _ in range(self.fix_m)])
            self.fix_u = self.u.rvs(self.fix_n)
            self.fix_K = self.K.rvs()
        else:
            self.fix_n = None
            self.fix_m = None
            self.fix_w = None
            self.fix_u = None
            self.fix_K = None
    def generate(self, n_samples):
        def _sample():
            if self.fix_w is not None:
                n = self.fix_n
                m = self.fix_m
                w = self.fix_w
                u = self.fix_u
                K = self.fix_K
            else:
                n = self.n.rvs()
                m = self.m.rvs()
                w = np.array([self.w.rvs(n) for _ in range(m)])
                u = self.u.rvs(n)
                K = self.K.rvs()
            w = w * np.array([self.w_jitter.rvs(n) for _ in range(m)])
            alpha = self.alpha.rvs(m)
            p = np.array([w[:, j].sum() / m + K * u[j] for j in range(n)])
            b = np.array([w[i, :].sum() * alpha[i] for i in range(m)])
            if self.round:
                p = p.round()
                b = b.round()
                w = w.round()
            return MultiKnapsackInstance(p, b, w)
        return [_sample() for _ in range(n_samples)]
 class KnapsackInstance(Instance):
    &#34;&#34;&#34;
    Simpler (one-dimensional) Knapsack Problem, used for testing.
    &#34;&#34;&#34;
    def __init__(self, weights, prices, capacity):
        super().__init__()
        self.weights = weights
        self.prices = prices
        self.capacity = capacity
    def to_model(self):
        model = pe.ConcreteModel()
        items = range(len(self.weights))
        model.x = pe.Var(items, domain=pe.Binary)
        model.OBJ = pe.Objective(
            expr=sum(model.x[v] * self.prices[v] for v in items), sense=pe.maximize
        )
        model.eq_capacity = pe.Constraint(
            expr=sum(model.x[v] * self.weights[v] for v in items) &lt;= self.capacity
        )
        return model
    def get_instance_features(self):
        return np.array(
            [
                self.capacity,
                np.average(self.weights),
            ]
        )
    def get_variable_features(self, var, index):
        return np.array(
            [
                self.weights[index],
                self.prices[index],
            ]
        )
 class GurobiKnapsackInstance(KnapsackInstance):
    &#34;&#34;&#34;
    Simpler (one-dimensional) knapsack instance, implemented directly in Gurobi
    instead of Pyomo, used for testing.
    &#34;&#34;&#34;
    def __init__(self, weights, prices, capacity):
        super().__init__(weights, prices, capacity)
    def to_model(self):
        import gurobipy as gp
        from gurobipy import GRB
        model = gp.Model(&#34;Knapsack&#34;)
        n = len(self.weights)
        x = model.addVars(n, vtype=GRB.BINARY, name=&#34;x&#34;)
        model.addConstr(
            gp.quicksum(x[i] * self.weights[i] for i in range(n)) &lt;= self.capacity,
            &#34;eq_capacity&#34;,
        )
        model.setObjective(
            gp.quicksum(x[i] * self.prices[i] for i in range(n)), GRB.MAXIMIZE
        )
        return model</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.problems.knapsack.ChallengeA"><code class="flex name class">
 <span>class <span class="ident">ChallengeA</span></span>
 <span>(</span><span>seed=42, n_training_instances=500, n_test_instances=50)</span>
 </code></dt>
 <dd>
 <section class="desc"><ul>
 <li>250 variables, 10 constraints, fixed weights</li>
 <li>w ~ U(0, 1000), jitter ~ U(0.95, 1.05)</li>
 <li>K = 500, u ~ U(0., 1.)</li>
 <li>alpha = 0.25</li>
 </ul></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class ChallengeA:
    &#34;&#34;&#34;
    - 250 variables, 10 constraints, fixed weights
    - w ~ U(0, 1000), jitter ~ U(0.95, 1.05)
    - K = 500, u ~ U(0., 1.)
    - alpha = 0.25
    &#34;&#34;&#34;
    def __init__(
        self,
        seed=42,
        n_training_instances=500,
        n_test_instances=50,
    ):
        np.random.seed(seed)
        self.gen = MultiKnapsackGenerator(
            n=randint(low=250, high=251),
            m=randint(low=10, high=11),
            w=uniform(loc=0.0, scale=1000.0),
            K=uniform(loc=500.0, scale=0.0),
            u=uniform(loc=0.0, scale=1.0),
            alpha=uniform(loc=0.25, scale=0.0),
            fix_w=True,
            w_jitter=uniform(loc=0.95, scale=0.1),
        )
        np.random.seed(seed + 1)
        self.training_instances = self.gen.generate(n_training_instances)
        np.random.seed(seed + 2)
        self.test_instances = self.gen.generate(n_test_instances)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.problems.knapsack.GurobiKnapsackInstance"><code class="flex name class">
 <span>class <span class="ident">GurobiKnapsackInstance</span></span>
 <span>(</span><span>weights, prices, capacity)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Simpler (one-dimensional) knapsack instance, implemented directly in Gurobi
 instead of Pyomo, used for testing.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class GurobiKnapsackInstance(KnapsackInstance):
    &#34;&#34;&#34;
    Simpler (one-dimensional) knapsack instance, implemented directly in Gurobi
    instead of Pyomo, used for testing.
    &#34;&#34;&#34;
    def __init__(self, weights, prices, capacity):
        super().__init__(weights, prices, capacity)
    def to_model(self):
        import gurobipy as gp
        from gurobipy import GRB
        model = gp.Model(&#34;Knapsack&#34;)
        n = len(self.weights)
        x = model.addVars(n, vtype=GRB.BINARY, name=&#34;x&#34;)
        model.addConstr(
            gp.quicksum(x[i] * self.weights[i] for i in range(n)) &lt;= self.capacity,
            &#34;eq_capacity&#34;,
        )
        model.setObjective(
            gp.quicksum(x[i] * self.prices[i] for i in range(n)), GRB.MAXIMIZE
        )
        return model</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.problems.knapsack.KnapsackInstance" href="#miplearn.problems.knapsack.KnapsackInstance">KnapsackInstance</a></li>
 <li><a title="miplearn.instance.Instance" href="../instance.html#miplearn.instance.Instance">Instance</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.problems.knapsack.KnapsackInstance" href="#miplearn.problems.knapsack.KnapsackInstance">KnapsackInstance</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.problems.knapsack.KnapsackInstance.build_lazy_constraint" href="../instance.html#miplearn.instance.Instance.build_lazy_constraint">build_lazy_constraint</a></code></li>
 <li><code><a title="miplearn.problems.knapsack.KnapsackInstance.find_violated_lazy_constraints" href="../instance.html#miplearn.instance.Instance.find_violated_lazy_constraints">find_violated_lazy_constraints</a></code></li>
 <li><code><a title="miplearn.problems.knapsack.KnapsackInstance.get_instance_features" href="../instance.html#miplearn.instance.Instance.get_instance_features">get_instance_features</a></code></li>
 <li><code><a title="miplearn.problems.knapsack.KnapsackInstance.get_variable_category" href="../instance.html#miplearn.instance.Instance.get_variable_category">get_variable_category</a></code></li>
 <li><code><a title="miplearn.problems.knapsack.KnapsackInstance.get_variable_features" href="../instance.html#miplearn.instance.Instance.get_variable_features">get_variable_features</a></code></li>
 <li><code><a title="miplearn.problems.knapsack.KnapsackInstance.to_model" href="../instance.html#miplearn.instance.Instance.to_model">to_model</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 <dt id="miplearn.problems.knapsack.KnapsackInstance"><code class="flex name class">
 <span>class <span class="ident">KnapsackInstance</span></span>
 <span>(</span><span>weights, prices, capacity)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Simpler (one-dimensional) Knapsack Problem, used for testing.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class KnapsackInstance(Instance):
    &#34;&#34;&#34;
    Simpler (one-dimensional) Knapsack Problem, used for testing.
    &#34;&#34;&#34;
    def __init__(self, weights, prices, capacity):
        super().__init__()
        self.weights = weights
        self.prices = prices
        self.capacity = capacity
    def to_model(self):
        model = pe.ConcreteModel()
        items = range(len(self.weights))
        model.x = pe.Var(items, domain=pe.Binary)
        model.OBJ = pe.Objective(
            expr=sum(model.x[v] * self.prices[v] for v in items), sense=pe.maximize
        )
        model.eq_capacity = pe.Constraint(
            expr=sum(model.x[v] * self.weights[v] for v in items) &lt;= self.capacity
        )
        return model
    def get_instance_features(self):
        return np.array(
            [
                self.capacity,
                np.average(self.weights),
            ]
        )
    def get_variable_features(self, var, index):
        return np.array(
            [
                self.weights[index],
                self.prices[index],
            ]
        )</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.instance.Instance" href="../instance.html#miplearn.instance.Instance">Instance</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Subclasses</h3>
 <ul class="hlist">
 <li><a title="miplearn.problems.knapsack.GurobiKnapsackInstance" href="#miplearn.problems.knapsack.GurobiKnapsackInstance">GurobiKnapsackInstance</a></li>
 </ul>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.instance.Instance" href="../instance.html#miplearn.instance.Instance">Instance</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.instance.Instance.build_lazy_constraint" href="../instance.html#miplearn.instance.Instance.build_lazy_constraint">build_lazy_constraint</a></code></li>
 <li><code><a title="miplearn.instance.Instance.find_violated_lazy_constraints" href="../instance.html#miplearn.instance.Instance.find_violated_lazy_constraints">find_violated_lazy_constraints</a></code></li>
 <li><code><a title="miplearn.instance.Instance.get_instance_features" href="../instance.html#miplearn.instance.Instance.get_instance_features">get_instance_features</a></code></li>
 <li><code><a title="miplearn.instance.Instance.get_variable_category" href="../instance.html#miplearn.instance.Instance.get_variable_category">get_variable_category</a></code></li>
 <li><code><a title="miplearn.instance.Instance.get_variable_features" href="../instance.html#miplearn.instance.Instance.get_variable_features">get_variable_features</a></code></li>
 <li><code><a title="miplearn.instance.Instance.to_model" href="../instance.html#miplearn.instance.Instance.to_model">to_model</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 <dt id="miplearn.problems.knapsack.MultiKnapsackGenerator"><code class="flex name class">
 <span>class <span class="ident">MultiKnapsackGenerator</span></span>
 <span>(</span><span>n=&lt;scipy.stats._distn_infrastructure.rv_frozen object&gt;, m=&lt;scipy.stats._distn_infrastructure.rv_frozen object&gt;, w=&lt;scipy.stats._distn_infrastructure.rv_frozen object&gt;, K=&lt;scipy.stats._distn_infrastructure.rv_frozen object&gt;, u=&lt;scipy.stats._distn_infrastructure.rv_frozen object&gt;, alpha=&lt;scipy.stats._distn_infrastructure.rv_frozen object&gt;, fix_w=False, w_jitter=&lt;scipy.stats._distn_infrastructure.rv_frozen object&gt;, round=True)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Initialize the problem generator.</p>
 <p>Instances have a random number of items (or variables) and a random number of knapsacks
 (or constraints), as specified by the provided probability distributions <code>n</code> and <code>m</code>,
 respectively. The weight of each item <code>i</code> on knapsack <code>j</code> is sampled independently from
 the provided distribution <code>w</code>. The capacity of knapsack <code>j</code> is set to:</p>
 <pre><code>alpha_j * sum(w[i,j] for i in range(n)),
 </code></pre>
 <p>where <code>alpha_j</code>, the tightness ratio, is sampled from the provided probability
 distribution <code>alpha</code>. To make the instances more challenging, the costs of the items
 are linearly correlated to their average weights. More specifically, the weight of each
 item <code>i</code> is set to:</p>
 <pre><code>sum(w[i,j]/m for j in range(m)) + K * u_i,
 </code></pre>
 <p>where <code>K</code>, the correlation coefficient, and <code>u_i</code>, the correlation multiplier, are sampled
 from the provided probability distributions. Note that <code>K</code> is only sample once for the
 entire instance.</p>
 <p>If fix_w=True is provided, then w[i,j] are kept the same in all generated instances. This
 also implies that n and m are kept fixed. Although the prices and capacities are derived
 from w[i,j], as long as u and K are not constants, the generated instances will still not
 be completely identical.</p>
 <p>If a probability distribution w_jitter is provided, then item weights will be set to
 w[i,j] * gamma[i,j] where gamma[i,j] is sampled from w_jitter. When combined with
 fix_w=True, this argument may be used to generate instances where the weight of each item
 is roughly the same, but not exactly identical, across all instances. The prices of the
 items and the capacities of the knapsacks will be calculated as above, but using these
 perturbed weights instead.</p>
 <p>By default, all generated prices, weights and capacities are rounded to the nearest integer
 number. If <code>round=False</code> is provided, this rounding will be disabled.</p>
 <h2 id="parameters">Parameters</h2>
 <dl>
 <dt><strong><code>n</code></strong> :&ensp;<code>rv_discrete</code></dt>
 <dd>Probability distribution for the number of items (or variables)</dd>
 <dt><strong><code>m</code></strong> :&ensp;<code>rv_discrete</code></dt>
 <dd>Probability distribution for the number of knapsacks (or constraints)</dd>
 <dt><strong><code>w</code></strong> :&ensp;<code>rv_continuous</code></dt>
 <dd>Probability distribution for the item weights</dd>
 <dt><strong><code>K</code></strong> :&ensp;<code>rv_continuous</code></dt>
 <dd>Probability distribution for the profit correlation coefficient</dd>
 <dt><strong><code>u</code></strong> :&ensp;<code>rv_continuous</code></dt>
 <dd>Probability distribution for the profit multiplier</dd>
 <dt><strong><code>alpha</code></strong> :&ensp;<code>rv_continuous</code></dt>
 <dd>Probability distribution for the tightness ratio</dd>
 <dt><strong><code>fix_w</code></strong> :&ensp;<code>boolean</code></dt>
 <dd>If true, weights are kept the same (minus the noise from w_jitter) in all instances</dd>
 <dt><strong><code>w_jitter</code></strong> :&ensp;<code>rv_continuous</code></dt>
 <dd>Probability distribution for random noise added to the weights</dd>
 <dt><strong><code>round</code></strong> :&ensp;<code>boolean</code></dt>
 <dd>If true, all prices, weights and capacities are rounded to the nearest integer</dd>
 </dl></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class MultiKnapsackGenerator:
    def __init__(
        self,
        n=randint(low=100, high=101),
        m=randint(low=30, high=31),
        w=randint(low=0, high=1000),
        K=randint(low=500, high=500),
        u=uniform(loc=0.0, scale=1.0),
        alpha=uniform(loc=0.25, scale=0.0),
        fix_w=False,
        w_jitter=uniform(loc=1.0, scale=0.0),
        round=True,
    ):
        &#34;&#34;&#34;Initialize the problem generator.
        Instances have a random number of items (or variables) and a random number of knapsacks
        (or constraints), as specified by the provided probability distributions `n` and `m`,
        respectively. The weight of each item `i` on knapsack `j` is sampled independently from
        the provided distribution `w`. The capacity of knapsack `j` is set to:
            alpha_j * sum(w[i,j] for i in range(n)),
        where `alpha_j`, the tightness ratio, is sampled from the provided probability
        distribution `alpha`. To make the instances more challenging, the costs of the items
        are linearly correlated to their average weights. More specifically, the weight of each
        item `i` is set to:
            sum(w[i,j]/m for j in range(m)) + K * u_i,
        where `K`, the correlation coefficient, and `u_i`, the correlation multiplier, are sampled
        from the provided probability distributions. Note that `K` is only sample once for the
        entire instance.
        If fix_w=True is provided, then w[i,j] are kept the same in all generated instances. This
        also implies that n and m are kept fixed. Although the prices and capacities are derived
        from w[i,j], as long as u and K are not constants, the generated instances will still not
        be completely identical.
        If a probability distribution w_jitter is provided, then item weights will be set to
        w[i,j] * gamma[i,j] where gamma[i,j] is sampled from w_jitter. When combined with
        fix_w=True, this argument may be used to generate instances where the weight of each item
        is roughly the same, but not exactly identical, across all instances. The prices of the
        items and the capacities of the knapsacks will be calculated as above, but using these
        perturbed weights instead.
        By default, all generated prices, weights and capacities are rounded to the nearest integer
        number. If `round=False` is provided, this rounding will be disabled.
        Parameters
        ----------
        n: rv_discrete
            Probability distribution for the number of items (or variables)
        m: rv_discrete
            Probability distribution for the number of knapsacks (or constraints)
        w: rv_continuous
            Probability distribution for the item weights
        K: rv_continuous
            Probability distribution for the profit correlation coefficient
        u: rv_continuous
            Probability distribution for the profit multiplier
        alpha: rv_continuous
            Probability distribution for the tightness ratio
        fix_w: boolean
            If true, weights are kept the same (minus the noise from w_jitter) in all instances
        w_jitter: rv_continuous
            Probability distribution for random noise added to the weights
        round: boolean
            If true, all prices, weights and capacities are rounded to the nearest integer
        &#34;&#34;&#34;
        assert isinstance(n, rv_frozen), &#34;n should be a SciPy probability distribution&#34;
        assert isinstance(m, rv_frozen), &#34;m should be a SciPy probability distribution&#34;
        assert isinstance(w, rv_frozen), &#34;w should be a SciPy probability distribution&#34;
        assert isinstance(K, rv_frozen), &#34;K should be a SciPy probability distribution&#34;
        assert isinstance(u, rv_frozen), &#34;u should be a SciPy probability distribution&#34;
        assert isinstance(
            alpha, rv_frozen
        ), &#34;alpha should be a SciPy probability distribution&#34;
        assert isinstance(fix_w, bool), &#34;fix_w should be boolean&#34;
        assert isinstance(
            w_jitter, rv_frozen
        ), &#34;w_jitter should be a SciPy probability distribution&#34;
        self.n = n
        self.m = m
        self.w = w
        self.K = K
        self.u = u
        self.alpha = alpha
        self.w_jitter = w_jitter
        self.round = round
        if fix_w:
            self.fix_n = self.n.rvs()
            self.fix_m = self.m.rvs()
            self.fix_w = np.array([self.w.rvs(self.fix_n) for _ in range(self.fix_m)])
            self.fix_u = self.u.rvs(self.fix_n)
            self.fix_K = self.K.rvs()
        else:
            self.fix_n = None
            self.fix_m = None
            self.fix_w = None
            self.fix_u = None
            self.fix_K = None
    def generate(self, n_samples):
        def _sample():
            if self.fix_w is not None:
                n = self.fix_n
                m = self.fix_m
                w = self.fix_w
                u = self.fix_u
                K = self.fix_K
            else:
                n = self.n.rvs()
                m = self.m.rvs()
                w = np.array([self.w.rvs(n) for _ in range(m)])
                u = self.u.rvs(n)
                K = self.K.rvs()
            w = w * np.array([self.w_jitter.rvs(n) for _ in range(m)])
            alpha = self.alpha.rvs(m)
            p = np.array([w[:, j].sum() / m + K * u[j] for j in range(n)])
            b = np.array([w[i, :].sum() * alpha[i] for i in range(m)])
            if self.round:
                p = p.round()
                b = b.round()
                w = w.round()
            return MultiKnapsackInstance(p, b, w)
        return [_sample() for _ in range(n_samples)]</code></pre>
 </details>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.problems.knapsack.MultiKnapsackGenerator.generate"><code class="name flex">
 <span>def <span class="ident">generate</span></span>(<span>self, n_samples)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def generate(self, n_samples):
    def _sample():
        if self.fix_w is not None:
            n = self.fix_n
            m = self.fix_m
            w = self.fix_w
            u = self.fix_u
            K = self.fix_K
        else:
            n = self.n.rvs()
            m = self.m.rvs()
            w = np.array([self.w.rvs(n) for _ in range(m)])
            u = self.u.rvs(n)
            K = self.K.rvs()
        w = w * np.array([self.w_jitter.rvs(n) for _ in range(m)])
        alpha = self.alpha.rvs(m)
        p = np.array([w[:, j].sum() / m + K * u[j] for j in range(n)])
        b = np.array([w[i, :].sum() * alpha[i] for i in range(m)])
        if self.round:
            p = p.round()
            b = b.round()
            w = w.round()
        return MultiKnapsackInstance(p, b, w)
    return [_sample() for _ in range(n_samples)]</code></pre>
 </details>
 </dd>
 </dl>
 </dd>
 <dt id="miplearn.problems.knapsack.MultiKnapsackInstance"><code class="flex name class">
 <span>class <span class="ident">MultiKnapsackInstance</span></span>
 <span>(</span><span>prices, capacities, weights)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Representation of the Multidimensional 0-1 Knapsack Problem.</p>
 <p>Given a set of n items and m knapsacks, the problem is to find a subset of items S maximizing
 sum(prices[i] for i in S). If selected, each item i occupies weights[i,j] units of space in
 each knapsack j. Furthermore, each knapsack j has limited storage space, given by capacities[j].</p>
 <p>This implementation assigns a different category for each decision variable, and therefore
 trains one ML model per variable. It is only suitable when training and test instances have
 same size and items don't shuffle around.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class MultiKnapsackInstance(Instance):
    &#34;&#34;&#34;Representation of the Multidimensional 0-1 Knapsack Problem.
    Given a set of n items and m knapsacks, the problem is to find a subset of items S maximizing
    sum(prices[i] for i in S). If selected, each item i occupies weights[i,j] units of space in
    each knapsack j. Furthermore, each knapsack j has limited storage space, given by capacities[j].
    This implementation assigns a different category for each decision variable, and therefore
    trains one ML model per variable. It is only suitable when training and test instances have
    same size and items don&#39;t shuffle around.
    &#34;&#34;&#34;
    def __init__(self, prices, capacities, weights):
        super().__init__()
        assert isinstance(prices, np.ndarray)
        assert isinstance(capacities, np.ndarray)
        assert isinstance(weights, np.ndarray)
        assert len(weights.shape) == 2
        self.m, self.n = weights.shape
        assert prices.shape == (self.n,)
        assert capacities.shape == (self.m,)
        self.prices = prices
        self.capacities = capacities
        self.weights = weights
    def to_model(self):
        model = pe.ConcreteModel()
        model.x = pe.Var(range(self.n), domain=pe.Binary)
        model.OBJ = pe.Objective(
            rule=lambda model: sum(model.x[j] * self.prices[j] for j in range(self.n)),
            sense=pe.maximize,
        )
        model.eq_capacity = pe.ConstraintList()
        for i in range(self.m):
            model.eq_capacity.add(
                sum(model.x[j] * self.weights[i, j] for j in range(self.n))
                &lt;= self.capacities[i]
            )
        return model
    def get_instance_features(self):
        return np.hstack(
            [
                np.mean(self.prices),
                self.capacities,
            ]
        )
    def get_variable_features(self, var, index):
        return np.hstack(
            [
                self.prices[index],
                self.weights[:, index],
            ]
        )</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.instance.Instance" href="../instance.html#miplearn.instance.Instance">Instance</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.instance.Instance" href="../instance.html#miplearn.instance.Instance">Instance</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.instance.Instance.build_lazy_constraint" href="../instance.html#miplearn.instance.Instance.build_lazy_constraint">build_lazy_constraint</a></code></li>
 <li><code><a title="miplearn.instance.Instance.find_violated_lazy_constraints" href="../instance.html#miplearn.instance.Instance.find_violated_lazy_constraints">find_violated_lazy_constraints</a></code></li>
 <li><code><a title="miplearn.instance.Instance.get_instance_features" href="../instance.html#miplearn.instance.Instance.get_instance_features">get_instance_features</a></code></li>
 <li><code><a title="miplearn.instance.Instance.get_variable_category" href="../instance.html#miplearn.instance.Instance.get_variable_category">get_variable_category</a></code></li>
 <li><code><a title="miplearn.instance.Instance.get_variable_features" href="../instance.html#miplearn.instance.Instance.get_variable_features">get_variable_features</a></code></li>
 <li><code><a title="miplearn.instance.Instance.to_model" href="../instance.html#miplearn.instance.Instance.to_model">to_model</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.problems" href="index.html">miplearn.problems</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.problems.knapsack.ChallengeA" href="#miplearn.problems.knapsack.ChallengeA">ChallengeA</a></code></h4>
 </li>
 <li>
 <h4><code><a title="miplearn.problems.knapsack.GurobiKnapsackInstance" href="#miplearn.problems.knapsack.GurobiKnapsackInstance">GurobiKnapsackInstance</a></code></h4>
 </li>
 <li>
 <h4><code><a title="miplearn.problems.knapsack.KnapsackInstance" href="#miplearn.problems.knapsack.KnapsackInstance">KnapsackInstance</a></code></h4>
 </li>
 <li>
 <h4><code><a title="miplearn.problems.knapsack.MultiKnapsackGenerator" href="#miplearn.problems.knapsack.MultiKnapsackGenerator">MultiKnapsackGenerator</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.problems.knapsack.MultiKnapsackGenerator.generate" href="#miplearn.problems.knapsack.MultiKnapsackGenerator.generate">generate</a></code></li>
 </ul>
 </li>
 <li>
 <h4><code><a title="miplearn.problems.knapsack.MultiKnapsackInstance" href="#miplearn.problems.knapsack.MultiKnapsackInstance">MultiKnapsackInstance</a></code></h4>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/problems/stab.html
+++ b/0.2/api/miplearn/problems/stab.html
@ -1,434 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.problems.stab API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.problems.stab</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import networkx as nx
 import numpy as np
 import pyomo.environ as pe
 from scipy.stats import uniform, randint
 from scipy.stats.distributions import rv_frozen
 from miplearn.instance import Instance
 class ChallengeA:
    def __init__(
        self,
        seed=42,
        n_training_instances=500,
        n_test_instances=50,
    ):
        np.random.seed(seed)
        self.generator = MaxWeightStableSetGenerator(
            w=uniform(loc=100.0, scale=50.0),
            n=randint(low=200, high=201),
            p=uniform(loc=0.05, scale=0.0),
            fix_graph=True,
        )
        np.random.seed(seed + 1)
        self.training_instances = self.generator.generate(n_training_instances)
        np.random.seed(seed + 2)
        self.test_instances = self.generator.generate(n_test_instances)
 class MaxWeightStableSetGenerator:
    &#34;&#34;&#34;Random instance generator for the Maximum-Weight Stable Set Problem.
    The generator has two modes of operation. When `fix_graph=True` is provided, one random
    Erdős-Rényi graph $G_{n,p}$ is generated in the constructor, where $n$ and $p$ are sampled
    from user-provided probability distributions `n` and `p`. To generate each instance, the
    generator independently samples each $w_v$ from the user-provided probability distribution `w`.
    When `fix_graph=False`, a new random graph is generated for each instance; the remaining
    parameters are sampled in the same way.
    &#34;&#34;&#34;
    def __init__(
        self,
        w=uniform(loc=10.0, scale=1.0),
        n=randint(low=250, high=251),
        p=uniform(loc=0.05, scale=0.0),
        fix_graph=True,
    ):
        &#34;&#34;&#34;Initialize the problem generator.
        Parameters
        ----------
        w: rv_continuous
            Probability distribution for vertex weights.
        n: rv_discrete
            Probability distribution for parameter $n$ in Erdős-Rényi model.
        p: rv_continuous
            Probability distribution for parameter $p$ in Erdős-Rényi model.
        &#34;&#34;&#34;
        assert isinstance(w, rv_frozen), &#34;w should be a SciPy probability distribution&#34;
        assert isinstance(n, rv_frozen), &#34;n should be a SciPy probability distribution&#34;
        assert isinstance(p, rv_frozen), &#34;p should be a SciPy probability distribution&#34;
        self.w = w
        self.n = n
        self.p = p
        self.fix_graph = fix_graph
        self.graph = None
        if fix_graph:
            self.graph = self._generate_graph()
    def generate(self, n_samples):
        def _sample():
            if self.graph is not None:
                graph = self.graph
            else:
                graph = self._generate_graph()
            weights = self.w.rvs(graph.number_of_nodes())
            return MaxWeightStableSetInstance(graph, weights)
        return [_sample() for _ in range(n_samples)]
    def _generate_graph(self):
        return nx.generators.random_graphs.binomial_graph(self.n.rvs(), self.p.rvs())
 class MaxWeightStableSetInstance(Instance):
    &#34;&#34;&#34;An instance of the Maximum-Weight Stable Set Problem.
    Given a graph G=(V,E) and a weight w_v for each vertex v, the problem asks for a stable
    set S of G maximizing sum(w_v for v in S). A stable set (also called independent set) is
    a subset of vertices, no two of which are adjacent.
    This is one of Karp&#39;s 21 NP-complete problems.
    &#34;&#34;&#34;
    def __init__(self, graph, weights):
        super().__init__()
        self.graph = graph
        self.weights = weights
    def to_model(self):
        nodes = list(self.graph.nodes)
        model = pe.ConcreteModel()
        model.x = pe.Var(nodes, domain=pe.Binary)
        model.OBJ = pe.Objective(
            expr=sum(model.x[v] * self.weights[v] for v in nodes), sense=pe.maximize
        )
        model.clique_eqs = pe.ConstraintList()
        for clique in nx.find_cliques(self.graph):
            model.clique_eqs.add(sum(model.x[i] for i in clique) &lt;= 1)
        return model
    def get_instance_features(self):
        return np.ones(0)
    def get_variable_features(self, var, index):
        neighbor_weights = [0] * 15
        neighbor_degrees = [100] * 15
        for n in self.graph.neighbors(index):
            neighbor_weights += [self.weights[n] / self.weights[index]]
            neighbor_degrees += [self.graph.degree(n) / self.graph.degree(index)]
        neighbor_weights.sort(reverse=True)
        neighbor_degrees.sort()
        features = []
        features += neighbor_weights[:5]
        features += neighbor_degrees[:5]
        features += [self.graph.degree(index)]
        return np.array(features)
    def get_variable_category(self, var, index):
        return &#34;default&#34;</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.problems.stab.ChallengeA"><code class="flex name class">
 <span>class <span class="ident">ChallengeA</span></span>
 <span>(</span><span>seed=42, n_training_instances=500, n_test_instances=50)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class ChallengeA:
    def __init__(
        self,
        seed=42,
        n_training_instances=500,
        n_test_instances=50,
    ):
        np.random.seed(seed)
        self.generator = MaxWeightStableSetGenerator(
            w=uniform(loc=100.0, scale=50.0),
            n=randint(low=200, high=201),
            p=uniform(loc=0.05, scale=0.0),
            fix_graph=True,
        )
        np.random.seed(seed + 1)
        self.training_instances = self.generator.generate(n_training_instances)
        np.random.seed(seed + 2)
        self.test_instances = self.generator.generate(n_test_instances)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.problems.stab.MaxWeightStableSetGenerator"><code class="flex name class">
 <span>class <span class="ident">MaxWeightStableSetGenerator</span></span>
 <span>(</span><span>w=&lt;scipy.stats._distn_infrastructure.rv_frozen object&gt;, n=&lt;scipy.stats._distn_infrastructure.rv_frozen object&gt;, p=&lt;scipy.stats._distn_infrastructure.rv_frozen object&gt;, fix_graph=True)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Random instance generator for the Maximum-Weight Stable Set Problem.</p>
 <p>The generator has two modes of operation. When <code>fix_graph=True</code> is provided, one random
 Erdős-Rényi graph $G_{n,p}$ is generated in the constructor, where $n$ and $p$ are sampled
 from user-provided probability distributions <code>n</code> and <code>p</code>. To generate each instance, the
 generator independently samples each $w_v$ from the user-provided probability distribution <code>w</code>.</p>
 <p>When <code>fix_graph=False</code>, a new random graph is generated for each instance; the remaining
 parameters are sampled in the same way.</p>
 <p>Initialize the problem generator.</p>
 <h2 id="parameters">Parameters</h2>
 <dl>
 <dt><strong><code>w</code></strong> :&ensp;<code>rv_continuous</code></dt>
 <dd>Probability distribution for vertex weights.</dd>
 <dt><strong><code>n</code></strong> :&ensp;<code>rv_discrete</code></dt>
 <dd>Probability distribution for parameter $n$ in Erdős-Rényi model.</dd>
 <dt><strong><code>p</code></strong> :&ensp;<code>rv_continuous</code></dt>
 <dd>Probability distribution for parameter $p$ in Erdős-Rényi model.</dd>
 </dl></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class MaxWeightStableSetGenerator:
    &#34;&#34;&#34;Random instance generator for the Maximum-Weight Stable Set Problem.
    The generator has two modes of operation. When `fix_graph=True` is provided, one random
    Erdős-Rényi graph $G_{n,p}$ is generated in the constructor, where $n$ and $p$ are sampled
    from user-provided probability distributions `n` and `p`. To generate each instance, the
    generator independently samples each $w_v$ from the user-provided probability distribution `w`.
    When `fix_graph=False`, a new random graph is generated for each instance; the remaining
    parameters are sampled in the same way.
    &#34;&#34;&#34;
    def __init__(
        self,
        w=uniform(loc=10.0, scale=1.0),
        n=randint(low=250, high=251),
        p=uniform(loc=0.05, scale=0.0),
        fix_graph=True,
    ):
        &#34;&#34;&#34;Initialize the problem generator.
        Parameters
        ----------
        w: rv_continuous
            Probability distribution for vertex weights.
        n: rv_discrete
            Probability distribution for parameter $n$ in Erdős-Rényi model.
        p: rv_continuous
            Probability distribution for parameter $p$ in Erdős-Rényi model.
        &#34;&#34;&#34;
        assert isinstance(w, rv_frozen), &#34;w should be a SciPy probability distribution&#34;
        assert isinstance(n, rv_frozen), &#34;n should be a SciPy probability distribution&#34;
        assert isinstance(p, rv_frozen), &#34;p should be a SciPy probability distribution&#34;
        self.w = w
        self.n = n
        self.p = p
        self.fix_graph = fix_graph
        self.graph = None
        if fix_graph:
            self.graph = self._generate_graph()
    def generate(self, n_samples):
        def _sample():
            if self.graph is not None:
                graph = self.graph
            else:
                graph = self._generate_graph()
            weights = self.w.rvs(graph.number_of_nodes())
            return MaxWeightStableSetInstance(graph, weights)
        return [_sample() for _ in range(n_samples)]
    def _generate_graph(self):
        return nx.generators.random_graphs.binomial_graph(self.n.rvs(), self.p.rvs())</code></pre>
 </details>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.problems.stab.MaxWeightStableSetGenerator.generate"><code class="name flex">
 <span>def <span class="ident">generate</span></span>(<span>self, n_samples)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def generate(self, n_samples):
    def _sample():
        if self.graph is not None:
            graph = self.graph
        else:
            graph = self._generate_graph()
        weights = self.w.rvs(graph.number_of_nodes())
        return MaxWeightStableSetInstance(graph, weights)
    return [_sample() for _ in range(n_samples)]</code></pre>
 </details>
 </dd>
 </dl>
 </dd>
 <dt id="miplearn.problems.stab.MaxWeightStableSetInstance"><code class="flex name class">
 <span>class <span class="ident">MaxWeightStableSetInstance</span></span>
 <span>(</span><span>graph, weights)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>An instance of the Maximum-Weight Stable Set Problem.</p>
 <p>Given a graph G=(V,E) and a weight w_v for each vertex v, the problem asks for a stable
 set S of G maximizing sum(w_v for v in S). A stable set (also called independent set) is
 a subset of vertices, no two of which are adjacent.</p>
 <p>This is one of Karp's 21 NP-complete problems.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class MaxWeightStableSetInstance(Instance):
    &#34;&#34;&#34;An instance of the Maximum-Weight Stable Set Problem.
    Given a graph G=(V,E) and a weight w_v for each vertex v, the problem asks for a stable
    set S of G maximizing sum(w_v for v in S). A stable set (also called independent set) is
    a subset of vertices, no two of which are adjacent.
    This is one of Karp&#39;s 21 NP-complete problems.
    &#34;&#34;&#34;
    def __init__(self, graph, weights):
        super().__init__()
        self.graph = graph
        self.weights = weights
    def to_model(self):
        nodes = list(self.graph.nodes)
        model = pe.ConcreteModel()
        model.x = pe.Var(nodes, domain=pe.Binary)
        model.OBJ = pe.Objective(
            expr=sum(model.x[v] * self.weights[v] for v in nodes), sense=pe.maximize
        )
        model.clique_eqs = pe.ConstraintList()
        for clique in nx.find_cliques(self.graph):
            model.clique_eqs.add(sum(model.x[i] for i in clique) &lt;= 1)
        return model
    def get_instance_features(self):
        return np.ones(0)
    def get_variable_features(self, var, index):
        neighbor_weights = [0] * 15
        neighbor_degrees = [100] * 15
        for n in self.graph.neighbors(index):
            neighbor_weights += [self.weights[n] / self.weights[index]]
            neighbor_degrees += [self.graph.degree(n) / self.graph.degree(index)]
        neighbor_weights.sort(reverse=True)
        neighbor_degrees.sort()
        features = []
        features += neighbor_weights[:5]
        features += neighbor_degrees[:5]
        features += [self.graph.degree(index)]
        return np.array(features)
    def get_variable_category(self, var, index):
        return &#34;default&#34;</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.instance.Instance" href="../instance.html#miplearn.instance.Instance">Instance</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.instance.Instance" href="../instance.html#miplearn.instance.Instance">Instance</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.instance.Instance.build_lazy_constraint" href="../instance.html#miplearn.instance.Instance.build_lazy_constraint">build_lazy_constraint</a></code></li>
 <li><code><a title="miplearn.instance.Instance.find_violated_lazy_constraints" href="../instance.html#miplearn.instance.Instance.find_violated_lazy_constraints">find_violated_lazy_constraints</a></code></li>
 <li><code><a title="miplearn.instance.Instance.get_instance_features" href="../instance.html#miplearn.instance.Instance.get_instance_features">get_instance_features</a></code></li>
 <li><code><a title="miplearn.instance.Instance.get_variable_category" href="../instance.html#miplearn.instance.Instance.get_variable_category">get_variable_category</a></code></li>
 <li><code><a title="miplearn.instance.Instance.get_variable_features" href="../instance.html#miplearn.instance.Instance.get_variable_features">get_variable_features</a></code></li>
 <li><code><a title="miplearn.instance.Instance.to_model" href="../instance.html#miplearn.instance.Instance.to_model">to_model</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.problems" href="index.html">miplearn.problems</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.problems.stab.ChallengeA" href="#miplearn.problems.stab.ChallengeA">ChallengeA</a></code></h4>
 </li>
 <li>
 <h4><code><a title="miplearn.problems.stab.MaxWeightStableSetGenerator" href="#miplearn.problems.stab.MaxWeightStableSetGenerator">MaxWeightStableSetGenerator</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.problems.stab.MaxWeightStableSetGenerator.generate" href="#miplearn.problems.stab.MaxWeightStableSetGenerator.generate">generate</a></code></li>
 </ul>
 </li>
 <li>
 <h4><code><a title="miplearn.problems.stab.MaxWeightStableSetInstance" href="#miplearn.problems.stab.MaxWeightStableSetInstance">MaxWeightStableSetInstance</a></code></h4>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/problems/tsp.html
+++ b/0.2/api/miplearn/problems/tsp.html
@ -1,587 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.problems.tsp API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.problems.tsp</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import networkx as nx
 import numpy as np
 import pyomo.environ as pe
 from scipy.spatial.distance import pdist, squareform
 from scipy.stats import uniform, randint
 from scipy.stats.distributions import rv_frozen
 from miplearn.instance import Instance
 class ChallengeA:
    def __init__(
        self,
        seed=42,
        n_training_instances=500,
        n_test_instances=50,
    ):
        np.random.seed(seed)
        self.generator = TravelingSalesmanGenerator(
            x=uniform(loc=0.0, scale=1000.0),
            y=uniform(loc=0.0, scale=1000.0),
            n=randint(low=350, high=351),
            gamma=uniform(loc=0.95, scale=0.1),
            fix_cities=True,
            round=True,
        )
        np.random.seed(seed + 1)
        self.training_instances = self.generator.generate(n_training_instances)
        np.random.seed(seed + 2)
        self.test_instances = self.generator.generate(n_test_instances)
 class TravelingSalesmanGenerator:
    &#34;&#34;&#34;Random generator for the Traveling Salesman Problem.&#34;&#34;&#34;
    def __init__(
        self,
        x=uniform(loc=0.0, scale=1000.0),
        y=uniform(loc=0.0, scale=1000.0),
        n=randint(low=100, high=101),
        gamma=uniform(loc=1.0, scale=0.0),
        fix_cities=True,
        round=True,
    ):
        &#34;&#34;&#34;Initializes the problem generator.
        Initially, the generator creates n cities (x_1,y_1),...,(x_n,y_n) where n, x_i and y_i are
        sampled independently from the provided probability distributions `n`, `x` and `y`. For each
        (unordered) pair of cities (i,j), the distance d[i,j] between them is set to:
            d[i,j] = gamma[i,j] \sqrt{(x_i - x_j)^2 + (y_i - y_j)^2}
        where gamma is sampled from the provided probability distribution `gamma`.
        If fix_cities=True, the list of cities is kept the same for all generated instances. The
        gamma values, and therefore also the distances, are still different.
        By default, all distances d[i,j] are rounded to the nearest integer.  If `round=False`
        is provided, this rounding will be disabled.
        Arguments
        ---------
        x: rv_continuous
            Probability distribution for the x-coordinate of each city.
        y: rv_continuous
            Probability distribution for the y-coordinate of each city.
        n: rv_discrete
            Probability distribution for the number of cities.
        fix_cities: bool
            If False, cities will be resampled for every generated instance. Otherwise, list of
            cities will be computed once, during the constructor.
        round: bool
            If True, distances are rounded to the nearest integer.
        &#34;&#34;&#34;
        assert isinstance(x, rv_frozen), &#34;x should be a SciPy probability distribution&#34;
        assert isinstance(y, rv_frozen), &#34;y should be a SciPy probability distribution&#34;
        assert isinstance(n, rv_frozen), &#34;n should be a SciPy probability distribution&#34;
        assert isinstance(
            gamma,
            rv_frozen,
        ), &#34;gamma should be a SciPy probability distribution&#34;
        self.x = x
        self.y = y
        self.n = n
        self.gamma = gamma
        self.round = round
        if fix_cities:
            self.fixed_n, self.fixed_cities = self._generate_cities()
        else:
            self.fixed_n = None
            self.fixed_cities = None
    def generate(self, n_samples):
        def _sample():
            if self.fixed_cities is not None:
                n, cities = self.fixed_n, self.fixed_cities
            else:
                n, cities = self._generate_cities()
            distances = squareform(pdist(cities)) * self.gamma.rvs(size=(n, n))
            distances = np.tril(distances) + np.triu(distances.T, 1)
            if self.round:
                distances = distances.round()
            return TravelingSalesmanInstance(n, distances)
        return [_sample() for _ in range(n_samples)]
    def _generate_cities(self):
        n = self.n.rvs()
        cities = np.array([(self.x.rvs(), self.y.rvs()) for _ in range(n)])
        return n, cities
 class TravelingSalesmanInstance(Instance):
    &#34;&#34;&#34;An instance ot the Traveling Salesman Problem.
    Given a list of cities and the distance between each pair of cities, the problem asks for the
    shortest route starting at the first city, visiting each other city exactly once, then
    returning to the first city. This problem is a generalization of the Hamiltonian path problem,
    one of Karp&#39;s 21 NP-complete problems.
    &#34;&#34;&#34;
    def __init__(self, n_cities, distances):
        assert isinstance(distances, np.ndarray)
        assert distances.shape == (n_cities, n_cities)
        self.n_cities = n_cities
        self.distances = distances
    def to_model(self):
        model = pe.ConcreteModel()
        model.edges = edges = [
            (i, j) for i in range(self.n_cities) for j in range(i + 1, self.n_cities)
        ]
        model.x = pe.Var(edges, domain=pe.Binary)
        model.obj = pe.Objective(
            expr=sum(model.x[i, j] * self.distances[i, j] for (i, j) in edges),
            sense=pe.minimize,
        )
        model.eq_degree = pe.ConstraintList()
        model.eq_subtour = pe.ConstraintList()
        for i in range(self.n_cities):
            model.eq_degree.add(
                sum(
                    model.x[min(i, j), max(i, j)]
                    for j in range(self.n_cities)
                    if i != j
                )
                == 2
            )
        return model
    def get_instance_features(self):
        return np.array([1])
    def get_variable_features(self, var_name, index):
        return np.array([1])
    def get_variable_category(self, var_name, index):
        return index
    def find_violated_lazy_constraints(self, model):
        selected_edges = [e for e in model.edges if model.x[e].value &gt; 0.5]
        graph = nx.Graph()
        graph.add_edges_from(selected_edges)
        components = [frozenset(c) for c in list(nx.connected_components(graph))]
        violations = []
        for c in components:
            if len(c) &lt; self.n_cities:
                violations += [c]
        return violations
    def build_lazy_constraint(self, model, component):
        cut_edges = [
            e
            for e in model.edges
            if (e[0] in component and e[1] not in component)
            or (e[0] not in component and e[1] in component)
        ]
        return model.eq_subtour.add(sum(model.x[e] for e in cut_edges) &gt;= 2)
    def find_violated_user_cuts(self, model):
        return self.find_violated_lazy_constraints(model)
    def build_user_cut(self, model, violation):
        return self.build_lazy_constraint(model, violation)</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.problems.tsp.ChallengeA"><code class="flex name class">
 <span>class <span class="ident">ChallengeA</span></span>
 <span>(</span><span>seed=42, n_training_instances=500, n_test_instances=50)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class ChallengeA:
    def __init__(
        self,
        seed=42,
        n_training_instances=500,
        n_test_instances=50,
    ):
        np.random.seed(seed)
        self.generator = TravelingSalesmanGenerator(
            x=uniform(loc=0.0, scale=1000.0),
            y=uniform(loc=0.0, scale=1000.0),
            n=randint(low=350, high=351),
            gamma=uniform(loc=0.95, scale=0.1),
            fix_cities=True,
            round=True,
        )
        np.random.seed(seed + 1)
        self.training_instances = self.generator.generate(n_training_instances)
        np.random.seed(seed + 2)
        self.test_instances = self.generator.generate(n_test_instances)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.problems.tsp.TravelingSalesmanGenerator"><code class="flex name class">
 <span>class <span class="ident">TravelingSalesmanGenerator</span></span>
 <span>(</span><span>x=&lt;scipy.stats._distn_infrastructure.rv_frozen object&gt;, y=&lt;scipy.stats._distn_infrastructure.rv_frozen object&gt;, n=&lt;scipy.stats._distn_infrastructure.rv_frozen object&gt;, gamma=&lt;scipy.stats._distn_infrastructure.rv_frozen object&gt;, fix_cities=True, round=True)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Random generator for the Traveling Salesman Problem.</p>
 <p>Initializes the problem generator.</p>
 <p>Initially, the generator creates n cities (x_1,y_1),&hellip;,(x_n,y_n) where n, x_i and y_i are
 sampled independently from the provided probability distributions <code>n</code>, <code>x</code> and <code>y</code>. For each
 (unordered) pair of cities (i,j), the distance d[i,j] between them is set to:</p>
 <pre><code>d[i,j] = gamma[i,j] \sqrt{(x_i - x_j)^2 + (y_i - y_j)^2}
 </code></pre>
 <p>where gamma is sampled from the provided probability distribution <code>gamma</code>.</p>
 <p>If fix_cities=True, the list of cities is kept the same for all generated instances. The
 gamma values, and therefore also the distances, are still different.</p>
 <p>By default, all distances d[i,j] are rounded to the nearest integer.
 If <code>round=False</code>
 is provided, this rounding will be disabled.</p>
 <h2 id="arguments">Arguments</h2>
 <dl>
 <dt><strong><code>x</code></strong> :&ensp;<code>rv_continuous</code></dt>
 <dd>Probability distribution for the x-coordinate of each city.</dd>
 <dt><strong><code>y</code></strong> :&ensp;<code>rv_continuous</code></dt>
 <dd>Probability distribution for the y-coordinate of each city.</dd>
 <dt><strong><code>n</code></strong> :&ensp;<code>rv_discrete</code></dt>
 <dd>Probability distribution for the number of cities.</dd>
 <dt><strong><code>fix_cities</code></strong> :&ensp;<code>bool</code></dt>
 <dd>If False, cities will be resampled for every generated instance. Otherwise, list of
 cities will be computed once, during the constructor.</dd>
 <dt><strong><code>round</code></strong> :&ensp;<code>bool</code></dt>
 <dd>If True, distances are rounded to the nearest integer.</dd>
 </dl></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class TravelingSalesmanGenerator:
    &#34;&#34;&#34;Random generator for the Traveling Salesman Problem.&#34;&#34;&#34;
    def __init__(
        self,
        x=uniform(loc=0.0, scale=1000.0),
        y=uniform(loc=0.0, scale=1000.0),
        n=randint(low=100, high=101),
        gamma=uniform(loc=1.0, scale=0.0),
        fix_cities=True,
        round=True,
    ):
        &#34;&#34;&#34;Initializes the problem generator.
        Initially, the generator creates n cities (x_1,y_1),...,(x_n,y_n) where n, x_i and y_i are
        sampled independently from the provided probability distributions `n`, `x` and `y`. For each
        (unordered) pair of cities (i,j), the distance d[i,j] between them is set to:
            d[i,j] = gamma[i,j] \sqrt{(x_i - x_j)^2 + (y_i - y_j)^2}
        where gamma is sampled from the provided probability distribution `gamma`.
        If fix_cities=True, the list of cities is kept the same for all generated instances. The
        gamma values, and therefore also the distances, are still different.
        By default, all distances d[i,j] are rounded to the nearest integer.  If `round=False`
        is provided, this rounding will be disabled.
        Arguments
        ---------
        x: rv_continuous
            Probability distribution for the x-coordinate of each city.
        y: rv_continuous
            Probability distribution for the y-coordinate of each city.
        n: rv_discrete
            Probability distribution for the number of cities.
        fix_cities: bool
            If False, cities will be resampled for every generated instance. Otherwise, list of
            cities will be computed once, during the constructor.
        round: bool
            If True, distances are rounded to the nearest integer.
        &#34;&#34;&#34;
        assert isinstance(x, rv_frozen), &#34;x should be a SciPy probability distribution&#34;
        assert isinstance(y, rv_frozen), &#34;y should be a SciPy probability distribution&#34;
        assert isinstance(n, rv_frozen), &#34;n should be a SciPy probability distribution&#34;
        assert isinstance(
            gamma,
            rv_frozen,
        ), &#34;gamma should be a SciPy probability distribution&#34;
        self.x = x
        self.y = y
        self.n = n
        self.gamma = gamma
        self.round = round
        if fix_cities:
            self.fixed_n, self.fixed_cities = self._generate_cities()
        else:
            self.fixed_n = None
            self.fixed_cities = None
    def generate(self, n_samples):
        def _sample():
            if self.fixed_cities is not None:
                n, cities = self.fixed_n, self.fixed_cities
            else:
                n, cities = self._generate_cities()
            distances = squareform(pdist(cities)) * self.gamma.rvs(size=(n, n))
            distances = np.tril(distances) + np.triu(distances.T, 1)
            if self.round:
                distances = distances.round()
            return TravelingSalesmanInstance(n, distances)
        return [_sample() for _ in range(n_samples)]
    def _generate_cities(self):
        n = self.n.rvs()
        cities = np.array([(self.x.rvs(), self.y.rvs()) for _ in range(n)])
        return n, cities</code></pre>
 </details>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.problems.tsp.TravelingSalesmanGenerator.generate"><code class="name flex">
 <span>def <span class="ident">generate</span></span>(<span>self, n_samples)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def generate(self, n_samples):
    def _sample():
        if self.fixed_cities is not None:
            n, cities = self.fixed_n, self.fixed_cities
        else:
            n, cities = self._generate_cities()
        distances = squareform(pdist(cities)) * self.gamma.rvs(size=(n, n))
        distances = np.tril(distances) + np.triu(distances.T, 1)
        if self.round:
            distances = distances.round()
        return TravelingSalesmanInstance(n, distances)
    return [_sample() for _ in range(n_samples)]</code></pre>
 </details>
 </dd>
 </dl>
 </dd>
 <dt id="miplearn.problems.tsp.TravelingSalesmanInstance"><code class="flex name class">
 <span>class <span class="ident">TravelingSalesmanInstance</span></span>
 <span>(</span><span>n_cities, distances)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>An instance ot the Traveling Salesman Problem.</p>
 <p>Given a list of cities and the distance between each pair of cities, the problem asks for the
 shortest route starting at the first city, visiting each other city exactly once, then
 returning to the first city. This problem is a generalization of the Hamiltonian path problem,
 one of Karp's 21 NP-complete problems.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class TravelingSalesmanInstance(Instance):
    &#34;&#34;&#34;An instance ot the Traveling Salesman Problem.
    Given a list of cities and the distance between each pair of cities, the problem asks for the
    shortest route starting at the first city, visiting each other city exactly once, then
    returning to the first city. This problem is a generalization of the Hamiltonian path problem,
    one of Karp&#39;s 21 NP-complete problems.
    &#34;&#34;&#34;
    def __init__(self, n_cities, distances):
        assert isinstance(distances, np.ndarray)
        assert distances.shape == (n_cities, n_cities)
        self.n_cities = n_cities
        self.distances = distances
    def to_model(self):
        model = pe.ConcreteModel()
        model.edges = edges = [
            (i, j) for i in range(self.n_cities) for j in range(i + 1, self.n_cities)
        ]
        model.x = pe.Var(edges, domain=pe.Binary)
        model.obj = pe.Objective(
            expr=sum(model.x[i, j] * self.distances[i, j] for (i, j) in edges),
            sense=pe.minimize,
        )
        model.eq_degree = pe.ConstraintList()
        model.eq_subtour = pe.ConstraintList()
        for i in range(self.n_cities):
            model.eq_degree.add(
                sum(
                    model.x[min(i, j), max(i, j)]
                    for j in range(self.n_cities)
                    if i != j
                )
                == 2
            )
        return model
    def get_instance_features(self):
        return np.array([1])
    def get_variable_features(self, var_name, index):
        return np.array([1])
    def get_variable_category(self, var_name, index):
        return index
    def find_violated_lazy_constraints(self, model):
        selected_edges = [e for e in model.edges if model.x[e].value &gt; 0.5]
        graph = nx.Graph()
        graph.add_edges_from(selected_edges)
        components = [frozenset(c) for c in list(nx.connected_components(graph))]
        violations = []
        for c in components:
            if len(c) &lt; self.n_cities:
                violations += [c]
        return violations
    def build_lazy_constraint(self, model, component):
        cut_edges = [
            e
            for e in model.edges
            if (e[0] in component and e[1] not in component)
            or (e[0] not in component and e[1] in component)
        ]
        return model.eq_subtour.add(sum(model.x[e] for e in cut_edges) &gt;= 2)
    def find_violated_user_cuts(self, model):
        return self.find_violated_lazy_constraints(model)
    def build_user_cut(self, model, violation):
        return self.build_lazy_constraint(model, violation)</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.instance.Instance" href="../instance.html#miplearn.instance.Instance">Instance</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Methods</h3>
 <dl>
 <dt id="miplearn.problems.tsp.TravelingSalesmanInstance.build_user_cut"><code class="name flex">
 <span>def <span class="ident">build_user_cut</span></span>(<span>self, model, violation)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def build_user_cut(self, model, violation):
    return self.build_lazy_constraint(model, violation)</code></pre>
 </details>
 </dd>
 <dt id="miplearn.problems.tsp.TravelingSalesmanInstance.find_violated_user_cuts"><code class="name flex">
 <span>def <span class="ident">find_violated_user_cuts</span></span>(<span>self, model)</span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">def find_violated_user_cuts(self, model):
    return self.find_violated_lazy_constraints(model)</code></pre>
 </details>
 </dd>
 </dl>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.instance.Instance" href="../instance.html#miplearn.instance.Instance">Instance</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.instance.Instance.build_lazy_constraint" href="../instance.html#miplearn.instance.Instance.build_lazy_constraint">build_lazy_constraint</a></code></li>
 <li><code><a title="miplearn.instance.Instance.find_violated_lazy_constraints" href="../instance.html#miplearn.instance.Instance.find_violated_lazy_constraints">find_violated_lazy_constraints</a></code></li>
 <li><code><a title="miplearn.instance.Instance.get_instance_features" href="../instance.html#miplearn.instance.Instance.get_instance_features">get_instance_features</a></code></li>
 <li><code><a title="miplearn.instance.Instance.get_variable_category" href="../instance.html#miplearn.instance.Instance.get_variable_category">get_variable_category</a></code></li>
 <li><code><a title="miplearn.instance.Instance.get_variable_features" href="../instance.html#miplearn.instance.Instance.get_variable_features">get_variable_features</a></code></li>
 <li><code><a title="miplearn.instance.Instance.to_model" href="../instance.html#miplearn.instance.Instance.to_model">to_model</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.problems" href="index.html">miplearn.problems</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.problems.tsp.ChallengeA" href="#miplearn.problems.tsp.ChallengeA">ChallengeA</a></code></h4>
 </li>
 <li>
 <h4><code><a title="miplearn.problems.tsp.TravelingSalesmanGenerator" href="#miplearn.problems.tsp.TravelingSalesmanGenerator">TravelingSalesmanGenerator</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.problems.tsp.TravelingSalesmanGenerator.generate" href="#miplearn.problems.tsp.TravelingSalesmanGenerator.generate">generate</a></code></li>
 </ul>
 </li>
 <li>
 <h4><code><a title="miplearn.problems.tsp.TravelingSalesmanInstance" href="#miplearn.problems.tsp.TravelingSalesmanInstance">TravelingSalesmanInstance</a></code></h4>
 <ul class="">
 <li><code><a title="miplearn.problems.tsp.TravelingSalesmanInstance.build_user_cut" href="#miplearn.problems.tsp.TravelingSalesmanInstance.build_user_cut">build_user_cut</a></code></li>
 <li><code><a title="miplearn.problems.tsp.TravelingSalesmanInstance.find_violated_user_cuts" href="#miplearn.problems.tsp.TravelingSalesmanInstance.find_violated_user_cuts">find_violated_user_cuts</a></code></li>
 </ul>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/solvers/gurobi.html
+++ b/0.2/api/miplearn/solvers/gurobi.html
@ -1,928 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.solvers.gurobi API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.solvers.gurobi</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import logging
 import re
 import sys
 from io import StringIO
 from random import randint
 from typing import List, Any, Dict, Optional
 from miplearn.instance import Instance
 from miplearn.solvers import _RedirectOutput
 from miplearn.solvers.internal import (
    InternalSolver,
    LPSolveStats,
    IterationCallback,
    LazyCallback,
    MIPSolveStats,
 )
 from miplearn.types import VarIndex, SolverParams, Solution
 logger = logging.getLogger(__name__)
 class GurobiSolver(InternalSolver):
    &#34;&#34;&#34;
    An InternalSolver backed by Gurobi&#39;s Python API (without Pyomo).
    Parameters
    ----------
    params: Optional[SolverParams]
        Parameters to pass to Gurobi. For example, `params={&#34;MIPGap&#34;: 1e-3}`
        sets the gap tolerance to 1e-3.
    lazy_cb_frequency: int
        If 1, calls lazy constraint callbacks whenever an integer solution
        is found. If 2, calls it also at every node, after solving the
        LP relaxation of that node.
    &#34;&#34;&#34;
    def __init__(
        self,
        params: Optional[SolverParams] = None,
        lazy_cb_frequency: int = 1,
    ) -&gt; None:
        import gurobipy
        if params is None:
            params = {}
        params[&#34;InfUnbdInfo&#34;] = True
        self.gp = gurobipy
        self.instance: Optional[Instance] = None
        self.model: Optional[&#34;gurobipy.Model&#34;] = None
        self.params: SolverParams = params
        self._all_vars: Dict = {}
        self._bin_vars: Optional[Dict[str, Dict[VarIndex, &#34;gurobipy.Var&#34;]]] = None
        self.cb_where: Optional[int] = None
        assert lazy_cb_frequency in [1, 2]
        if lazy_cb_frequency == 1:
            self.lazy_cb_where = [self.gp.GRB.Callback.MIPSOL]
        else:
            self.lazy_cb_where = [
                self.gp.GRB.Callback.MIPSOL,
                self.gp.GRB.Callback.MIPNODE,
            ]
    def set_instance(
        self,
        instance: Instance,
        model: Any = None,
    ) -&gt; None:
        self._raise_if_callback()
        if model is None:
            model = instance.to_model()
        assert isinstance(model, self.gp.Model)
        self.instance = instance
        self.model = model
        self.model.update()
        self._update_vars()
    def _raise_if_callback(self) -&gt; None:
        if self.cb_where is not None:
            raise Exception(&#34;method cannot be called from a callback&#34;)
    def _update_vars(self) -&gt; None:
        assert self.model is not None
        self._all_vars = {}
        self._bin_vars = {}
        idx: VarIndex
        for var in self.model.getVars():
            m = re.search(r&#34;([^[]*)\[(.*)]&#34;, var.varName)
            if m is None:
                name = var.varName
                idx = [0]
            else:
                name = m.group(1)
                parts = m.group(2).split(&#34;,&#34;)
                idx = [int(k) if k.isdecimal else k for k in parts]
            if len(idx) == 1:
                idx = idx[0]
            if name not in self._all_vars:
                self._all_vars[name] = {}
            self._all_vars[name][idx] = var
            if var.vtype != &#34;C&#34;:
                if name not in self._bin_vars:
                    self._bin_vars[name] = {}
                self._bin_vars[name][idx] = var
    def _apply_params(self, streams: List[Any]) -&gt; None:
        assert self.model is not None
        with _RedirectOutput(streams):
            for (name, value) in self.params.items():
                self.model.setParam(name, value)
            if &#34;seed&#34; not in [k.lower() for k in self.params.keys()]:
                self.model.setParam(&#34;Seed&#34;, randint(0, 1_000_000))
    def solve_lp(
        self,
        tee: bool = False,
    ) -&gt; LPSolveStats:
        self._raise_if_callback()
        streams: List[Any] = [StringIO()]
        if tee:
            streams += [sys.stdout]
        self._apply_params(streams)
        assert self.model is not None
        assert self._bin_vars is not None
        for (varname, vardict) in self._bin_vars.items():
            for (idx, var) in vardict.items():
                var.vtype = self.gp.GRB.CONTINUOUS
                var.lb = 0.0
                var.ub = 1.0
        with _RedirectOutput(streams):
            self.model.optimize()
        for (varname, vardict) in self._bin_vars.items():
            for (idx, var) in vardict.items():
                var.vtype = self.gp.GRB.BINARY
        log = streams[0].getvalue()
        opt_value = None
        if not self.is_infeasible():
            opt_value = self.model.objVal
        return {
            &#34;Optimal value&#34;: opt_value,
            &#34;Log&#34;: log,
        }
    def solve(
        self,
        tee: bool = False,
        iteration_cb: IterationCallback = None,
        lazy_cb: LazyCallback = None,
    ) -&gt; MIPSolveStats:
        self._raise_if_callback()
        assert self.model is not None
        def cb_wrapper(cb_model, cb_where):
            try:
                self.cb_where = cb_where
                if cb_where in self.lazy_cb_where:
                    lazy_cb(self, self.model)
            except:
                logger.exception(&#34;callback error&#34;)
            finally:
                self.cb_where = None
        if lazy_cb:
            self.params[&#34;LazyConstraints&#34;] = 1
        total_wallclock_time = 0
        total_nodes = 0
        streams: List[Any] = [StringIO()]
        if tee:
            streams += [sys.stdout]
        self._apply_params(streams)
        if iteration_cb is None:
            iteration_cb = lambda: False
        while True:
            with _RedirectOutput(streams):
                if lazy_cb is None:
                    self.model.optimize()
                else:
                    self.model.optimize(cb_wrapper)
            total_wallclock_time += self.model.runtime
            total_nodes += int(self.model.nodeCount)
            should_repeat = iteration_cb()
            if not should_repeat:
                break
        log = streams[0].getvalue()
        ub, lb = None, None
        sense = &#34;min&#34; if self.model.modelSense == 1 else &#34;max&#34;
        if self.model.solCount &gt; 0:
            if self.model.modelSense == 1:
                lb = self.model.objBound
                ub = self.model.objVal
            else:
                lb = self.model.objVal
                ub = self.model.objBound
        ws_value = self._extract_warm_start_value(log)
        stats: MIPSolveStats = {
            &#34;Lower bound&#34;: lb,
            &#34;Upper bound&#34;: ub,
            &#34;Wallclock time&#34;: total_wallclock_time,
            &#34;Nodes&#34;: total_nodes,
            &#34;Sense&#34;: sense,
            &#34;Log&#34;: log,
            &#34;Warm start value&#34;: ws_value,
            &#34;LP value&#34;: None,
        }
        return stats
    def get_solution(self) -&gt; Optional[Solution]:
        self._raise_if_callback()
        assert self.model is not None
        if self.model.solCount == 0:
            return None
        solution: Solution = {}
        for (varname, vardict) in self._all_vars.items():
            solution[varname] = {}
            for (idx, var) in vardict.items():
                solution[varname][idx] = var.x
        return solution
    def set_warm_start(self, solution: Solution) -&gt; None:
        self._raise_if_callback()
        self._clear_warm_start()
        count_fixed, count_total = 0, 0
        for (varname, vardict) in solution.items():
            for (idx, value) in vardict.items():
                count_total += 1
                if value is not None:
                    count_fixed += 1
                    self._all_vars[varname][idx].start = value
        logger.info(
            &#34;Setting start values for %d variables (out of %d)&#34;
            % (count_fixed, count_total)
        )
    def get_sense(self) -&gt; str:
        assert self.model is not None
        if self.model.modelSense == 1:
            return &#34;min&#34;
        else:
            return &#34;max&#34;
    def get_value(
        self,
        var_name: str,
        index: VarIndex,
    ) -&gt; Optional[float]:
        var = self._all_vars[var_name][index]
        return self._get_value(var)
    def is_infeasible(self) -&gt; bool:
        assert self.model is not None
        return self.model.status in [self.gp.GRB.INFEASIBLE, self.gp.GRB.INF_OR_UNBD]
    def get_dual(self, cid: str) -&gt; float:
        assert self.model is not None
        c = self.model.getConstrByName(cid)
        if self.is_infeasible():
            return c.farkasDual
        else:
            return c.pi
    def _get_value(self, var: Any) -&gt; Optional[float]:
        assert self.model is not None
        if self.cb_where == self.gp.GRB.Callback.MIPSOL:
            return self.model.cbGetSolution(var)
        elif self.cb_where == self.gp.GRB.Callback.MIPNODE:
            return self.model.cbGetNodeRel(var)
        elif self.cb_where is None:
            if self.is_infeasible():
                return None
            else:
                return var.x
        else:
            raise Exception(
                &#34;get_value cannot be called from cb_where=%s&#34; % self.cb_where
            )
    def get_empty_solution(self) -&gt; Solution:
        self._raise_if_callback()
        solution: Solution = {}
        for (varname, vardict) in self._all_vars.items():
            solution[varname] = {}
            for (idx, var) in vardict.items():
                solution[varname][idx] = None
        return solution
    def add_constraint(
        self,
        constraint: Any,
        name: str = &#34;&#34;,
    ) -&gt; None:
        assert self.model is not None
        if type(constraint) is tuple:
            lhs, sense, rhs, name = constraint
            if self.cb_where in [
                self.gp.GRB.Callback.MIPSOL,
                self.gp.GRB.Callback.MIPNODE,
            ]:
                self.model.cbLazy(lhs, sense, rhs)
            else:
                self.model.addConstr(lhs, sense, rhs, name)
        else:
            if self.cb_where in [
                self.gp.GRB.Callback.MIPSOL,
                self.gp.GRB.Callback.MIPNODE,
            ]:
                self.model.cbLazy(constraint)
            else:
                self.model.addConstr(constraint, name=name)
    def _clear_warm_start(self) -&gt; None:
        for (varname, vardict) in self._all_vars.items():
            for (idx, var) in vardict.items():
                var.start = self.gp.GRB.UNDEFINED
    def fix(self, solution: Solution) -&gt; None:
        self._raise_if_callback()
        for (varname, vardict) in solution.items():
            for (idx, value) in vardict.items():
                if value is None:
                    continue
                var = self._all_vars[varname][idx]
                var.vtype = self.gp.GRB.CONTINUOUS
                var.lb = value
                var.ub = value
    def get_constraint_ids(self):
        self._raise_if_callback()
        self.model.update()
        return [c.ConstrName for c in self.model.getConstrs()]
    def extract_constraint(self, cid):
        self._raise_if_callback()
        constr = self.model.getConstrByName(cid)
        cobj = (self.model.getRow(constr), constr.sense, constr.RHS, constr.ConstrName)
        self.model.remove(constr)
        return cobj
    def is_constraint_satisfied(self, cobj, tol=1e-5):
        lhs, sense, rhs, name = cobj
        if self.cb_where is not None:
            lhs_value = lhs.getConstant()
            for i in range(lhs.size()):
                var = lhs.getVar(i)
                coeff = lhs.getCoeff(i)
                lhs_value += self._get_value(var) * coeff
        else:
            lhs_value = lhs.getValue()
        if sense == &#34;&lt;&#34;:
            return lhs_value &lt;= rhs + tol
        elif sense == &#34;&gt;&#34;:
            return lhs_value &gt;= rhs - tol
        elif sense == &#34;=&#34;:
            return abs(rhs - lhs_value) &lt; abs(tol)
        else:
            raise Exception(&#34;Unknown sense: %s&#34; % sense)
    def get_inequality_slacks(self) -&gt; Dict[str, float]:
        assert self.model is not None
        ineqs = [c for c in self.model.getConstrs() if c.sense != &#34;=&#34;]
        return {c.ConstrName: c.Slack for c in ineqs}
    def set_constraint_sense(self, cid: str, sense: str) -&gt; None:
        assert self.model is not None
        c = self.model.getConstrByName(cid)
        c.Sense = sense
    def get_constraint_sense(self, cid: str) -&gt; str:
        assert self.model is not None
        c = self.model.getConstrByName(cid)
        return c.Sense
    def relax(self) -&gt; None:
        assert self.model is not None
        self.model = self.model.relax()
        self._update_vars()
    def _extract_warm_start_value(self, log: str) -&gt; Optional[float]:
        ws = self.__extract(log, &#34;MIP start with objective ([0-9.e+-]*)&#34;)
        if ws is None:
            return None
        return float(ws)
    @staticmethod
    def __extract(
        log: str,
        regexp: str,
        default: Optional[str] = None,
    ) -&gt; Optional[str]:
        value = default
        for line in log.splitlines():
            matches = re.findall(regexp, line)
            if len(matches) == 0:
                continue
            value = matches[0]
        return value
    def __getstate__(self):
        return {
            &#34;params&#34;: self.params,
            &#34;lazy_cb_where&#34;: self.lazy_cb_where,
        }
    def __setstate__(self, state):
        self.params = state[&#34;params&#34;]
        self.lazy_cb_where = state[&#34;lazy_cb_where&#34;]
        self.instance = None
        self.model = None
        self._all_vars = None
        self._bin_vars = None
        self.cb_where = None</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.solvers.gurobi.GurobiSolver"><code class="flex name class">
 <span>class <span class="ident">GurobiSolver</span></span>
 <span>(</span><span>params=None, lazy_cb_frequency=1)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>An InternalSolver backed by Gurobi's Python API (without Pyomo).</p>
 <h2 id="parameters">Parameters</h2>
 <dl>
 <dt><strong><code>params</code></strong> :&ensp;<code>Optional</code>[<code>SolverParams</code>]</dt>
 <dd>Parameters to pass to Gurobi. For example, <code>params={"MIPGap": 1e-3}</code>
 sets the gap tolerance to 1e-3.</dd>
 <dt><strong><code>lazy_cb_frequency</code></strong> :&ensp;<code>int</code></dt>
 <dd>If 1, calls lazy constraint callbacks whenever an integer solution
 is found. If 2, calls it also at every node, after solving the
 LP relaxation of that node.</dd>
 </dl></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class GurobiSolver(InternalSolver):
    &#34;&#34;&#34;
    An InternalSolver backed by Gurobi&#39;s Python API (without Pyomo).
    Parameters
    ----------
    params: Optional[SolverParams]
        Parameters to pass to Gurobi. For example, `params={&#34;MIPGap&#34;: 1e-3}`
        sets the gap tolerance to 1e-3.
    lazy_cb_frequency: int
        If 1, calls lazy constraint callbacks whenever an integer solution
        is found. If 2, calls it also at every node, after solving the
        LP relaxation of that node.
    &#34;&#34;&#34;
    def __init__(
        self,
        params: Optional[SolverParams] = None,
        lazy_cb_frequency: int = 1,
    ) -&gt; None:
        import gurobipy
        if params is None:
            params = {}
        params[&#34;InfUnbdInfo&#34;] = True
        self.gp = gurobipy
        self.instance: Optional[Instance] = None
        self.model: Optional[&#34;gurobipy.Model&#34;] = None
        self.params: SolverParams = params
        self._all_vars: Dict = {}
        self._bin_vars: Optional[Dict[str, Dict[VarIndex, &#34;gurobipy.Var&#34;]]] = None
        self.cb_where: Optional[int] = None
        assert lazy_cb_frequency in [1, 2]
        if lazy_cb_frequency == 1:
            self.lazy_cb_where = [self.gp.GRB.Callback.MIPSOL]
        else:
            self.lazy_cb_where = [
                self.gp.GRB.Callback.MIPSOL,
                self.gp.GRB.Callback.MIPNODE,
            ]
    def set_instance(
        self,
        instance: Instance,
        model: Any = None,
    ) -&gt; None:
        self._raise_if_callback()
        if model is None:
            model = instance.to_model()
        assert isinstance(model, self.gp.Model)
        self.instance = instance
        self.model = model
        self.model.update()
        self._update_vars()
    def _raise_if_callback(self) -&gt; None:
        if self.cb_where is not None:
            raise Exception(&#34;method cannot be called from a callback&#34;)
    def _update_vars(self) -&gt; None:
        assert self.model is not None
        self._all_vars = {}
        self._bin_vars = {}
        idx: VarIndex
        for var in self.model.getVars():
            m = re.search(r&#34;([^[]*)\[(.*)]&#34;, var.varName)
            if m is None:
                name = var.varName
                idx = [0]
            else:
                name = m.group(1)
                parts = m.group(2).split(&#34;,&#34;)
                idx = [int(k) if k.isdecimal else k for k in parts]
            if len(idx) == 1:
                idx = idx[0]
            if name not in self._all_vars:
                self._all_vars[name] = {}
            self._all_vars[name][idx] = var
            if var.vtype != &#34;C&#34;:
                if name not in self._bin_vars:
                    self._bin_vars[name] = {}
                self._bin_vars[name][idx] = var
    def _apply_params(self, streams: List[Any]) -&gt; None:
        assert self.model is not None
        with _RedirectOutput(streams):
            for (name, value) in self.params.items():
                self.model.setParam(name, value)
            if &#34;seed&#34; not in [k.lower() for k in self.params.keys()]:
                self.model.setParam(&#34;Seed&#34;, randint(0, 1_000_000))
    def solve_lp(
        self,
        tee: bool = False,
    ) -&gt; LPSolveStats:
        self._raise_if_callback()
        streams: List[Any] = [StringIO()]
        if tee:
            streams += [sys.stdout]
        self._apply_params(streams)
        assert self.model is not None
        assert self._bin_vars is not None
        for (varname, vardict) in self._bin_vars.items():
            for (idx, var) in vardict.items():
                var.vtype = self.gp.GRB.CONTINUOUS
                var.lb = 0.0
                var.ub = 1.0
        with _RedirectOutput(streams):
            self.model.optimize()
        for (varname, vardict) in self._bin_vars.items():
            for (idx, var) in vardict.items():
                var.vtype = self.gp.GRB.BINARY
        log = streams[0].getvalue()
        opt_value = None
        if not self.is_infeasible():
            opt_value = self.model.objVal
        return {
            &#34;Optimal value&#34;: opt_value,
            &#34;Log&#34;: log,
        }
    def solve(
        self,
        tee: bool = False,
        iteration_cb: IterationCallback = None,
        lazy_cb: LazyCallback = None,
    ) -&gt; MIPSolveStats:
        self._raise_if_callback()
        assert self.model is not None
        def cb_wrapper(cb_model, cb_where):
            try:
                self.cb_where = cb_where
                if cb_where in self.lazy_cb_where:
                    lazy_cb(self, self.model)
            except:
                logger.exception(&#34;callback error&#34;)
            finally:
                self.cb_where = None
        if lazy_cb:
            self.params[&#34;LazyConstraints&#34;] = 1
        total_wallclock_time = 0
        total_nodes = 0
        streams: List[Any] = [StringIO()]
        if tee:
            streams += [sys.stdout]
        self._apply_params(streams)
        if iteration_cb is None:
            iteration_cb = lambda: False
        while True:
            with _RedirectOutput(streams):
                if lazy_cb is None:
                    self.model.optimize()
                else:
                    self.model.optimize(cb_wrapper)
            total_wallclock_time += self.model.runtime
            total_nodes += int(self.model.nodeCount)
            should_repeat = iteration_cb()
            if not should_repeat:
                break
        log = streams[0].getvalue()
        ub, lb = None, None
        sense = &#34;min&#34; if self.model.modelSense == 1 else &#34;max&#34;
        if self.model.solCount &gt; 0:
            if self.model.modelSense == 1:
                lb = self.model.objBound
                ub = self.model.objVal
            else:
                lb = self.model.objVal
                ub = self.model.objBound
        ws_value = self._extract_warm_start_value(log)
        stats: MIPSolveStats = {
            &#34;Lower bound&#34;: lb,
            &#34;Upper bound&#34;: ub,
            &#34;Wallclock time&#34;: total_wallclock_time,
            &#34;Nodes&#34;: total_nodes,
            &#34;Sense&#34;: sense,
            &#34;Log&#34;: log,
            &#34;Warm start value&#34;: ws_value,
            &#34;LP value&#34;: None,
        }
        return stats
    def get_solution(self) -&gt; Optional[Solution]:
        self._raise_if_callback()
        assert self.model is not None
        if self.model.solCount == 0:
            return None
        solution: Solution = {}
        for (varname, vardict) in self._all_vars.items():
            solution[varname] = {}
            for (idx, var) in vardict.items():
                solution[varname][idx] = var.x
        return solution
    def set_warm_start(self, solution: Solution) -&gt; None:
        self._raise_if_callback()
        self._clear_warm_start()
        count_fixed, count_total = 0, 0
        for (varname, vardict) in solution.items():
            for (idx, value) in vardict.items():
                count_total += 1
                if value is not None:
                    count_fixed += 1
                    self._all_vars[varname][idx].start = value
        logger.info(
            &#34;Setting start values for %d variables (out of %d)&#34;
            % (count_fixed, count_total)
        )
    def get_sense(self) -&gt; str:
        assert self.model is not None
        if self.model.modelSense == 1:
            return &#34;min&#34;
        else:
            return &#34;max&#34;
    def get_value(
        self,
        var_name: str,
        index: VarIndex,
    ) -&gt; Optional[float]:
        var = self._all_vars[var_name][index]
        return self._get_value(var)
    def is_infeasible(self) -&gt; bool:
        assert self.model is not None
        return self.model.status in [self.gp.GRB.INFEASIBLE, self.gp.GRB.INF_OR_UNBD]
    def get_dual(self, cid: str) -&gt; float:
        assert self.model is not None
        c = self.model.getConstrByName(cid)
        if self.is_infeasible():
            return c.farkasDual
        else:
            return c.pi
    def _get_value(self, var: Any) -&gt; Optional[float]:
        assert self.model is not None
        if self.cb_where == self.gp.GRB.Callback.MIPSOL:
            return self.model.cbGetSolution(var)
        elif self.cb_where == self.gp.GRB.Callback.MIPNODE:
            return self.model.cbGetNodeRel(var)
        elif self.cb_where is None:
            if self.is_infeasible():
                return None
            else:
                return var.x
        else:
            raise Exception(
                &#34;get_value cannot be called from cb_where=%s&#34; % self.cb_where
            )
    def get_empty_solution(self) -&gt; Solution:
        self._raise_if_callback()
        solution: Solution = {}
        for (varname, vardict) in self._all_vars.items():
            solution[varname] = {}
            for (idx, var) in vardict.items():
                solution[varname][idx] = None
        return solution
    def add_constraint(
        self,
        constraint: Any,
        name: str = &#34;&#34;,
    ) -&gt; None:
        assert self.model is not None
        if type(constraint) is tuple:
            lhs, sense, rhs, name = constraint
            if self.cb_where in [
                self.gp.GRB.Callback.MIPSOL,
                self.gp.GRB.Callback.MIPNODE,
            ]:
                self.model.cbLazy(lhs, sense, rhs)
            else:
                self.model.addConstr(lhs, sense, rhs, name)
        else:
            if self.cb_where in [
                self.gp.GRB.Callback.MIPSOL,
                self.gp.GRB.Callback.MIPNODE,
            ]:
                self.model.cbLazy(constraint)
            else:
                self.model.addConstr(constraint, name=name)
    def _clear_warm_start(self) -&gt; None:
        for (varname, vardict) in self._all_vars.items():
            for (idx, var) in vardict.items():
                var.start = self.gp.GRB.UNDEFINED
    def fix(self, solution: Solution) -&gt; None:
        self._raise_if_callback()
        for (varname, vardict) in solution.items():
            for (idx, value) in vardict.items():
                if value is None:
                    continue
                var = self._all_vars[varname][idx]
                var.vtype = self.gp.GRB.CONTINUOUS
                var.lb = value
                var.ub = value
    def get_constraint_ids(self):
        self._raise_if_callback()
        self.model.update()
        return [c.ConstrName for c in self.model.getConstrs()]
    def extract_constraint(self, cid):
        self._raise_if_callback()
        constr = self.model.getConstrByName(cid)
        cobj = (self.model.getRow(constr), constr.sense, constr.RHS, constr.ConstrName)
        self.model.remove(constr)
        return cobj
    def is_constraint_satisfied(self, cobj, tol=1e-5):
        lhs, sense, rhs, name = cobj
        if self.cb_where is not None:
            lhs_value = lhs.getConstant()
            for i in range(lhs.size()):
                var = lhs.getVar(i)
                coeff = lhs.getCoeff(i)
                lhs_value += self._get_value(var) * coeff
        else:
            lhs_value = lhs.getValue()
        if sense == &#34;&lt;&#34;:
            return lhs_value &lt;= rhs + tol
        elif sense == &#34;&gt;&#34;:
            return lhs_value &gt;= rhs - tol
        elif sense == &#34;=&#34;:
            return abs(rhs - lhs_value) &lt; abs(tol)
        else:
            raise Exception(&#34;Unknown sense: %s&#34; % sense)
    def get_inequality_slacks(self) -&gt; Dict[str, float]:
        assert self.model is not None
        ineqs = [c for c in self.model.getConstrs() if c.sense != &#34;=&#34;]
        return {c.ConstrName: c.Slack for c in ineqs}
    def set_constraint_sense(self, cid: str, sense: str) -&gt; None:
        assert self.model is not None
        c = self.model.getConstrByName(cid)
        c.Sense = sense
    def get_constraint_sense(self, cid: str) -&gt; str:
        assert self.model is not None
        c = self.model.getConstrByName(cid)
        return c.Sense
    def relax(self) -&gt; None:
        assert self.model is not None
        self.model = self.model.relax()
        self._update_vars()
    def _extract_warm_start_value(self, log: str) -&gt; Optional[float]:
        ws = self.__extract(log, &#34;MIP start with objective ([0-9.e+-]*)&#34;)
        if ws is None:
            return None
        return float(ws)
    @staticmethod
    def __extract(
        log: str,
        regexp: str,
        default: Optional[str] = None,
    ) -&gt; Optional[str]:
        value = default
        for line in log.splitlines():
            matches = re.findall(regexp, line)
            if len(matches) == 0:
                continue
            value = matches[0]
        return value
    def __getstate__(self):
        return {
            &#34;params&#34;: self.params,
            &#34;lazy_cb_where&#34;: self.lazy_cb_where,
        }
    def __setstate__(self, state):
        self.params = state[&#34;params&#34;]
        self.lazy_cb_where = state[&#34;lazy_cb_where&#34;]
        self.instance = None
        self.model = None
        self._all_vars = None
        self._bin_vars = None
        self.cb_where = None</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.solvers.internal.InternalSolver" href="internal.html#miplearn.solvers.internal.InternalSolver">InternalSolver</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.solvers.internal.InternalSolver" href="internal.html#miplearn.solvers.internal.InternalSolver">InternalSolver</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.solvers.internal.InternalSolver.add_constraint" href="internal.html#miplearn.solvers.internal.InternalSolver.add_constraint">add_constraint</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.extract_constraint" href="internal.html#miplearn.solvers.internal.InternalSolver.extract_constraint">extract_constraint</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.fix" href="internal.html#miplearn.solvers.internal.InternalSolver.fix">fix</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.get_constraint_ids" href="internal.html#miplearn.solvers.internal.InternalSolver.get_constraint_ids">get_constraint_ids</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.get_constraint_sense" href="internal.html#miplearn.solvers.internal.InternalSolver.get_constraint_sense">get_constraint_sense</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.get_dual" href="internal.html#miplearn.solvers.internal.InternalSolver.get_dual">get_dual</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.get_empty_solution" href="internal.html#miplearn.solvers.internal.InternalSolver.get_empty_solution">get_empty_solution</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.get_inequality_slacks" href="internal.html#miplearn.solvers.internal.InternalSolver.get_inequality_slacks">get_inequality_slacks</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.get_sense" href="internal.html#miplearn.solvers.internal.InternalSolver.get_sense">get_sense</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.get_solution" href="internal.html#miplearn.solvers.internal.InternalSolver.get_solution">get_solution</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.get_value" href="internal.html#miplearn.solvers.internal.InternalSolver.get_value">get_value</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.is_constraint_satisfied" href="internal.html#miplearn.solvers.internal.InternalSolver.is_constraint_satisfied">is_constraint_satisfied</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.is_infeasible" href="internal.html#miplearn.solvers.internal.InternalSolver.is_infeasible">is_infeasible</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.relax" href="internal.html#miplearn.solvers.internal.InternalSolver.relax">relax</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.set_branching_priorities" href="internal.html#miplearn.solvers.internal.InternalSolver.set_branching_priorities">set_branching_priorities</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.set_constraint_sense" href="internal.html#miplearn.solvers.internal.InternalSolver.set_constraint_sense">set_constraint_sense</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.set_instance" href="internal.html#miplearn.solvers.internal.InternalSolver.set_instance">set_instance</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.set_warm_start" href="internal.html#miplearn.solvers.internal.InternalSolver.set_warm_start">set_warm_start</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.solve" href="internal.html#miplearn.solvers.internal.InternalSolver.solve">solve</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.solve_lp" href="internal.html#miplearn.solvers.internal.InternalSolver.solve_lp">solve_lp</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.solvers" href="index.html">miplearn.solvers</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.solvers.gurobi.GurobiSolver" href="#miplearn.solvers.gurobi.GurobiSolver">GurobiSolver</a></code></h4>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/solvers/index.html
+++ b/0.2/api/miplearn/solvers/index.html
@ -1,118 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.solvers API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.solvers</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import logging
 import sys
 from typing import Any, List
 logger = logging.getLogger(__name__)
 class _RedirectOutput:
    def __init__(self, streams: List[Any]):
        self.streams = streams
    def write(self, data: Any) -&gt; None:
        for stream in self.streams:
            stream.write(data)
    def flush(self) -&gt; None:
        for stream in self.streams:
            stream.flush()
    def __enter__(self):
        self._original_stdout = sys.stdout
        self._original_stderr = sys.stderr
        sys.stdout = self
        sys.stderr = self
        return self
    def __exit__(self, _type, _value, _traceback):
        sys.stdout = self._original_stdout
        sys.stderr = self._original_stderr</code></pre>
 </details>
 </section>
 <section>
 <h2 class="section-title" id="header-submodules">Sub-modules</h2>
 <dl>
 <dt><code class="name"><a title="miplearn.solvers.gurobi" href="gurobi.html">miplearn.solvers.gurobi</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.solvers.internal" href="internal.html">miplearn.solvers.internal</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.solvers.learning" href="learning.html">miplearn.solvers.learning</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.solvers.pyomo" href="pyomo/index.html">miplearn.solvers.pyomo</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 </dl>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn" href="../index.html">miplearn</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-submodules">Sub-modules</a></h3>
 <ul>
 <li><code><a title="miplearn.solvers.gurobi" href="gurobi.html">miplearn.solvers.gurobi</a></code></li>
 <li><code><a title="miplearn.solvers.internal" href="internal.html">miplearn.solvers.internal</a></code></li>
 <li><code><a title="miplearn.solvers.learning" href="learning.html">miplearn.solvers.learning</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo" href="pyomo/index.html">miplearn.solvers.pyomo</a></code></li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/solvers/internal.html
+++ b/0.2/api/miplearn/solvers/internal.html
--- a/0.2/api/miplearn/solvers/learning.html
+++ b/0.2/api/miplearn/solvers/learning.html
--- a/0.2/api/miplearn/solvers/pyomo/base.html
+++ b/0.2/api/miplearn/solvers/pyomo/base.html
@ -1,730 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.solvers.pyomo.base API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.solvers.pyomo.base</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import logging
 import re
 import sys
 from io import StringIO
 from typing import Any, List, Dict, Optional
 import pyomo
 from pyomo import environ as pe
 from pyomo.core import Var, Constraint
 from pyomo.opt import TerminationCondition
 from pyomo.opt.base.solvers import SolverFactory
 from miplearn.instance import Instance
 from miplearn.solvers import _RedirectOutput
 from miplearn.solvers.internal import (
    InternalSolver,
    LPSolveStats,
    IterationCallback,
    LazyCallback,
    MIPSolveStats,
 )
 from miplearn.types import VarIndex, SolverParams, Solution
 logger = logging.getLogger(__name__)
 class BasePyomoSolver(InternalSolver):
    &#34;&#34;&#34;
    Base class for all Pyomo solvers.
    &#34;&#34;&#34;
    def __init__(
        self,
        solver_factory: SolverFactory,
        params: SolverParams,
    ) -&gt; None:
        self.instance: Optional[Instance] = None
        self.model: Optional[pe.ConcreteModel] = None
        self._all_vars: List[pe.Var] = []
        self._bin_vars: List[pe.Var] = []
        self._is_warm_start_available: bool = False
        self._pyomo_solver: SolverFactory = solver_factory
        self._obj_sense: str = &#34;min&#34;
        self._varname_to_var: Dict[str, pe.Var] = {}
        self._cname_to_constr: Dict[str, pe.Constraint] = {}
        self._termination_condition: str = &#34;&#34;
        for (key, value) in params.items():
            self._pyomo_solver.options[key] = value
    def solve_lp(
        self,
        tee: bool = False,
    ) -&gt; LPSolveStats:
        self.relax()
        streams: List[Any] = [StringIO()]
        if tee:
            streams += [sys.stdout]
        with _RedirectOutput(streams):
            results = self._pyomo_solver.solve(tee=True)
        self._restore_integrality()
        opt_value = None
        if not self.is_infeasible():
            opt_value = results[&#34;Problem&#34;][0][&#34;Lower bound&#34;]
        return {
            &#34;Optimal value&#34;: opt_value,
            &#34;Log&#34;: streams[0].getvalue(),
        }
    def _restore_integrality(self) -&gt; None:
        for var in self._bin_vars:
            var.domain = pyomo.core.base.set_types.Binary
            self._pyomo_solver.update_var(var)
    def solve(
        self,
        tee: bool = False,
        iteration_cb: IterationCallback = None,
        lazy_cb: LazyCallback = None,
    ) -&gt; MIPSolveStats:
        if lazy_cb is not None:
            raise Exception(&#34;lazy callback not supported&#34;)
        total_wallclock_time = 0
        streams: List[Any] = [StringIO()]
        if tee:
            streams += [sys.stdout]
        if iteration_cb is None:
            iteration_cb = lambda: False
        while True:
            logger.debug(&#34;Solving MIP...&#34;)
            with _RedirectOutput(streams):
                results = self._pyomo_solver.solve(
                    tee=True,
                    warmstart=self._is_warm_start_available,
                )
            total_wallclock_time += results[&#34;Solver&#34;][0][&#34;Wallclock time&#34;]
            should_repeat = iteration_cb()
            if not should_repeat:
                break
        log = streams[0].getvalue()
        node_count = self._extract_node_count(log)
        ws_value = self._extract_warm_start_value(log)
        self._termination_condition = results[&#34;Solver&#34;][0][&#34;Termination condition&#34;]
        lb, ub = None, None
        if not self.is_infeasible():
            lb = results[&#34;Problem&#34;][0][&#34;Lower bound&#34;]
            ub = results[&#34;Problem&#34;][0][&#34;Upper bound&#34;]
        stats: MIPSolveStats = {
            &#34;Lower bound&#34;: lb,
            &#34;Upper bound&#34;: ub,
            &#34;Wallclock time&#34;: total_wallclock_time,
            &#34;Sense&#34;: self._obj_sense,
            &#34;Log&#34;: log,
            &#34;Nodes&#34;: node_count,
            &#34;Warm start value&#34;: ws_value,
            &#34;LP value&#34;: None,
        }
        return stats
    def get_solution(self) -&gt; Optional[Solution]:
        assert self.model is not None
        if self.is_infeasible():
            return None
        solution: Solution = {}
        for var in self.model.component_objects(Var):
            solution[str(var)] = {}
            for index in var:
                if var[index].fixed:
                    continue
                solution[str(var)][index] = var[index].value
        return solution
    def set_warm_start(self, solution: Solution) -&gt; None:
        self._clear_warm_start()
        count_total, count_fixed = 0, 0
        for var_name in solution:
            var = self._varname_to_var[var_name]
            for index in solution[var_name]:
                count_total += 1
                var[index].value = solution[var_name][index]
                if solution[var_name][index] is not None:
                    count_fixed += 1
        if count_fixed &gt; 0:
            self._is_warm_start_available = True
        logger.info(
            &#34;Setting start values for %d variables (out of %d)&#34;
            % (count_fixed, count_total)
        )
    def set_instance(
        self,
        instance: Instance,
        model: Any = None,
    ) -&gt; None:
        if model is None:
            model = instance.to_model()
        assert isinstance(model, pe.ConcreteModel)
        self.instance = instance
        self.model = model
        self._pyomo_solver.set_instance(model)
        self._update_obj()
        self._update_vars()
        self._update_constrs()
    def get_value(self, var_name: str, index: VarIndex) -&gt; Optional[float]:
        if self.is_infeasible():
            return None
        else:
            var = self._varname_to_var[var_name]
            return var[index].value
    def get_empty_solution(self) -&gt; Solution:
        assert self.model is not None
        solution: Solution = {}
        for var in self.model.component_objects(Var):
            svar = str(var)
            solution[svar] = {}
            for index in var:
                if var[index].fixed:
                    continue
                solution[svar][index] = None
        return solution
    def _clear_warm_start(self) -&gt; None:
        for var in self._all_vars:
            if not var.fixed:
                var.value = None
        self._is_warm_start_available = False
    def _update_obj(self) -&gt; None:
        self._obj_sense = &#34;max&#34;
        if self._pyomo_solver._objective.sense == pyomo.core.kernel.objective.minimize:
            self._obj_sense = &#34;min&#34;
    def _update_vars(self) -&gt; None:
        assert self.model is not None
        self._all_vars = []
        self._bin_vars = []
        self._varname_to_var = {}
        for var in self.model.component_objects(Var):
            self._varname_to_var[var.name] = var
            for idx in var:
                self._all_vars += [var[idx]]
                if var[idx].domain == pyomo.core.base.set_types.Binary:
                    self._bin_vars += [var[idx]]
    def _update_constrs(self) -&gt; None:
        assert self.model is not None
        self._cname_to_constr = {}
        for constr in self.model.component_objects(Constraint):
            self._cname_to_constr[constr.name] = constr
    def fix(self, solution):
        count_total, count_fixed = 0, 0
        for varname in solution:
            for index in solution[varname]:
                var = self._varname_to_var[varname]
                count_total += 1
                if solution[varname][index] is None:
                    continue
                count_fixed += 1
                var[index].fix(solution[varname][index])
                self._pyomo_solver.update_var(var[index])
        logger.info(
            &#34;Fixing values for %d variables (out of %d)&#34;
            % (
                count_fixed,
                count_total,
            )
        )
    def add_constraint(self, constraint):
        self._pyomo_solver.add_constraint(constraint)
        self._update_constrs()
    @staticmethod
    def __extract(
        log: str,
        regexp: Optional[str],
        default: Optional[str] = None,
    ) -&gt; Optional[str]:
        if regexp is None:
            return default
        value = default
        for line in log.splitlines():
            matches = re.findall(regexp, line)
            if len(matches) == 0:
                continue
            value = matches[0]
        return value
    def _extract_warm_start_value(self, log: str) -&gt; Optional[float]:
        value = self.__extract(log, self._get_warm_start_regexp())
        if value is None:
            return None
        return float(value)
    def _extract_node_count(self, log: str) -&gt; Optional[int]:
        value = self.__extract(log, self._get_node_count_regexp())
        if value is None:
            return None
        return int(value)
    def get_constraint_ids(self):
        return list(self._cname_to_constr.keys())
    def _get_warm_start_regexp(self) -&gt; Optional[str]:
        return None
    def _get_node_count_regexp(self) -&gt; Optional[str]:
        return None
    def relax(self) -&gt; None:
        for var in self._bin_vars:
            lb, ub = var.bounds
            var.setlb(lb)
            var.setub(ub)
            var.domain = pyomo.core.base.set_types.Reals
            self._pyomo_solver.update_var(var)
    def get_inequality_slacks(self) -&gt; Dict[str, float]:
        result: Dict[str, float] = {}
        for (cname, cobj) in self._cname_to_constr.items():
            if cobj.equality:
                continue
            result[cname] = cobj.slack()
        return result
    def get_constraint_sense(self, cid: str) -&gt; str:
        cobj = self._cname_to_constr[cid]
        has_ub = cobj.has_ub()
        has_lb = cobj.has_lb()
        assert (not has_lb) or (not has_ub), &#34;range constraints not supported&#34;
        if has_lb:
            return &#34;&gt;&#34;
        elif has_ub:
            return &#34;&lt;&#34;
        else:
            return &#34;=&#34;
    def set_constraint_sense(self, cid: str, sense: str) -&gt; None:
        raise Exception(&#34;Not implemented&#34;)
    def extract_constraint(self, cid: str) -&gt; Constraint:
        raise Exception(&#34;Not implemented&#34;)
    def is_constraint_satisfied(self, cobj: Constraint) -&gt; bool:
        raise Exception(&#34;Not implemented&#34;)
    def is_infeasible(self) -&gt; bool:
        return self._termination_condition == TerminationCondition.infeasible
    def get_dual(self, cid):
        raise Exception(&#34;Not implemented&#34;)
    def get_sense(self) -&gt; str:
        return self._obj_sense</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.solvers.pyomo.base.BasePyomoSolver"><code class="flex name class">
 <span>class <span class="ident">BasePyomoSolver</span></span>
 <span>(</span><span>solver_factory, params)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>Base class for all Pyomo solvers.</p></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class BasePyomoSolver(InternalSolver):
    &#34;&#34;&#34;
    Base class for all Pyomo solvers.
    &#34;&#34;&#34;
    def __init__(
        self,
        solver_factory: SolverFactory,
        params: SolverParams,
    ) -&gt; None:
        self.instance: Optional[Instance] = None
        self.model: Optional[pe.ConcreteModel] = None
        self._all_vars: List[pe.Var] = []
        self._bin_vars: List[pe.Var] = []
        self._is_warm_start_available: bool = False
        self._pyomo_solver: SolverFactory = solver_factory
        self._obj_sense: str = &#34;min&#34;
        self._varname_to_var: Dict[str, pe.Var] = {}
        self._cname_to_constr: Dict[str, pe.Constraint] = {}
        self._termination_condition: str = &#34;&#34;
        for (key, value) in params.items():
            self._pyomo_solver.options[key] = value
    def solve_lp(
        self,
        tee: bool = False,
    ) -&gt; LPSolveStats:
        self.relax()
        streams: List[Any] = [StringIO()]
        if tee:
            streams += [sys.stdout]
        with _RedirectOutput(streams):
            results = self._pyomo_solver.solve(tee=True)
        self._restore_integrality()
        opt_value = None
        if not self.is_infeasible():
            opt_value = results[&#34;Problem&#34;][0][&#34;Lower bound&#34;]
        return {
            &#34;Optimal value&#34;: opt_value,
            &#34;Log&#34;: streams[0].getvalue(),
        }
    def _restore_integrality(self) -&gt; None:
        for var in self._bin_vars:
            var.domain = pyomo.core.base.set_types.Binary
            self._pyomo_solver.update_var(var)
    def solve(
        self,
        tee: bool = False,
        iteration_cb: IterationCallback = None,
        lazy_cb: LazyCallback = None,
    ) -&gt; MIPSolveStats:
        if lazy_cb is not None:
            raise Exception(&#34;lazy callback not supported&#34;)
        total_wallclock_time = 0
        streams: List[Any] = [StringIO()]
        if tee:
            streams += [sys.stdout]
        if iteration_cb is None:
            iteration_cb = lambda: False
        while True:
            logger.debug(&#34;Solving MIP...&#34;)
            with _RedirectOutput(streams):
                results = self._pyomo_solver.solve(
                    tee=True,
                    warmstart=self._is_warm_start_available,
                )
            total_wallclock_time += results[&#34;Solver&#34;][0][&#34;Wallclock time&#34;]
            should_repeat = iteration_cb()
            if not should_repeat:
                break
        log = streams[0].getvalue()
        node_count = self._extract_node_count(log)
        ws_value = self._extract_warm_start_value(log)
        self._termination_condition = results[&#34;Solver&#34;][0][&#34;Termination condition&#34;]
        lb, ub = None, None
        if not self.is_infeasible():
            lb = results[&#34;Problem&#34;][0][&#34;Lower bound&#34;]
            ub = results[&#34;Problem&#34;][0][&#34;Upper bound&#34;]
        stats: MIPSolveStats = {
            &#34;Lower bound&#34;: lb,
            &#34;Upper bound&#34;: ub,
            &#34;Wallclock time&#34;: total_wallclock_time,
            &#34;Sense&#34;: self._obj_sense,
            &#34;Log&#34;: log,
            &#34;Nodes&#34;: node_count,
            &#34;Warm start value&#34;: ws_value,
            &#34;LP value&#34;: None,
        }
        return stats
    def get_solution(self) -&gt; Optional[Solution]:
        assert self.model is not None
        if self.is_infeasible():
            return None
        solution: Solution = {}
        for var in self.model.component_objects(Var):
            solution[str(var)] = {}
            for index in var:
                if var[index].fixed:
                    continue
                solution[str(var)][index] = var[index].value
        return solution
    def set_warm_start(self, solution: Solution) -&gt; None:
        self._clear_warm_start()
        count_total, count_fixed = 0, 0
        for var_name in solution:
            var = self._varname_to_var[var_name]
            for index in solution[var_name]:
                count_total += 1
                var[index].value = solution[var_name][index]
                if solution[var_name][index] is not None:
                    count_fixed += 1
        if count_fixed &gt; 0:
            self._is_warm_start_available = True
        logger.info(
            &#34;Setting start values for %d variables (out of %d)&#34;
            % (count_fixed, count_total)
        )
    def set_instance(
        self,
        instance: Instance,
        model: Any = None,
    ) -&gt; None:
        if model is None:
            model = instance.to_model()
        assert isinstance(model, pe.ConcreteModel)
        self.instance = instance
        self.model = model
        self._pyomo_solver.set_instance(model)
        self._update_obj()
        self._update_vars()
        self._update_constrs()
    def get_value(self, var_name: str, index: VarIndex) -&gt; Optional[float]:
        if self.is_infeasible():
            return None
        else:
            var = self._varname_to_var[var_name]
            return var[index].value
    def get_empty_solution(self) -&gt; Solution:
        assert self.model is not None
        solution: Solution = {}
        for var in self.model.component_objects(Var):
            svar = str(var)
            solution[svar] = {}
            for index in var:
                if var[index].fixed:
                    continue
                solution[svar][index] = None
        return solution
    def _clear_warm_start(self) -&gt; None:
        for var in self._all_vars:
            if not var.fixed:
                var.value = None
        self._is_warm_start_available = False
    def _update_obj(self) -&gt; None:
        self._obj_sense = &#34;max&#34;
        if self._pyomo_solver._objective.sense == pyomo.core.kernel.objective.minimize:
            self._obj_sense = &#34;min&#34;
    def _update_vars(self) -&gt; None:
        assert self.model is not None
        self._all_vars = []
        self._bin_vars = []
        self._varname_to_var = {}
        for var in self.model.component_objects(Var):
            self._varname_to_var[var.name] = var
            for idx in var:
                self._all_vars += [var[idx]]
                if var[idx].domain == pyomo.core.base.set_types.Binary:
                    self._bin_vars += [var[idx]]
    def _update_constrs(self) -&gt; None:
        assert self.model is not None
        self._cname_to_constr = {}
        for constr in self.model.component_objects(Constraint):
            self._cname_to_constr[constr.name] = constr
    def fix(self, solution):
        count_total, count_fixed = 0, 0
        for varname in solution:
            for index in solution[varname]:
                var = self._varname_to_var[varname]
                count_total += 1
                if solution[varname][index] is None:
                    continue
                count_fixed += 1
                var[index].fix(solution[varname][index])
                self._pyomo_solver.update_var(var[index])
        logger.info(
            &#34;Fixing values for %d variables (out of %d)&#34;
            % (
                count_fixed,
                count_total,
            )
        )
    def add_constraint(self, constraint):
        self._pyomo_solver.add_constraint(constraint)
        self._update_constrs()
    @staticmethod
    def __extract(
        log: str,
        regexp: Optional[str],
        default: Optional[str] = None,
    ) -&gt; Optional[str]:
        if regexp is None:
            return default
        value = default
        for line in log.splitlines():
            matches = re.findall(regexp, line)
            if len(matches) == 0:
                continue
            value = matches[0]
        return value
    def _extract_warm_start_value(self, log: str) -&gt; Optional[float]:
        value = self.__extract(log, self._get_warm_start_regexp())
        if value is None:
            return None
        return float(value)
    def _extract_node_count(self, log: str) -&gt; Optional[int]:
        value = self.__extract(log, self._get_node_count_regexp())
        if value is None:
            return None
        return int(value)
    def get_constraint_ids(self):
        return list(self._cname_to_constr.keys())
    def _get_warm_start_regexp(self) -&gt; Optional[str]:
        return None
    def _get_node_count_regexp(self) -&gt; Optional[str]:
        return None
    def relax(self) -&gt; None:
        for var in self._bin_vars:
            lb, ub = var.bounds
            var.setlb(lb)
            var.setub(ub)
            var.domain = pyomo.core.base.set_types.Reals
            self._pyomo_solver.update_var(var)
    def get_inequality_slacks(self) -&gt; Dict[str, float]:
        result: Dict[str, float] = {}
        for (cname, cobj) in self._cname_to_constr.items():
            if cobj.equality:
                continue
            result[cname] = cobj.slack()
        return result
    def get_constraint_sense(self, cid: str) -&gt; str:
        cobj = self._cname_to_constr[cid]
        has_ub = cobj.has_ub()
        has_lb = cobj.has_lb()
        assert (not has_lb) or (not has_ub), &#34;range constraints not supported&#34;
        if has_lb:
            return &#34;&gt;&#34;
        elif has_ub:
            return &#34;&lt;&#34;
        else:
            return &#34;=&#34;
    def set_constraint_sense(self, cid: str, sense: str) -&gt; None:
        raise Exception(&#34;Not implemented&#34;)
    def extract_constraint(self, cid: str) -&gt; Constraint:
        raise Exception(&#34;Not implemented&#34;)
    def is_constraint_satisfied(self, cobj: Constraint) -&gt; bool:
        raise Exception(&#34;Not implemented&#34;)
    def is_infeasible(self) -&gt; bool:
        return self._termination_condition == TerminationCondition.infeasible
    def get_dual(self, cid):
        raise Exception(&#34;Not implemented&#34;)
    def get_sense(self) -&gt; str:
        return self._obj_sense</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.solvers.internal.InternalSolver" href="../internal.html#miplearn.solvers.internal.InternalSolver">InternalSolver</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Subclasses</h3>
 <ul class="hlist">
 <li><a title="miplearn.solvers.pyomo.cplex.CplexPyomoSolver" href="cplex.html#miplearn.solvers.pyomo.cplex.CplexPyomoSolver">CplexPyomoSolver</a></li>
 <li><a title="miplearn.solvers.pyomo.gurobi.GurobiPyomoSolver" href="gurobi.html#miplearn.solvers.pyomo.gurobi.GurobiPyomoSolver">GurobiPyomoSolver</a></li>
 <li><a title="miplearn.solvers.pyomo.xpress.XpressPyomoSolver" href="xpress.html#miplearn.solvers.pyomo.xpress.XpressPyomoSolver">XpressPyomoSolver</a></li>
 </ul>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.solvers.internal.InternalSolver" href="../internal.html#miplearn.solvers.internal.InternalSolver">InternalSolver</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.solvers.internal.InternalSolver.add_constraint" href="../internal.html#miplearn.solvers.internal.InternalSolver.add_constraint">add_constraint</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.extract_constraint" href="../internal.html#miplearn.solvers.internal.InternalSolver.extract_constraint">extract_constraint</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.fix" href="../internal.html#miplearn.solvers.internal.InternalSolver.fix">fix</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.get_constraint_ids" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_constraint_ids">get_constraint_ids</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.get_constraint_sense" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_constraint_sense">get_constraint_sense</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.get_dual" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_dual">get_dual</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.get_empty_solution" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_empty_solution">get_empty_solution</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.get_inequality_slacks" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_inequality_slacks">get_inequality_slacks</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.get_sense" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_sense">get_sense</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.get_solution" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_solution">get_solution</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.get_value" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_value">get_value</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.is_constraint_satisfied" href="../internal.html#miplearn.solvers.internal.InternalSolver.is_constraint_satisfied">is_constraint_satisfied</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.is_infeasible" href="../internal.html#miplearn.solvers.internal.InternalSolver.is_infeasible">is_infeasible</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.relax" href="../internal.html#miplearn.solvers.internal.InternalSolver.relax">relax</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.set_branching_priorities" href="../internal.html#miplearn.solvers.internal.InternalSolver.set_branching_priorities">set_branching_priorities</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.set_constraint_sense" href="../internal.html#miplearn.solvers.internal.InternalSolver.set_constraint_sense">set_constraint_sense</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.set_instance" href="../internal.html#miplearn.solvers.internal.InternalSolver.set_instance">set_instance</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.set_warm_start" href="../internal.html#miplearn.solvers.internal.InternalSolver.set_warm_start">set_warm_start</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.solve" href="../internal.html#miplearn.solvers.internal.InternalSolver.solve">solve</a></code></li>
 <li><code><a title="miplearn.solvers.internal.InternalSolver.solve_lp" href="../internal.html#miplearn.solvers.internal.InternalSolver.solve_lp">solve_lp</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.solvers.pyomo" href="index.html">miplearn.solvers.pyomo</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver" href="#miplearn.solvers.pyomo.base.BasePyomoSolver">BasePyomoSolver</a></code></h4>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/solvers/pyomo/cplex.html
+++ b/0.2/api/miplearn/solvers/pyomo/cplex.html
@ -1,193 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.solvers.pyomo.cplex API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.solvers.pyomo.cplex</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 from typing import Optional
 from pyomo import environ as pe
 from scipy.stats import randint
 from miplearn.solvers.pyomo.base import BasePyomoSolver
 from miplearn.types import SolverParams
 class CplexPyomoSolver(BasePyomoSolver):
    &#34;&#34;&#34;
    An InternalSolver that uses CPLEX and the Pyomo modeling language.
    Parameters
    ----------
    params: dict
        Dictionary of options to pass to the Pyomo solver. For example,
        {&#34;mip_display&#34;: 5} to increase the log verbosity.
    &#34;&#34;&#34;
    def __init__(
        self,
        params: Optional[SolverParams] = None,
    ) -&gt; None:
        if params is None:
            params = {}
        if &#34;randomseed&#34; not in params.keys():
            params[&#34;randomseed&#34;] = randint(low=0, high=1000).rvs()
        if &#34;mip_display&#34; not in params.keys():
            params[&#34;mip_display&#34;] = 4
        super().__init__(
            solver_factory=pe.SolverFactory(&#34;cplex_persistent&#34;),
            params=params,
        )
    def _get_warm_start_regexp(self):
        return &#34;MIP start .* with objective ([0-9.e+-]*)\\.&#34;
    def _get_node_count_regexp(self):
        return &#34;^[ *] *([0-9]+)&#34;</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.solvers.pyomo.cplex.CplexPyomoSolver"><code class="flex name class">
 <span>class <span class="ident">CplexPyomoSolver</span></span>
 <span>(</span><span>params=None)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>An InternalSolver that uses CPLEX and the Pyomo modeling language.</p>
 <h2 id="parameters">Parameters</h2>
 <dl>
 <dt><strong><code>params</code></strong> :&ensp;<code>dict</code></dt>
 <dd>Dictionary of options to pass to the Pyomo solver. For example,
 {"mip_display": 5} to increase the log verbosity.</dd>
 </dl></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class CplexPyomoSolver(BasePyomoSolver):
    &#34;&#34;&#34;
    An InternalSolver that uses CPLEX and the Pyomo modeling language.
    Parameters
    ----------
    params: dict
        Dictionary of options to pass to the Pyomo solver. For example,
        {&#34;mip_display&#34;: 5} to increase the log verbosity.
    &#34;&#34;&#34;
    def __init__(
        self,
        params: Optional[SolverParams] = None,
    ) -&gt; None:
        if params is None:
            params = {}
        if &#34;randomseed&#34; not in params.keys():
            params[&#34;randomseed&#34;] = randint(low=0, high=1000).rvs()
        if &#34;mip_display&#34; not in params.keys():
            params[&#34;mip_display&#34;] = 4
        super().__init__(
            solver_factory=pe.SolverFactory(&#34;cplex_persistent&#34;),
            params=params,
        )
    def _get_warm_start_regexp(self):
        return &#34;MIP start .* with objective ([0-9.e+-]*)\\.&#34;
    def _get_node_count_regexp(self):
        return &#34;^[ *] *([0-9]+)&#34;</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.solvers.pyomo.base.BasePyomoSolver" href="base.html#miplearn.solvers.pyomo.base.BasePyomoSolver">BasePyomoSolver</a></li>
 <li><a title="miplearn.solvers.internal.InternalSolver" href="../internal.html#miplearn.solvers.internal.InternalSolver">InternalSolver</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.solvers.pyomo.base.BasePyomoSolver" href="base.html#miplearn.solvers.pyomo.base.BasePyomoSolver">BasePyomoSolver</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.add_constraint" href="../internal.html#miplearn.solvers.internal.InternalSolver.add_constraint">add_constraint</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.extract_constraint" href="../internal.html#miplearn.solvers.internal.InternalSolver.extract_constraint">extract_constraint</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.fix" href="../internal.html#miplearn.solvers.internal.InternalSolver.fix">fix</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_constraint_ids" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_constraint_ids">get_constraint_ids</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_constraint_sense" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_constraint_sense">get_constraint_sense</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_dual" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_dual">get_dual</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_empty_solution" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_empty_solution">get_empty_solution</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_inequality_slacks" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_inequality_slacks">get_inequality_slacks</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_sense" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_sense">get_sense</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_solution" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_solution">get_solution</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_value" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_value">get_value</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.is_constraint_satisfied" href="../internal.html#miplearn.solvers.internal.InternalSolver.is_constraint_satisfied">is_constraint_satisfied</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.is_infeasible" href="../internal.html#miplearn.solvers.internal.InternalSolver.is_infeasible">is_infeasible</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.relax" href="../internal.html#miplearn.solvers.internal.InternalSolver.relax">relax</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.set_branching_priorities" href="../internal.html#miplearn.solvers.internal.InternalSolver.set_branching_priorities">set_branching_priorities</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.set_constraint_sense" href="../internal.html#miplearn.solvers.internal.InternalSolver.set_constraint_sense">set_constraint_sense</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.set_instance" href="../internal.html#miplearn.solvers.internal.InternalSolver.set_instance">set_instance</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.set_warm_start" href="../internal.html#miplearn.solvers.internal.InternalSolver.set_warm_start">set_warm_start</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.solve" href="../internal.html#miplearn.solvers.internal.InternalSolver.solve">solve</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.solve_lp" href="../internal.html#miplearn.solvers.internal.InternalSolver.solve_lp">solve_lp</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.solvers.pyomo" href="index.html">miplearn.solvers.pyomo</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.solvers.pyomo.cplex.CplexPyomoSolver" href="#miplearn.solvers.pyomo.cplex.CplexPyomoSolver">CplexPyomoSolver</a></code></h4>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/solvers/pyomo/gurobi.html
+++ b/0.2/api/miplearn/solvers/pyomo/gurobi.html
@ -1,221 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.solvers.pyomo.gurobi API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.solvers.pyomo.gurobi</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import logging
 from typing import Optional
 from pyomo import environ as pe
 from scipy.stats import randint
 from miplearn.solvers.pyomo.base import BasePyomoSolver
 from miplearn.types import SolverParams, BranchPriorities
 logger = logging.getLogger(__name__)
 class GurobiPyomoSolver(BasePyomoSolver):
    &#34;&#34;&#34;
    An InternalSolver that uses Gurobi and the Pyomo modeling language.
    Parameters
    ----------
    params: dict
        Dictionary of options to pass to the Pyomo solver. For example,
        {&#34;Threads&#34;: 4} to set the number of threads.
    &#34;&#34;&#34;
    def __init__(
        self,
        params: SolverParams = None,
    ) -&gt; None:
        if params is None:
            params = {}
        if &#34;seed&#34; not in params.keys():
            params[&#34;seed&#34;] = randint(low=0, high=1000).rvs()
        super().__init__(
            solver_factory=pe.SolverFactory(&#34;gurobi_persistent&#34;),
            params=params,
        )
    def _extract_node_count(self, log: str) -&gt; int:
        return max(1, int(self._pyomo_solver._solver_model.getAttr(&#34;NodeCount&#34;)))
    def _get_warm_start_regexp(self) -&gt; str:
        return &#34;MIP start with objective ([0-9.e+-]*)&#34;
    def _get_node_count_regexp(self) -&gt; Optional[str]:
        return None
    def set_branching_priorities(self, priorities: BranchPriorities) -&gt; None:
        from gurobipy import GRB
        for varname in priorities.keys():
            var = self._varname_to_var[varname]
            for (index, priority) in priorities[varname].items():
                if priority is None:
                    continue
                gvar = self._pyomo_solver._pyomo_var_to_solver_var_map[var[index]]
                gvar.setAttr(GRB.Attr.BranchPriority, int(round(priority)))</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.solvers.pyomo.gurobi.GurobiPyomoSolver"><code class="flex name class">
 <span>class <span class="ident">GurobiPyomoSolver</span></span>
 <span>(</span><span>params=None)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>An InternalSolver that uses Gurobi and the Pyomo modeling language.</p>
 <h2 id="parameters">Parameters</h2>
 <dl>
 <dt><strong><code>params</code></strong> :&ensp;<code>dict</code></dt>
 <dd>Dictionary of options to pass to the Pyomo solver. For example,
 {"Threads": 4} to set the number of threads.</dd>
 </dl></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class GurobiPyomoSolver(BasePyomoSolver):
    &#34;&#34;&#34;
    An InternalSolver that uses Gurobi and the Pyomo modeling language.
    Parameters
    ----------
    params: dict
        Dictionary of options to pass to the Pyomo solver. For example,
        {&#34;Threads&#34;: 4} to set the number of threads.
    &#34;&#34;&#34;
    def __init__(
        self,
        params: SolverParams = None,
    ) -&gt; None:
        if params is None:
            params = {}
        if &#34;seed&#34; not in params.keys():
            params[&#34;seed&#34;] = randint(low=0, high=1000).rvs()
        super().__init__(
            solver_factory=pe.SolverFactory(&#34;gurobi_persistent&#34;),
            params=params,
        )
    def _extract_node_count(self, log: str) -&gt; int:
        return max(1, int(self._pyomo_solver._solver_model.getAttr(&#34;NodeCount&#34;)))
    def _get_warm_start_regexp(self) -&gt; str:
        return &#34;MIP start with objective ([0-9.e+-]*)&#34;
    def _get_node_count_regexp(self) -&gt; Optional[str]:
        return None
    def set_branching_priorities(self, priorities: BranchPriorities) -&gt; None:
        from gurobipy import GRB
        for varname in priorities.keys():
            var = self._varname_to_var[varname]
            for (index, priority) in priorities[varname].items():
                if priority is None:
                    continue
                gvar = self._pyomo_solver._pyomo_var_to_solver_var_map[var[index]]
                gvar.setAttr(GRB.Attr.BranchPriority, int(round(priority)))</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.solvers.pyomo.base.BasePyomoSolver" href="base.html#miplearn.solvers.pyomo.base.BasePyomoSolver">BasePyomoSolver</a></li>
 <li><a title="miplearn.solvers.internal.InternalSolver" href="../internal.html#miplearn.solvers.internal.InternalSolver">InternalSolver</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.solvers.pyomo.base.BasePyomoSolver" href="base.html#miplearn.solvers.pyomo.base.BasePyomoSolver">BasePyomoSolver</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.add_constraint" href="../internal.html#miplearn.solvers.internal.InternalSolver.add_constraint">add_constraint</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.extract_constraint" href="../internal.html#miplearn.solvers.internal.InternalSolver.extract_constraint">extract_constraint</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.fix" href="../internal.html#miplearn.solvers.internal.InternalSolver.fix">fix</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_constraint_ids" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_constraint_ids">get_constraint_ids</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_constraint_sense" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_constraint_sense">get_constraint_sense</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_dual" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_dual">get_dual</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_empty_solution" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_empty_solution">get_empty_solution</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_inequality_slacks" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_inequality_slacks">get_inequality_slacks</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_sense" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_sense">get_sense</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_solution" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_solution">get_solution</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_value" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_value">get_value</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.is_constraint_satisfied" href="../internal.html#miplearn.solvers.internal.InternalSolver.is_constraint_satisfied">is_constraint_satisfied</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.is_infeasible" href="../internal.html#miplearn.solvers.internal.InternalSolver.is_infeasible">is_infeasible</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.relax" href="../internal.html#miplearn.solvers.internal.InternalSolver.relax">relax</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.set_branching_priorities" href="../internal.html#miplearn.solvers.internal.InternalSolver.set_branching_priorities">set_branching_priorities</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.set_constraint_sense" href="../internal.html#miplearn.solvers.internal.InternalSolver.set_constraint_sense">set_constraint_sense</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.set_instance" href="../internal.html#miplearn.solvers.internal.InternalSolver.set_instance">set_instance</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.set_warm_start" href="../internal.html#miplearn.solvers.internal.InternalSolver.set_warm_start">set_warm_start</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.solve" href="../internal.html#miplearn.solvers.internal.InternalSolver.solve">solve</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.solve_lp" href="../internal.html#miplearn.solvers.internal.InternalSolver.solve_lp">solve_lp</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.solvers.pyomo" href="index.html">miplearn.solvers.pyomo</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.solvers.pyomo.gurobi.GurobiPyomoSolver" href="#miplearn.solvers.pyomo.gurobi.GurobiPyomoSolver">GurobiPyomoSolver</a></code></h4>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/solvers/pyomo/index.html
+++ b/0.2/api/miplearn/solvers/pyomo/index.html
@ -1,88 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.solvers.pyomo API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.solvers.pyomo</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.</code></pre>
 </details>
 </section>
 <section>
 <h2 class="section-title" id="header-submodules">Sub-modules</h2>
 <dl>
 <dt><code class="name"><a title="miplearn.solvers.pyomo.base" href="base.html">miplearn.solvers.pyomo.base</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.solvers.pyomo.cplex" href="cplex.html">miplearn.solvers.pyomo.cplex</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.solvers.pyomo.gurobi" href="gurobi.html">miplearn.solvers.pyomo.gurobi</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 <dt><code class="name"><a title="miplearn.solvers.pyomo.xpress" href="xpress.html">miplearn.solvers.pyomo.xpress</a></code></dt>
 <dd>
 <section class="desc"></section>
 </dd>
 </dl>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.solvers" href="../index.html">miplearn.solvers</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-submodules">Sub-modules</a></h3>
 <ul>
 <li><code><a title="miplearn.solvers.pyomo.base" href="base.html">miplearn.solvers.pyomo.base</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.cplex" href="cplex.html">miplearn.solvers.pyomo.cplex</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.gurobi" href="gurobi.html">miplearn.solvers.pyomo.gurobi</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.xpress" href="xpress.html">miplearn.solvers.pyomo.xpress</a></code></li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/solvers/pyomo/xpress.html
+++ b/0.2/api/miplearn/solvers/pyomo/xpress.html
@ -1,174 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.solvers.pyomo.xpress API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.solvers.pyomo.xpress</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 import logging
 from pyomo import environ as pe
 from scipy.stats import randint
 from miplearn.solvers.pyomo.base import BasePyomoSolver
 from miplearn.types import SolverParams
 logger = logging.getLogger(__name__)
 class XpressPyomoSolver(BasePyomoSolver):
    &#34;&#34;&#34;
    An InternalSolver that uses XPRESS and the Pyomo modeling language.
    Parameters
    ----------
    params: dict
        Dictionary of options to pass to the Pyomo solver. For example,
        {&#34;Threads&#34;: 4} to set the number of threads.
    &#34;&#34;&#34;
    def __init__(self, params: SolverParams = None) -&gt; None:
        if params is None:
            params = {}
        if &#34;randomseed&#34; not in params.keys():
            params[&#34;randomseed&#34;] = randint(low=0, high=1000).rvs()
        super().__init__(
            solver_factory=pe.SolverFactory(&#34;xpress_persistent&#34;),
            params=params,
        )</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.solvers.pyomo.xpress.XpressPyomoSolver"><code class="flex name class">
 <span>class <span class="ident">XpressPyomoSolver</span></span>
 <span>(</span><span>params=None)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>An InternalSolver that uses XPRESS and the Pyomo modeling language.</p>
 <h2 id="parameters">Parameters</h2>
 <dl>
 <dt><strong><code>params</code></strong> :&ensp;<code>dict</code></dt>
 <dd>Dictionary of options to pass to the Pyomo solver. For example,
 {"Threads": 4} to set the number of threads.</dd>
 </dl></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class XpressPyomoSolver(BasePyomoSolver):
    &#34;&#34;&#34;
    An InternalSolver that uses XPRESS and the Pyomo modeling language.
    Parameters
    ----------
    params: dict
        Dictionary of options to pass to the Pyomo solver. For example,
        {&#34;Threads&#34;: 4} to set the number of threads.
    &#34;&#34;&#34;
    def __init__(self, params: SolverParams = None) -&gt; None:
        if params is None:
            params = {}
        if &#34;randomseed&#34; not in params.keys():
            params[&#34;randomseed&#34;] = randint(low=0, high=1000).rvs()
        super().__init__(
            solver_factory=pe.SolverFactory(&#34;xpress_persistent&#34;),
            params=params,
        )</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li><a title="miplearn.solvers.pyomo.base.BasePyomoSolver" href="base.html#miplearn.solvers.pyomo.base.BasePyomoSolver">BasePyomoSolver</a></li>
 <li><a title="miplearn.solvers.internal.InternalSolver" href="../internal.html#miplearn.solvers.internal.InternalSolver">InternalSolver</a></li>
 <li>abc.ABC</li>
 </ul>
 <h3>Inherited members</h3>
 <ul class="hlist">
 <li><code><b><a title="miplearn.solvers.pyomo.base.BasePyomoSolver" href="base.html#miplearn.solvers.pyomo.base.BasePyomoSolver">BasePyomoSolver</a></b></code>:
 <ul class="hlist">
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.add_constraint" href="../internal.html#miplearn.solvers.internal.InternalSolver.add_constraint">add_constraint</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.extract_constraint" href="../internal.html#miplearn.solvers.internal.InternalSolver.extract_constraint">extract_constraint</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.fix" href="../internal.html#miplearn.solvers.internal.InternalSolver.fix">fix</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_constraint_ids" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_constraint_ids">get_constraint_ids</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_constraint_sense" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_constraint_sense">get_constraint_sense</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_dual" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_dual">get_dual</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_empty_solution" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_empty_solution">get_empty_solution</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_inequality_slacks" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_inequality_slacks">get_inequality_slacks</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_sense" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_sense">get_sense</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_solution" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_solution">get_solution</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.get_value" href="../internal.html#miplearn.solvers.internal.InternalSolver.get_value">get_value</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.is_constraint_satisfied" href="../internal.html#miplearn.solvers.internal.InternalSolver.is_constraint_satisfied">is_constraint_satisfied</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.is_infeasible" href="../internal.html#miplearn.solvers.internal.InternalSolver.is_infeasible">is_infeasible</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.relax" href="../internal.html#miplearn.solvers.internal.InternalSolver.relax">relax</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.set_branching_priorities" href="../internal.html#miplearn.solvers.internal.InternalSolver.set_branching_priorities">set_branching_priorities</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.set_constraint_sense" href="../internal.html#miplearn.solvers.internal.InternalSolver.set_constraint_sense">set_constraint_sense</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.set_instance" href="../internal.html#miplearn.solvers.internal.InternalSolver.set_instance">set_instance</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.set_warm_start" href="../internal.html#miplearn.solvers.internal.InternalSolver.set_warm_start">set_warm_start</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.solve" href="../internal.html#miplearn.solvers.internal.InternalSolver.solve">solve</a></code></li>
 <li><code><a title="miplearn.solvers.pyomo.base.BasePyomoSolver.solve_lp" href="../internal.html#miplearn.solvers.internal.InternalSolver.solve_lp">solve_lp</a></code></li>
 </ul>
 </li>
 </ul>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn.solvers.pyomo" href="index.html">miplearn.solvers.pyomo</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.solvers.pyomo.xpress.XpressPyomoSolver" href="#miplearn.solvers.pyomo.xpress.XpressPyomoSolver">XpressPyomoSolver</a></code></h4>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/api/miplearn/types.html
+++ b/0.2/api/miplearn/types.html
@ -1,256 +0,0 @@
 <!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
 <meta name="generator" content="pdoc 0.7.5" />
 <title>miplearn.types API documentation</title>
 <meta name="description" content="" />
 <link href='https://cdnjs.cloudflare.com/ajax/libs/normalize/8.0.0/normalize.min.css' rel='stylesheet'>
 <link href='https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/8.0.0/sanitize.min.css' rel='stylesheet'>
 <link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/github.min.css" rel="stylesheet">
 <style>.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{font-weight:bold}#index h4 + ul{margin-bottom:.6em}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
 <style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
 <style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
 </head>
 <body>
 <main>
 <article id="content">
 <header>
 <h1 class="title">Module <code>miplearn.types</code></h1>
 </header>
 <section id="section-intro">
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">#  MIPLearn: Extensible Framework for Learning-Enhanced Mixed-Integer Optimization
 #  Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved.
 #  Released under the modified BSD license. See COPYING.md for more details.
 from typing import Optional, Dict, Callable, Any, Union, List
 from mypy_extensions import TypedDict
 VarIndex = Union[str, int, List[Union[str, int]]]
 Solution = Dict[str, Dict[VarIndex, Optional[float]]]
 TrainingSample = TypedDict(
    &#34;TrainingSample&#34;,
    {
        &#34;LP log&#34;: str,
        &#34;LP solution&#34;: Optional[Solution],
        &#34;LP value&#34;: Optional[float],
        &#34;Lower bound&#34;: Optional[float],
        &#34;MIP log&#34;: str,
        &#34;Solution&#34;: Optional[Solution],
        &#34;Upper bound&#34;: Optional[float],
        &#34;slacks&#34;: Dict,
    },
    total=False,
 )
 LPSolveStats = TypedDict(
    &#34;LPSolveStats&#34;,
    {
        &#34;Optimal value&#34;: Optional[float],
        &#34;Log&#34;: str,
    },
 )
 MIPSolveStats = TypedDict(
    &#34;MIPSolveStats&#34;,
    {
        &#34;Lower bound&#34;: Optional[float],
        &#34;Upper bound&#34;: Optional[float],
        &#34;Wallclock time&#34;: float,
        &#34;Nodes&#34;: Optional[int],
        &#34;Sense&#34;: str,
        &#34;Log&#34;: str,
        &#34;Warm start value&#34;: Optional[float],
        &#34;LP value&#34;: Optional[float],
    },
 )
 LearningSolveStats = TypedDict(
    &#34;LearningSolveStats&#34;,
    {
        &#34;Gap&#34;: Optional[float],
        &#34;Instance&#34;: Union[str, int],
        &#34;LP value&#34;: Optional[float],
        &#34;Log&#34;: str,
        &#34;Lower bound&#34;: Optional[float],
        &#34;Mode&#34;: str,
        &#34;Nodes&#34;: Optional[int],
        &#34;Sense&#34;: str,
        &#34;Solver&#34;: str,
        &#34;Upper bound&#34;: Optional[float],
        &#34;Wallclock time&#34;: float,
        &#34;Warm start value&#34;: Optional[float],
    },
    total=False,
 )
 IterationCallback = Callable[[], bool]
 LazyCallback = Callable[[Any, Any], None]
 SolverParams = Dict[str, Any]
 BranchPriorities = Solution
 class Constraint:
    pass</code></pre>
 </details>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 </section>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="miplearn.types.Constraint"><code class="flex name class">
 <span>class <span class="ident">Constraint</span></span>
 </code></dt>
 <dd>
 <section class="desc"></section>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">class Constraint:
    pass</code></pre>
 </details>
 </dd>
 <dt id="miplearn.types.LPSolveStats"><code class="flex name class">
 <span>class <span class="ident">LPSolveStats</span></span>
 <span>(</span><span>*args, **kwargs)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>dict() -&gt; new empty dictionary
 dict(mapping) -&gt; new dictionary initialized from a mapping object's
 (key, value) pairs
 dict(iterable) -&gt; new dictionary initialized as if via:
 d = {}
 for k, v in iterable:
 d[k] = v
 dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs
 in the keyword argument list.
 For example:
 dict(one=1, two=2)</p></section>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li>builtins.dict</li>
 </ul>
 </dd>
 <dt id="miplearn.types.LearningSolveStats"><code class="flex name class">
 <span>class <span class="ident">LearningSolveStats</span></span>
 <span>(</span><span>*args, **kwargs)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>dict() -&gt; new empty dictionary
 dict(mapping) -&gt; new dictionary initialized from a mapping object's
 (key, value) pairs
 dict(iterable) -&gt; new dictionary initialized as if via:
 d = {}
 for k, v in iterable:
 d[k] = v
 dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs
 in the keyword argument list.
 For example:
 dict(one=1, two=2)</p></section>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li>builtins.dict</li>
 </ul>
 </dd>
 <dt id="miplearn.types.MIPSolveStats"><code class="flex name class">
 <span>class <span class="ident">MIPSolveStats</span></span>
 <span>(</span><span>*args, **kwargs)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>dict() -&gt; new empty dictionary
 dict(mapping) -&gt; new dictionary initialized from a mapping object's
 (key, value) pairs
 dict(iterable) -&gt; new dictionary initialized as if via:
 d = {}
 for k, v in iterable:
 d[k] = v
 dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs
 in the keyword argument list.
 For example:
 dict(one=1, two=2)</p></section>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li>builtins.dict</li>
 </ul>
 </dd>
 <dt id="miplearn.types.TrainingSample"><code class="flex name class">
 <span>class <span class="ident">TrainingSample</span></span>
 <span>(</span><span>*args, **kwargs)</span>
 </code></dt>
 <dd>
 <section class="desc"><p>dict() -&gt; new empty dictionary
 dict(mapping) -&gt; new dictionary initialized from a mapping object's
 (key, value) pairs
 dict(iterable) -&gt; new dictionary initialized as if via:
 d = {}
 for k, v in iterable:
 d[k] = v
 dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs
 in the keyword argument list.
 For example:
 dict(one=1, two=2)</p></section>
 <h3>Ancestors</h3>
 <ul class="hlist">
 <li>builtins.dict</li>
 </ul>
 </dd>
 </dl>
 </section>
 </article>
 <nav id="sidebar">
 <h1>Index</h1>
 <div class="toc">
 <ul></ul>
 </div>
 <ul id="index">
 <li><h3>Super-module</h3>
 <ul>
 <li><code><a title="miplearn" href="index.html">miplearn</a></code></li>
 </ul>
 </li>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
 <h4><code><a title="miplearn.types.Constraint" href="#miplearn.types.Constraint">Constraint</a></code></h4>
 </li>
 <li>
 <h4><code><a title="miplearn.types.LPSolveStats" href="#miplearn.types.LPSolveStats">LPSolveStats</a></code></h4>
 </li>
 <li>
 <h4><code><a title="miplearn.types.LearningSolveStats" href="#miplearn.types.LearningSolveStats">LearningSolveStats</a></code></h4>
 </li>
 <li>
 <h4><code><a title="miplearn.types.MIPSolveStats" href="#miplearn.types.MIPSolveStats">MIPSolveStats</a></code></h4>
 </li>
 <li>
 <h4><code><a title="miplearn.types.TrainingSample" href="#miplearn.types.TrainingSample">TrainingSample</a></code></h4>
 </li>
 </ul>
 </li>
 </ul>
 </nav>
 </main>
 <footer id="footer">
 <p>Generated by <a href="https://pdoc3.github.io/pdoc"><cite>pdoc</cite> 0.7.5</a>.</p>
 </footer>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad()</script>
 </body>
 </html>
--- a/0.2/benchmark/index.html
+++ b/0.2/benchmark/index.html
@ -0,0 +1,477 @@
 <!DOCTYPE html>
 <html>
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>2. Benchmarks &#8212; MIPLearn&lt;br/&gt;&lt;small&gt;0.2.0&lt;/small&gt;</title>
  <link href="../_static/css/theme.css" rel="stylesheet" />
  <link href="../_static/css/index.c5995385ac14fb8791e8eb36b4908be2.css" rel="stylesheet" />
  <link rel="stylesheet"
    href="../_static/vendor/fontawesome/5.13.0/css/all.min.css">
  <link rel="preload" as="font" type="font/woff2" crossorigin
    href="../_static/vendor/fontawesome/5.13.0/webfonts/fa-solid-900.woff2">
  <link rel="preload" as="font" type="font/woff2" crossorigin
    href="../_static/vendor/fontawesome/5.13.0/webfonts/fa-brands-400.woff2">
    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
    <link rel="stylesheet" href="../_static/sphinx-book-theme.acff12b8f9c144ce68a297486a2fa670.css" type="text/css" />
    <link rel="stylesheet" type="text/css" href="../_static/custom.css" />
  <link rel="preload" as="script" href="../_static/js/index.1c5a1a01449ed65a7b51.js">
    <script id="documentation_options" data-url_root="../" src="../_static/documentation_options.js"></script>
    <script src="../_static/jquery.js"></script>
    <script src="../_static/underscore.js"></script>
    <script src="../_static/doctools.js"></script>
    <script src="../_static/sphinx-book-theme.12a9622fbb08dcb3a2a40b2c02b83a57.js"></script>
    <script async="async" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/latest.js?config=TeX-AMS-MML_HTMLorMML"></script>
    <script type="text/x-mathjax-config">MathJax.Hub.Config({"tex2jax": {"inlineMath": [["\\(", "\\)"]], "displayMath": [["\\[", "\\]"]], "processRefs": false, "processEnvironments": false}})</script>
    <link rel="author" title="About these documents" href="../about/" />
    <link rel="index" title="Index" href="../genindex/" />
    <link rel="search" title="Search" href="../search/" />
    <link rel="next" title="3. Customization" href="../customization/" />
    <link rel="prev" title="1. Using MIPLearn" href="../usage/" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <meta name="docsearch:language" content="en" />
  </head>
  <body data-spy="scroll" data-target="#bd-toc-nav" data-offset="80">
    <div class="container-fluid" id="banner"></div>
    <div class="container-xl">
      <div class="row">
 <div class="col-12 col-md-3 bd-sidebar site-navigation show" id="site-navigation">
        <div class="navbar-brand-box">
    <a class="navbar-brand text-wrap" href="../">
      <h1 class="site-logo" id="site-title">MIPLearn<br/><small>0.2.0</small></h1>
    </a>
 </div><form class="bd-search d-flex align-items-center" action="../search/" method="get">
  <i class="icon fas fa-search"></i>
  <input type="search" class="form-control" name="q" id="search-input" placeholder="Search the docs ..." aria-label="Search the docs ..." autocomplete="off" >
 </form><nav class="bd-links" id="bd-docs-nav" aria-label="Main navigation">
    <div class="bd-toc-item active">
        <ul class="current nav bd-sidenav">
 <li class="toctree-l1">
  <a class="reference internal" href="../usage/">
   <span class="sectnum">
    1.
   </span>
   Using MIPLearn
  </a>
 </li>
 <li class="toctree-l1 current active">
  <a class="current reference internal" href="#">
   <span class="sectnum">
    2.
   </span>
   Benchmarks
  </a>
 </li>
 <li class="toctree-l1">
  <a class="reference internal" href="../customization/">
   <span class="sectnum">
    3.
   </span>
   Customization
  </a>
 </li>
 <li class="toctree-l1">
  <a class="reference internal" href="../about/">
   <span class="sectnum">
    4.
   </span>
   About
  </a>
 </li>
 </ul>
    </div>
 </nav> <!-- To handle the deprecated key -->
 </div>
 <main class="col py-md-3 pl-md-4 bd-content overflow-auto" role="main">
    <div class="topbar container-xl fixed-top">
    <div class="topbar-contents row">
        <div class="col-12 col-md-3 bd-topbar-whitespace site-navigation show"></div>
        <div class="col pl-md-4 topbar-main">
            <button id="navbar-toggler" class="navbar-toggler ml-0" type="button" data-toggle="collapse"
                data-toggle="tooltip" data-placement="bottom" data-target=".site-navigation" aria-controls="navbar-menu"
                aria-expanded="true" aria-label="Toggle navigation" aria-controls="site-navigation"
                title="Toggle navigation" data-toggle="tooltip" data-placement="left">
                <i class="fas fa-bars"></i>
                <i class="fas fa-arrow-left"></i>
                <i class="fas fa-arrow-up"></i>
            </button>
 <div class="dropdown-buttons-trigger">
    <button id="dropdown-buttons-trigger" class="btn btn-secondary topbarbtn" aria-label="Download this page"><i
            class="fas fa-download"></i></button>
    <div class="dropdown-buttons">
        <!-- ipynb file if we had a myst markdown file -->
        <!-- Download raw file -->
        <a class="dropdown-buttons" href="../_sources/benchmark.md.txt"><button type="button"
                class="btn btn-secondary topbarbtn" title="Download source file" data-toggle="tooltip"
                data-placement="left">.md</button></a>
        <!-- Download PDF via print -->
        <button type="button" id="download-print" class="btn btn-secondary topbarbtn" title="Print to PDF"
            onClick="window.print()" data-toggle="tooltip" data-placement="left">.pdf</button>
    </div>
 </div>
            <!-- Source interaction buttons -->
 <div class="dropdown-buttons-trigger">
    <button id="dropdown-buttons-trigger" class="btn btn-secondary topbarbtn"
        aria-label="Connect with source repository"><i class="fab fa-github"></i></button>
    <div class="dropdown-buttons sourcebuttons">
        <a class="repository-button"
            href="https://github.com/ANL-CEEESA/MIPLearn/"><button type="button" class="btn btn-secondary topbarbtn"
                data-toggle="tooltip" data-placement="left" title="Source repository"><i
                    class="fab fa-github"></i>repository</button></a>
    </div>
 </div>
            <!-- Full screen (wrap in <a> to have style consistency -->
 <a class="full-screen-button"><button type="button" class="btn btn-secondary topbarbtn" data-toggle="tooltip"
        data-placement="bottom" onclick="toggleFullScreen()" aria-label="Fullscreen mode"
        title="Fullscreen mode"><i
            class="fas fa-expand"></i></button></a>
            <!-- Launch buttons -->
        </div>
        <!-- Table of contents -->
        <div class="d-none d-md-block col-md-2 bd-toc show">
            <div class="tocsection onthispage pt-5 pb-3">
                <i class="fas fa-list"></i> Contents
            </div>
            <nav id="bd-toc-nav">
                <ul class="visible nav section-nav flex-column">
 <li class="toc-h2 nav-item toc-entry">
  <a class="reference internal nav-link" href="#preliminaries">
   <span class="sectnum">
    2.1.
   </span>
   Preliminaries
  </a>
  <ul class="nav section-nav flex-column">
   <li class="toc-h3 nav-item toc-entry">
    <a class="reference internal nav-link" href="#benchmark-challenges">
     Benchmark challenges
    </a>
   </li>
   <li class="toc-h3 nav-item toc-entry">
    <a class="reference internal nav-link" href="#baseline-results">
     Baseline results
    </a>
   </li>
  </ul>
 </li>
 <li class="toc-h2 nav-item toc-entry">
  <a class="reference internal nav-link" href="#maximum-weight-stable-set-problem">
   <span class="sectnum">
    2.2.
   </span>
   Maximum Weight Stable Set Problem
  </a>
  <ul class="nav section-nav flex-column">
   <li class="toc-h3 nav-item toc-entry">
    <a class="reference internal nav-link" href="#problem-definition">
     Problem definition
    </a>
   </li>
   <li class="toc-h3 nav-item toc-entry">
    <a class="reference internal nav-link" href="#random-instance-generator">
     Random instance generator
    </a>
   </li>
   <li class="toc-h3 nav-item toc-entry">
    <a class="reference internal nav-link" href="#challenge-a">
     Challenge A
    </a>
   </li>
  </ul>
 </li>
 <li class="toc-h2 nav-item toc-entry">
  <a class="reference internal nav-link" href="#traveling-salesman-problem">
   <span class="sectnum">
    2.3.
   </span>
   Traveling Salesman Problem
  </a>
  <ul class="nav section-nav flex-column">
   <li class="toc-h3 nav-item toc-entry">
    <a class="reference internal nav-link" href="#id1">
     Problem definition
    </a>
   </li>
   <li class="toc-h3 nav-item toc-entry">
    <a class="reference internal nav-link" href="#random-problem-generator">
     Random problem generator
    </a>
   </li>
   <li class="toc-h3 nav-item toc-entry">
    <a class="reference internal nav-link" href="#id2">
     Challenge A
    </a>
   </li>
  </ul>
 </li>
 <li class="toc-h2 nav-item toc-entry">
  <a class="reference internal nav-link" href="#multidimensional-0-1-knapsack-problem">
   <span class="sectnum">
    2.4.
   </span>
   Multidimensional 0-1 Knapsack Problem
  </a>
  <ul class="nav section-nav flex-column">
   <li class="toc-h3 nav-item toc-entry">
    <a class="reference internal nav-link" href="#id3">
     Problem definition
    </a>
   </li>
   <li class="toc-h3 nav-item toc-entry">
    <a class="reference internal nav-link" href="#id4">
     Random instance generator
    </a>
   </li>
   <li class="toc-h3 nav-item toc-entry">
    <a class="reference internal nav-link" href="#id5">
     Challenge A
    </a>
   </li>
  </ul>
 </li>
 </ul>
            </nav>
        </div>
    </div>
 </div>
    <div id="main-content" class="row">
        <div class="col-12 col-md-9 pl-md-3 pr-md-0">
              <div>
  <div class="section" id="benchmarks">
 <h1><span class="sectnum">2.</span> Benchmarks<a class="headerlink" href="#benchmarks" title="Permalink to this headline">¶</a></h1>
 <p>MIPLearn provides a selection of benchmark problems and random instance generators, covering applications from different fields, that can be used to evaluate new learning-enhanced MIP techniques in a measurable and reproducible way. In this page, we describe these problems, the included instance generators, and we present some benchmark results for  <code class="docutils literal notranslate"><span class="pre">LearningSolver</span></code> with default parameters.</p>
 <div class="section" id="preliminaries">
 <h2><span class="sectnum">2.1.</span> Preliminaries<a class="headerlink" href="#preliminaries" title="Permalink to this headline">¶</a></h2>
 <div class="section" id="benchmark-challenges">
 <h3>Benchmark challenges<a class="headerlink" href="#benchmark-challenges" title="Permalink to this headline">¶</a></h3>
 <p>When evaluating the performance of a conventional MIP solver, <em>benchmark sets</em>, such as MIPLIB and TSPLIB, are typically used. The performance of newly proposed solvers or solution techniques are typically measured as the average (or total) running time the solver takes to solve the entire benchmark set. For Learning-Enhanced MIP solvers, it is also necessary to specify what instances should the solver be trained on (the <em>training instances</em>) before solving the actual set of instances we are interested in (the <em>test instances</em>). If the training instances are very similar to the test instances, we would expect a Learning-Enhanced Solver to present stronger perfomance benefits.</p>
 <p>In MIPLearn, each optimization problem comes with a set of <strong>benchmark challenges</strong>, which specify how should the training and test instances be generated. The first challenges are typically easier, in the sense that training and test instances are very similar. Later challenges gradually make the sets more distinct, and therefore harder to learn from.</p>
 </div>
 <div class="section" id="baseline-results">
 <h3>Baseline results<a class="headerlink" href="#baseline-results" title="Permalink to this headline">¶</a></h3>
 <p>To illustrate the performance of <code class="docutils literal notranslate"><span class="pre">LearningSolver</span></code>, and to set a baseline for newly proposed techniques, we present in this page, for each benchmark challenge, a small set of computational results measuring the solution speed of the solver and the solution quality with default parameters. For more detailed computational studies, see <a class="reference external" href="about.md#references">references</a>. We compare three solvers:</p>
 <ul class="simple">
 <li><p><strong>baseline:</strong> Gurobi 9.0 with default settings (a conventional state-of-the-art MIP solver)</p></li>
 <li><p><strong>ml-exact:</strong> <code class="docutils literal notranslate"><span class="pre">LearningSolver</span></code> with default settings, using Gurobi 9.0 as internal MIP solver</p></li>
 <li><p><strong>ml-heuristic:</strong> Same as above, but with <code class="docutils literal notranslate"><span class="pre">mode=&quot;heuristic&quot;</span></code></p></li>
 </ul>
 <p>All experiments presented here were performed on a Linux server (Ubuntu Linux 18.04 LTS) with Intel Xeon Gold 6230s (2 processors, 40 cores, 80 threads) and 256 GB RAM (DDR4, 2933 MHz). All solvers were restricted to use 4 threads, with no time limits, and 10 instances were solved simultaneously at a time.</p>
 </div>
 </div>
 <div class="section" id="maximum-weight-stable-set-problem">
 <h2><span class="sectnum">2.2.</span> Maximum Weight Stable Set Problem<a class="headerlink" href="#maximum-weight-stable-set-problem" title="Permalink to this headline">¶</a></h2>
 <div class="section" id="problem-definition">
 <h3>Problem definition<a class="headerlink" href="#problem-definition" title="Permalink to this headline">¶</a></h3>
 <p>Given a simple undirected graph <span class="math notranslate nohighlight">\(G=(V,E)\)</span> and weights <span class="math notranslate nohighlight">\(w \in \mathbb{R}^V\)</span>, the problem is to find a stable set <span class="math notranslate nohighlight">\(S \subseteq V\)</span> that maximizes <span class="math notranslate nohighlight">\( \sum_{v \in V} w_v\)</span>. We recall that a subset <span class="math notranslate nohighlight">\(S \subseteq V\)</span> is a <em>stable set</em> if no two vertices of <span class="math notranslate nohighlight">\(S\)</span> are adjacent. This is one of Karp’s 21 NP-complete problems.</p>
 </div>
 <div class="section" id="random-instance-generator">
 <h3>Random instance generator<a class="headerlink" href="#random-instance-generator" title="Permalink to this headline">¶</a></h3>
 <p>The class <code class="docutils literal notranslate"><span class="pre">MaxWeightStableSetGenerator</span></code> can be used to generate random instances of this problem, with user-specified probability distributions. When the constructor parameter <code class="docutils literal notranslate"><span class="pre">fix_graph=True</span></code> is provided, one random Erdős-Rényi graph <span class="math notranslate nohighlight">\(G_{n,p}\)</span> is generated during the constructor, where <span class="math notranslate nohighlight">\(n\)</span> and <span class="math notranslate nohighlight">\(p\)</span> are sampled from user-provided probability distributions <code class="docutils literal notranslate"><span class="pre">n</span></code> and <code class="docutils literal notranslate"><span class="pre">p</span></code>. To generate each instance, the generator independently samples each <span class="math notranslate nohighlight">\(w_v\)</span> from the user-provided probability distribution <code class="docutils literal notranslate"><span class="pre">w</span></code>. When <code class="docutils literal notranslate"><span class="pre">fix_graph=False</span></code>, a new random graph is generated for each instance, while the remaining parameters are sampled in the same way.</p>
 </div>
 <div class="section" id="challenge-a">
 <h3>Challenge A<a class="headerlink" href="#challenge-a" title="Permalink to this headline">¶</a></h3>
 <ul class="simple">
 <li><p>Fixed random Erdős-Rényi graph <span class="math notranslate nohighlight">\(G_{n,p}\)</span> with <span class="math notranslate nohighlight">\(n=200\)</span> and <span class="math notranslate nohighlight">\(p=5\%\)</span></p></li>
 <li><p>Random vertex weights <span class="math notranslate nohighlight">\(w_v \sim U(100, 150)\)</span></p></li>
 <li><p>500 training instances, 50 test instances</p></li>
 </ul>
 <div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">MaxWeightStableSetGenerator</span><span class="p">(</span><span class="n">w</span><span class="o">=</span><span class="n">uniform</span><span class="p">(</span><span class="n">loc</span><span class="o">=</span><span class="mf">100.</span><span class="p">,</span> <span class="n">scale</span><span class="o">=</span><span class="mf">50.</span><span class="p">),</span>
                            <span class="n">n</span><span class="o">=</span><span class="n">randint</span><span class="p">(</span><span class="n">low</span><span class="o">=</span><span class="mi">200</span><span class="p">,</span> <span class="n">high</span><span class="o">=</span><span class="mi">201</span><span class="p">),</span>
                            <span class="n">p</span><span class="o">=</span><span class="n">uniform</span><span class="p">(</span><span class="n">loc</span><span class="o">=</span><span class="mf">0.05</span><span class="p">,</span> <span class="n">scale</span><span class="o">=</span><span class="mf">0.0</span><span class="p">),</span>
                            <span class="n">fix_graph</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
 </pre></div>
 </div>
 <p><img alt="alt" src="figures/benchmark_stab_a.png" /></p>
 </div>
 </div>
 <div class="section" id="traveling-salesman-problem">
 <h2><span class="sectnum">2.3.</span> Traveling Salesman Problem<a class="headerlink" href="#traveling-salesman-problem" title="Permalink to this headline">¶</a></h2>
 <div class="section" id="id1">
 <h3>Problem definition<a class="headerlink" href="#id1" title="Permalink to this headline">¶</a></h3>
 <p>Given a list of cities and the distance between each pair of cities, the problem asks for the
 shortest route starting at the first city, visiting each other city exactly once, then returning
 to the first city. This problem is a generalization of the Hamiltonian path problem, one of Karp’s
 21 NP-complete problems.</p>
 </div>
 <div class="section" id="random-problem-generator">
 <h3>Random problem generator<a class="headerlink" href="#random-problem-generator" title="Permalink to this headline">¶</a></h3>
 <p>The class <code class="docutils literal notranslate"><span class="pre">TravelingSalesmanGenerator</span></code> can be used to generate random instances of this
 problem. Initially, the generator creates <span class="math notranslate nohighlight">\(n\)</span> cities <span class="math notranslate nohighlight">\((x_1,y_1),\ldots,(x_n,y_n) \in \mathbb{R}^2\)</span>,
 where <span class="math notranslate nohighlight">\(n, x_i\)</span> and <span class="math notranslate nohighlight">\(y_i\)</span> are sampled independently from the provided probability distributions <code class="docutils literal notranslate"><span class="pre">n</span></code>,
 <code class="docutils literal notranslate"><span class="pre">x</span></code> and <code class="docutils literal notranslate"><span class="pre">y</span></code>. For each pair of cities <span class="math notranslate nohighlight">\((i,j)\)</span>, the distance <span class="math notranslate nohighlight">\(d_{i,j}\)</span> between them is set to:
 $<span class="math notranslate nohighlight">\(
    d_{i,j} = \gamma_{i,j} \sqrt{(x_i-x_j)^2 + (y_i - y_j)^2}
 \)</span><span class="math notranslate nohighlight">\(
 where \)</span>\gamma_{i,j}$ is sampled from the distribution <code class="docutils literal notranslate"><span class="pre">gamma</span></code>.</p>
 <p>If <code class="docutils literal notranslate"><span class="pre">fix_cities=True</span></code> is provided, the list of cities is kept the same for all generated instances.
 The <span class="math notranslate nohighlight">\(gamma\)</span> values, and therefore also the distances, are still different.</p>
 <p>By default, all distances <span class="math notranslate nohighlight">\(d_{i,j}\)</span> are rounded to the nearest integer.  If <code class="docutils literal notranslate"><span class="pre">round=False</span></code>
 is provided, this rounding will be disabled.</p>
 </div>
 <div class="section" id="id2">
 <h3>Challenge A<a class="headerlink" href="#id2" title="Permalink to this headline">¶</a></h3>
 <ul class="simple">
 <li><p>Fixed list of 350 cities in the <span class="math notranslate nohighlight">\([0, 1000]^2\)</span> square</p></li>
 <li><p><span class="math notranslate nohighlight">\(\gamma_{i,j} \sim U(0.95, 1.05)\)</span></p></li>
 <li><p>500 training instances, 50 test instances</p></li>
 </ul>
 <div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">TravelingSalesmanGenerator</span><span class="p">(</span><span class="n">x</span><span class="o">=</span><span class="n">uniform</span><span class="p">(</span><span class="n">loc</span><span class="o">=</span><span class="mf">0.0</span><span class="p">,</span> <span class="n">scale</span><span class="o">=</span><span class="mf">1000.0</span><span class="p">),</span>
                           <span class="n">y</span><span class="o">=</span><span class="n">uniform</span><span class="p">(</span><span class="n">loc</span><span class="o">=</span><span class="mf">0.0</span><span class="p">,</span> <span class="n">scale</span><span class="o">=</span><span class="mf">1000.0</span><span class="p">),</span>
                           <span class="n">n</span><span class="o">=</span><span class="n">randint</span><span class="p">(</span><span class="n">low</span><span class="o">=</span><span class="mi">350</span><span class="p">,</span> <span class="n">high</span><span class="o">=</span><span class="mi">351</span><span class="p">),</span>
                           <span class="n">gamma</span><span class="o">=</span><span class="n">uniform</span><span class="p">(</span><span class="n">loc</span><span class="o">=</span><span class="mf">0.95</span><span class="p">,</span> <span class="n">scale</span><span class="o">=</span><span class="mf">0.1</span><span class="p">),</span>
                           <span class="n">fix_cities</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span>
                           <span class="nb">round</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span>
                          <span class="p">)</span>
 </pre></div>
 </div>
 <p><img alt="alt" src="figures/benchmark_tsp_a.png" /></p>
 </div>
 </div>
 <div class="section" id="multidimensional-0-1-knapsack-problem">
 <h2><span class="sectnum">2.4.</span> Multidimensional 0-1 Knapsack Problem<a class="headerlink" href="#multidimensional-0-1-knapsack-problem" title="Permalink to this headline">¶</a></h2>
 <div class="section" id="id3">
 <h3>Problem definition<a class="headerlink" href="#id3" title="Permalink to this headline">¶</a></h3>
 <p>Given a set of <span class="math notranslate nohighlight">\(n\)</span> items and <span class="math notranslate nohighlight">\(m\)</span> types of resources (also called <em>knapsacks</em>), the problem is to find a subset of items that maximizes profit without consuming more resources than it is available. More precisely, the problem is:</p>
 <div class="math notranslate nohighlight">
 \[\begin{split}
 \begin{align*}
    \text{maximize}
        &amp; \sum_{j=1}^n p_j x_j
        \\
    \text{subject to}
        &amp; \sum_{j=1}^n w_{ij} x_j \leq b_i
        &amp; \forall i=1,\ldots,m \\
    &amp; x_j \in \{0,1\}
        &amp; \forall j=1,\ldots,n
 \end{align*}
 \end{split}\]</div>
 </div>
 <div class="section" id="id4">
 <h3>Random instance generator<a class="headerlink" href="#id4" title="Permalink to this headline">¶</a></h3>
 <p>The class <code class="docutils literal notranslate"><span class="pre">MultiKnapsackGenerator</span></code> can be used to generate random instances of this problem. The number of items <span class="math notranslate nohighlight">\(n\)</span> and knapsacks <span class="math notranslate nohighlight">\(m\)</span> are sampled from the user-provided probability distributions <code class="docutils literal notranslate"><span class="pre">n</span></code> and <code class="docutils literal notranslate"><span class="pre">m</span></code>. The weights <span class="math notranslate nohighlight">\(w_{ij}\)</span> are sampled independently from the provided distribution <code class="docutils literal notranslate"><span class="pre">w</span></code>. The capacity of knapsack <span class="math notranslate nohighlight">\(i\)</span> is set to</p>
 <div class="math notranslate nohighlight">
 \[
    b_i = \alpha_i \sum_{j=1}^n w_{ij}
 \]</div>
 <p>where <span class="math notranslate nohighlight">\(\alpha_i\)</span>, the tightness ratio, is sampled from the provided probability
 distribution <code class="docutils literal notranslate"><span class="pre">alpha</span></code>. To make the instances more challenging, the costs of the items
 are linearly correlated to their average weights. More specifically, the price of each
 item <span class="math notranslate nohighlight">\(j\)</span> is set to:</p>
 <div class="math notranslate nohighlight">
 \[
    p_j = \sum_{i=1}^m \frac{w_{ij}}{m} + K  u_j,
 \]</div>
 <p>where <span class="math notranslate nohighlight">\(K\)</span>, the correlation coefficient, and <span class="math notranslate nohighlight">\(u_j\)</span>, the correlation multiplier, are sampled
 from the provided probability distributions <code class="docutils literal notranslate"><span class="pre">K</span></code> and <code class="docutils literal notranslate"><span class="pre">u</span></code>.</p>
 <p>If <code class="docutils literal notranslate"><span class="pre">fix_w=True</span></code> is provided, then <span class="math notranslate nohighlight">\(w_{ij}\)</span> are kept the same in all generated instances. This also implies that <span class="math notranslate nohighlight">\(n\)</span> and <span class="math notranslate nohighlight">\(m\)</span> are kept fixed. Although the prices and capacities are derived from <span class="math notranslate nohighlight">\(w_{ij}\)</span>, as long as <code class="docutils literal notranslate"><span class="pre">u</span></code> and <code class="docutils literal notranslate"><span class="pre">K</span></code> are not constants, the generated instances will still not be completely identical.</p>
 <p>If a probability distribution <code class="docutils literal notranslate"><span class="pre">w_jitter</span></code> is provided, then item weights will be set to <span class="math notranslate nohighlight">\(w_{ij} \gamma_{ij}\)</span> where <span class="math notranslate nohighlight">\(\gamma_{ij}\)</span> is sampled from <code class="docutils literal notranslate"><span class="pre">w_jitter</span></code>. When combined with <code class="docutils literal notranslate"><span class="pre">fix_w=True</span></code>, this argument may be used to generate instances where the weight of each item is roughly the same, but not exactly identical, across all instances. The prices of the items and the capacities of the knapsacks will be calculated as above, but using these perturbed weights instead.</p>
 <p>By default, all generated prices, weights and capacities are rounded to the nearest integer number. If <code class="docutils literal notranslate"><span class="pre">round=False</span></code> is provided, this rounding will be disabled.</p>
 <p>!!! note “References”
 * Freville, Arnaud, and Gérard Plateau. <em>An efficient preprocessing procedure for the multidimensional 0–1 knapsack problem.</em> Discrete applied mathematics 49.1-3 (1994): 189-212.
 * Fréville, Arnaud. <em>The multidimensional 0–1 knapsack problem: An overview.</em> European Journal of Operational Research 155.1 (2004): 1-21.</p>
 </div>
 <div class="section" id="id5">
 <h3>Challenge A<a class="headerlink" href="#id5" title="Permalink to this headline">¶</a></h3>
 <ul class="simple">
 <li><p>250 variables, 10 constraints, fixed weights</p></li>
 <li><p><span class="math notranslate nohighlight">\(w \sim U(0, 1000), \gamma \sim U(0.95, 1.05)\)</span></p></li>
 <li><p><span class="math notranslate nohighlight">\(K = 500, u \sim U(0, 1), \alpha = 0.25\)</span></p></li>
 <li><p>500 training instances, 50 test instances</p></li>
 </ul>
 <div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">MultiKnapsackGenerator</span><span class="p">(</span><span class="n">n</span><span class="o">=</span><span class="n">randint</span><span class="p">(</span><span class="n">low</span><span class="o">=</span><span class="mi">250</span><span class="p">,</span> <span class="n">high</span><span class="o">=</span><span class="mi">251</span><span class="p">),</span>
                       <span class="n">m</span><span class="o">=</span><span class="n">randint</span><span class="p">(</span><span class="n">low</span><span class="o">=</span><span class="mi">10</span><span class="p">,</span> <span class="n">high</span><span class="o">=</span><span class="mi">11</span><span class="p">),</span>
                       <span class="n">w</span><span class="o">=</span><span class="n">uniform</span><span class="p">(</span><span class="n">loc</span><span class="o">=</span><span class="mf">0.0</span><span class="p">,</span> <span class="n">scale</span><span class="o">=</span><span class="mf">1000.0</span><span class="p">),</span>
                       <span class="n">K</span><span class="o">=</span><span class="n">uniform</span><span class="p">(</span><span class="n">loc</span><span class="o">=</span><span class="mf">500.0</span><span class="p">,</span> <span class="n">scale</span><span class="o">=</span><span class="mf">0.0</span><span class="p">),</span>
                       <span class="n">u</span><span class="o">=</span><span class="n">uniform</span><span class="p">(</span><span class="n">loc</span><span class="o">=</span><span class="mf">0.0</span><span class="p">,</span> <span class="n">scale</span><span class="o">=</span><span class="mf">1.0</span><span class="p">),</span>
                       <span class="n">alpha</span><span class="o">=</span><span class="n">uniform</span><span class="p">(</span><span class="n">loc</span><span class="o">=</span><span class="mf">0.25</span><span class="p">,</span> <span class="n">scale</span><span class="o">=</span><span class="mf">0.0</span><span class="p">),</span>
                       <span class="n">fix_w</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span>
                       <span class="n">w_jitter</span><span class="o">=</span><span class="n">uniform</span><span class="p">(</span><span class="n">loc</span><span class="o">=</span><span class="mf">0.95</span><span class="p">,</span> <span class="n">scale</span><span class="o">=</span><span class="mf">0.1</span><span class="p">),</span>
                      <span class="p">)</span>
 </pre></div>
 </div>
 <p><img alt="alt" src="figures/benchmark_knapsack_a.png" /></p>
 </div>
 </div>
 </div>
              </div>
        <div class='prev-next-bottom'>
    <a class='left-prev' id="prev-link" href="../usage/" title="previous page"><span class="sectnum">1.</span> Using MIPLearn</a>
    <a class='right-next' id="next-link" href="../customization/" title="next page"><span class="sectnum">3.</span> Customization</a>
        </div>
        </div>
    </div>
    <footer class="footer mt-5 mt-md-0">
    <div class="container">
      <p>
            &copy; Copyright 2020-2021, UChicago Argonne, LLC.<br/>
      </p>
    </div>
  </footer>
 </main>
      </div>
    </div>
  <script src="../_static/js/index.1c5a1a01449ed65a7b51.js"></script>
  </body>
 </html>
--- a/0.2/css/base.css
+++ b/0.2/css/base.css
@ -1,289 +0,0 @@
 html {
    scroll-padding-top: 70px;
 }
 body {
    padding-top: 70px;
 }
 p > img {
    max-width: 100%;
    height: auto;
 }
 ul.nav li.first-level {
    font-weight: bold;
 }
 ul.nav li.third-level {
    padding-left: 12px;
 }
 div.col-md-3 {
    padding-left: 0;
 }
 div.col-md-9 {
    padding-bottom: 100px;
 }
 div.source-links {
    float: right;
 }
 /*
 * Side navigation
 *
 * Scrollspy and affixed enhanced navigation to highlight sections and secondary
 * sections of docs content.
 */
 /* By default it's not affixed in mobile views, so undo that */
 .bs-sidebar.affix {
    position: static;
 }
 .bs-sidebar.well {
    padding: 0;
 }
 /* First level of nav */
 .bs-sidenav {
    margin-top: 30px;
    margin-bottom: 30px;
    padding-top:    10px;
    padding-bottom: 10px;
    border-radius: 5px;
 }
 /* All levels of nav */
 .bs-sidebar .nav > li > a {
    display: block;
    padding: 5px 20px;
    z-index: 1;
 }
 .bs-sidebar .nav > li > a:hover,
 .bs-sidebar .nav > li > a:focus {
    text-decoration: none;
    border-right: 1px solid;
 }
 .bs-sidebar .nav > .active > a,
 .bs-sidebar .nav > .active:hover > a,
 .bs-sidebar .nav > .active:focus > a {
    font-weight: bold;
    background-color: transparent;
    border-right: 1px solid;
 }
 /* Nav: second level (shown on .active) */
 .bs-sidebar .nav .nav {
    display: none; /* Hide by default, but at >768px, show it */
    margin-bottom: 8px;
 }
 .bs-sidebar .nav .nav > li > a {
    padding-top:    3px;
    padding-bottom: 3px;
    padding-left: 30px;
    font-size: 90%;
 }
 /* Show and affix the side nav when space allows it */
@media (min-width: 992px) {
    .bs-sidebar .nav > .active > ul {
        display: block;
    }
    /* Widen the fixed sidebar */
    .bs-sidebar.affix,
    .bs-sidebar.affix-bottom {
        width: 213px;
    }
    .bs-sidebar.affix {
        position: fixed; /* Undo the static from mobile first approach */
        top: 80px;
        max-height: calc(100% - 180px);
        overflow-y: auto;
    }
    .bs-sidebar.affix-bottom {
        position: absolute; /* Undo the static from mobile first approach */
    }
    .bs-sidebar.affix-bottom .bs-sidenav,
    .bs-sidebar.affix .bs-sidenav {
        margin-top: 0;
        margin-bottom: 0;
    }
 }
@media (min-width: 1200px) {
    /* Widen the fixed sidebar again */
    .bs-sidebar.affix-bottom,
    .bs-sidebar.affix {
        width: 263px;
    }
 }
 /* Added to support >2 level nav in drop down */
 .dropdown-submenu {
    position: relative;
 }
 .dropdown-submenu>.dropdown-menu {
    top: 0;
    left: 100%;
    margin-top: 0px;
    margin-left: 0px;
 }
 .dropdown-submenu:hover>.dropdown-menu {
    display: block;
 }
 .dropdown-submenu>a:after {
    display: block;
    content: " ";
    float: right;
    width: 0;
    height: 0;
    border-color: transparent;
    border-style: solid;
    border-width: 5px 0 5px 5px;
    border-left-color: #ccc;
    margin-top: 5px;
    margin-right: -10px;
 }
 .dropdown-submenu:hover>a:after {
    border-left-color: #fff;
 }
 .dropdown-submenu.pull-left {
    float: none;
 }
 .dropdown-submenu.pull-left>.dropdown-menu {
    left: -100%;
    margin-left: 00px;
 }
 /* Start Bootstrap Callouts CSS Source by Chris Pratt (https://codepen.io/chrisdpratt/pen/IAymB) MIT License*/
 .bs-callout {
    padding: 20px;
    margin: 20px 0;
    border: 1px solid #eee;
    border-left-width: 5px;
    border-radius: 3px;
    background-color: #FCFDFF;
 }
 .bs-callout h4 {
    font-style: normal;
    font-weight: 400;
    margin-top: 0;
    margin-bottom: 5px;
 }
 .bs-callout p:last-child {
    margin-bottom: 0;
 }
 .bs-callout code {
    border-radius: 3px;
 }
 .bs-callout+.bs-callout {
    margin-top: -5px;
 }
 .bs-callout-default {
    border-left-color: #FA023C; /*modified from upstream default by Christopher Simpkins*/
 }
 .bs-callout-default h4 {
    color: #FA023C; /*modified from upstream default by Christopher Simpkins*/
 }
 .bs-callout-primary {
    border-left-color: #428bca;
 }
 .bs-callout-primary h4 {
    color: #428bca;
 }
 .bs-callout-success {
    border-left-color: #5cb85c;
 }
 .bs-callout-success h4 {
    color: #5cb85c;
 }
 .bs-callout-danger {
    border-left-color: #d9534f;
 }
 .bs-callout-danger h4 {
    color: #d9534f;
 }
 .bs-callout-warning {
    border-left-color: #f0ad4e;
 }
 .bs-callout-warning h4 {
    color: #f0ad4e;
 }
 .bs-callout-info {
    border-left-color: #5bc0de;
 }
 .bs-callout-info h4 {
    color: #5bc0de;
 }
 /* End Bootstrap Callouts CSS Source by Chris Pratt */
 /* Headerlinks */
 .headerlink {
    display: none;
    padding-left: .5em;
 }
 h1:hover .headerlink, h2:hover .headerlink, h3:hover .headerlink, h4:hover .headerlink, h5:hover .headerlink, h6:hover .headerlink {
    display: inline-block;
 }
 /* Admonitions */
 .admonition {
    padding: 20px;
    margin: 20px 0;
    border: 1px solid #eee;
    border-left-width: 5px;
    border-radius: 3px;
    background-color: #FCFDFF;
 }
 .admonition p:last-child {
    margin-bottom: 0;
 }
 .admonition code {
    border-radius: 3px;
 }
 .admonition+.admonition {
    margin-top: -5px;
 }
 .admonition.note { /* csslint allow: adjoining-classes */
    border-left-color: #428bca;
 }
 .admonition.warning { /* csslint allow: adjoining-classes */
    border-left-color: #f0ad4e;
 }
 .admonition.danger { /* csslint allow: adjoining-classes */
    border-left-color: #d9534f;
 }
 .admonition-title {
    font-size: 19px;
    font-style: normal;
    font-weight: 400;
    margin-top: 0;
    margin-bottom: 5px;
 }
 .admonition.note > .admonition-title {
    color: #428bca;
 }
 .admonition.warning > .admonition-title {
    color: #f0ad4e;
 }
 .admonition.danger > .admonition-title {
    color: #d9534f;
 }
--- a/0.2/css/base.min.css
+++ b/0.2/css/base.min.css
@ -1 +0,0 @@
 html{scroll-padding-top:70px}body{padding-top:70px}p>img{max-width:100%;height:auto}ul.nav li.first-level{font-weight:bold}ul.nav li.third-level{padding-left:12px}div.col-md-3{padding-left:0}div.col-md-9{padding-bottom:100px}div.source-links{float:right}.bs-sidebar.affix{position:static}.bs-sidebar.well{padding:0}.bs-sidenav{margin-top:30px;margin-bottom:30px;padding-top:10px;padding-bottom:10px;border-radius:5px}.bs-sidebar .nav>li>a{display:block;padding:5px 20px;z-index:1}.bs-sidebar .nav>li>a:hover,.bs-sidebar .nav>li>a:focus{text-decoration:none;border-right:1px solid}.bs-sidebar .nav>.active>a,.bs-sidebar .nav>.active:hover>a,.bs-sidebar .nav>.active:focus>a{font-weight:bold;background-color:transparent;border-right:1px solid}.bs-sidebar .nav .nav{display:none;margin-bottom:8px}.bs-sidebar .nav .nav>li>a{padding-top:3px;padding-bottom:3px;padding-left:30px;font-size:90%}@media(min-width:992px){.bs-sidebar .nav>.active>ul{display:block}.bs-sidebar.affix,.bs-sidebar.affix-bottom{width:213px}.bs-sidebar.affix{position:fixed;top:80px;max-height:calc(100% - 180px);overflow-y:auto}.bs-sidebar.affix-bottom{position:absolute}.bs-sidebar.affix-bottom .bs-sidenav,.bs-sidebar.affix .bs-sidenav{margin-top:0;margin-bottom:0}}@media(min-width:1200px){.bs-sidebar.affix-bottom,.bs-sidebar.affix{width:263px}}.dropdown-submenu{position:relative}.dropdown-submenu>.dropdown-menu{top:0;left:100%;margin-top:0;margin-left:0}.dropdown-submenu:hover>.dropdown-menu{display:block}.dropdown-submenu>a:after{display:block;content:" ";float:right;width:0;height:0;border-color:transparent;border-style:solid;border-width:5px 0 5px 5px;border-left-color:#ccc;margin-top:5px;margin-right:-10px}.dropdown-submenu:hover>a:after{border-left-color:#fff}.dropdown-submenu.pull-left{float:none}.dropdown-submenu.pull-left>.dropdown-menu{left:-100%;margin-left:00px}.bs-callout{padding:20px;margin:20px 0;border:1px solid #eee;border-left-width:5px;border-radius:3px;background-color:#fcfdff}.bs-callout h4{font-style:normal;font-weight:400;margin-top:0;margin-bottom:5px}.bs-callout p:last-child{margin-bottom:0}.bs-callout code{border-radius:3px}.bs-callout+.bs-callout{margin-top:-5px}.bs-callout-default{border-left-color:#fa023c}.bs-callout-default h4{color:#fa023c}.bs-callout-primary{border-left-color:#428bca}.bs-callout-primary h4{color:#428bca}.bs-callout-success{border-left-color:#5cb85c}.bs-callout-success h4{color:#5cb85c}.bs-callout-danger{border-left-color:#d9534f}.bs-callout-danger h4{color:#d9534f}.bs-callout-warning{border-left-color:#f0ad4e}.bs-callout-warning h4{color:#f0ad4e}.bs-callout-info{border-left-color:#5bc0de}.bs-callout-info h4{color:#5bc0de}.headerlink{display:none;padding-left:.5em}h1:hover .headerlink,h2:hover .headerlink,h3:hover .headerlink,h4:hover .headerlink,h5:hover .headerlink,h6:hover .headerlink{display:inline-block}.admonition{padding:20px;margin:20px 0;border:1px solid #eee;border-left-width:5px;border-radius:3px;background-color:#fcfdff}.admonition p:last-child{margin-bottom:0}.admonition code{border-radius:3px}.admonition+.admonition{margin-top:-5px}.admonition.note{border-left-color:#428bca}.admonition.warning{border-left-color:#f0ad4e}.admonition.danger{border-left-color:#d9534f}.admonition-title{font-size:19px;font-style:normal;font-weight:400;margin-top:0;margin-bottom:5px}.admonition.note>.admonition-title{color:#428bca}.admonition.warning>.admonition-title{color:#f0ad4e}.admonition.danger>.admonition-title{color:#d9534f}
--- a/0.2/css/bootstrap-custom.css
+++ b/0.2/css/bootstrap-custom.css
--- a/0.2/css/bootstrap-custom.min.css
+++ b/0.2/css/bootstrap-custom.min.css
--- a/0.2/css/cinder.css
+++ b/0.2/css/cinder.css
@ -1,88 +0,0 @@
 /*
  Cinder Theme for MkDocs | Copyright 2015 Christopher Simpkins | MIT License
 */
 body {
    font-family:"Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
    font-size: 16px;
    line-height: 1.7;
    background-color: #FFF;
    color: #343838;
 }
 h1, h2, h3, h4, h5, h6 {
    font-family:'Inter', 'Helvetica Neue', Helvetica, Arial, sans-serif;
    color: #222;
 }
 h1 small, h2 small, h3 small, h4 small, h5 small, h6 small, .h1 small, .h2 small, .h3 small, .h4 small, .h5 small, .h6 small, h1 .small, h2 .small, h3 .small, h4 .small, h5 .small, h6 .small, .h1 .small, .h2 .small, .h3 .small, .h4 .small, .h5 .small, .h6 .small {
    color: #B1B7B9;
 }
 h2 {
    margin-top: 35px;
 }
 h1, h2 {
    font-weight: 700;
 }
 h4 {
    font-family: 'Inter', 'Helvetica Neue', Helvetica, Arial, sans-serif;
    font-weight: 300;
    margin-top: 20px;
    font-style: italic;
 }
 h5 {
    font-family: 'Inter', 'Helvetica Neue', Helvetica, Arial, sans-serif;
    font-weight: 300;
    font-variant: small-caps;
 }
 pre, code {
    background-color: #FCFDFF;
 }
 pre>code {
    font-size: 13px;
 }
 pre {
    margin-top: 25px;
    margin-bottom: 25px;
 }
 .lead {
    font-family:"Inter", "Helvetica Neue", Helvetica, Arial, sans-serif;
    font-weight: 400;
    line-height: 1.4;
    letter-spacing: 0.0312em;
    color: #B1B7B9;
 }
 .navbar-default {
    background-color: #343838;
    border-bottom: 8px #EBF2F2 solid;
 }
 .bs-sidenav {
    background-image: url("../img/grid11.png");
    background-repeat: repeat;
    font-family: Inter,"Helvetica Neue",Helvetica,Arial,sans-serif;
    font-size: 13px;
 }
 .well {
    background-color: #FCFDFF;
 }
 .btn-default {
    background-color:#FCFDFF;
 }
 .table-striped > tbody > tr:nth-child(2n+1) > td, .table-striped > tbody > tr:nth-child(2n+1) > th {
    background-color: #FCFDFF;
 }
 #mkdocs-search-query:focus {
    outline: none;
    -webkit-box-shadow: none;
    box-shadow: none;
 }
 #mkdocs-search-query {
    font-family:"Inter", "Helvetica Neue", Helvetica, Arial, sans-serif;
    font-size: 20px;
    font-weight: 700;
    color: #343838;
    height: 45px;
 }
 footer > hr {
    width: 35%;
 }
--- a/0.2/css/cinder.min.css
+++ b/0.2/css/cinder.min.css
@ -1 +0,0 @@
 body{font-family:"Open Sans","Helvetica Neue",Helvetica,Arial,sans-serif;font-size:16px;line-height:1.7;background-color:#FFF;color:#343838}h1,h2,h3,h4,h5,h6{font-family:'Inter','Helvetica Neue',Helvetica,Arial,sans-serif;color:#222}h1 small,h2 small,h3 small,h4 small,h5 small,h6 small,.h1 small,.h2 small,.h3 small,.h4 small,.h5 small,.h6 small,h1 .small,h2 .small,h3 .small,h4 .small,h5 .small,h6 .small,.h1 .small,.h2 .small,.h3 .small,.h4 .small,.h5 .small,.h6 .small{color:#b1b7b9}h2{margin-top:35px}h1,h2{font-weight:700}h4{font-family:'Inter','Helvetica Neue',Helvetica,Arial,sans-serif;font-weight:300;margin-top:20px;font-style:italic}h5{font-family:'Inter','Helvetica Neue',Helvetica,Arial,sans-serif;font-weight:300;font-variant:small-caps}pre,code{background-color:#fcfdff}pre>code{font-size:13px}pre{margin-top:25px;margin-bottom:25px}.lead{font-family:"Inter","Helvetica Neue",Helvetica,Arial,sans-serif;font-weight:400;line-height:1.4;letter-spacing:.0312em;color:#b1b7b9}.navbar-default{background-color:#343838;border-bottom:8px #ebf2f2 solid}.bs-sidenav{background-image:url("../img/grid11.png");background-repeat:repeat;font-family:Inter,"Helvetica Neue",Helvetica,Arial,sans-serif;font-size:13px}.well{background-color:#fcfdff}.btn-default{background-color:#fcfdff}.table-striped>tbody>tr:nth-child(2n+1)>td,.table-striped>tbody>tr:nth-child(2n+1)>th{background-color:#fcfdff}#mkdocs-search-query:focus{outline:0;-webkit-box-shadow:none;box-shadow:none}#mkdocs-search-query{font-family:"Inter","Helvetica Neue",Helvetica,Arial,sans-serif;font-size:20px;font-weight:700;color:#343838;height:45px}footer>hr{width:35%}
--- a/0.2/css/custom.css
+++ b/0.2/css/custom.css
@ -1,32 +0,0 @@
 .navbar-default {
  border-bottom: 0px;
  background-color: #fff;
  box-shadow: 0px 0px 15px rgba(0, 0, 0, 0.2);
 }
 a, .navbar-default a {
  color: #06a !important;
  font-weight: normal;
 }
 .disabled > a {
  color: #999 !important;
 }
 .navbar-default a:hover,
 .navbar-default a:focus {
  background-color: #f4f4f4 !important;
 }
 .navbar-default .active,
 .active > a {
  background-color: #f0f0f0 !important;
 }
 .icon-bar {
  background-color: #666 !important;
 }
 .navbar-collapse {
  border-color: #fff !important;
 }
--- a/0.2/css/highlight.css
+++ b/0.2/css/highlight.css
@ -1,99 +0,0 @@
 /*
 github.com style (c) Vasily Polovnyov <vast@whiteants.net>
 */
 .hljs {
  display: block;
  overflow-x: auto;
  padding: 0.5em;
  color: #333;
  background: #FCFDFF;
 }
 .hljs-comment,
 .hljs-quote {
  color: #998;
  font-style: italic;
 }
 .hljs-keyword,
 .hljs-selector-tag,
 .hljs-subst {
  color: #333;
  font-weight: bold;
 }
 .hljs-number,
 .hljs-literal,
 .hljs-variable,
 .hljs-template-variable,
 .hljs-tag .hljs-attr {
  color: #008080;
 }
 .hljs-string,
 .hljs-doctag {
  color: #d14;
 }
 .hljs-title,
 .hljs-section,
 .hljs-selector-id {
  color: #900;
  font-weight: bold;
 }
 .hljs-subst {
  font-weight: normal;
 }
 .hljs-type,
 .hljs-class .hljs-title {
  color: #458;
  font-weight: bold;
 }
 .hljs-tag,
 .hljs-name,
 .hljs-attribute {
  color: #000080;
  font-weight: normal;
 }
 .hljs-regexp,
 .hljs-link {
  color: #009926;
 }
 .hljs-symbol,
 .hljs-bullet {
  color: #990073;
 }
 .hljs-built_in,
 .hljs-builtin-name {
  color: #0086b3;
 }
 .hljs-meta {
  color: #999;
  font-weight: bold;
 }
 .hljs-deletion {
  background: #fdd;
 }
 .hljs-addition {
  background: #dfd;
 }
 .hljs-emphasis {
  font-style: italic;
 }
 .hljs-strong {
  font-weight: bold;
 }
--- a/0.2/css/highlight.min.css
+++ b/0.2/css/highlight.min.css
@ -1 +0,0 @@
 .hljs{display:block;overflow-x:auto;padding:.5em;color:#333;background:#fcfdff}.hljs-comment,.hljs-quote{color:#998;font-style:italic}.hljs-keyword,.hljs-selector-tag,.hljs-subst{color:#333;font-weight:bold}.hljs-number,.hljs-literal,.hljs-variable,.hljs-template-variable,.hljs-tag .hljs-attr{color:teal}.hljs-string,.hljs-doctag{color:#d14}.hljs-title,.hljs-section,.hljs-selector-id{color:#900;font-weight:bold}.hljs-subst{font-weight:normal}.hljs-type,.hljs-class .hljs-title{color:#458;font-weight:bold}.hljs-tag,.hljs-name,.hljs-attribute{color:navy;font-weight:normal}.hljs-regexp,.hljs-link{color:#009926}.hljs-symbol,.hljs-bullet{color:#990073}.hljs-built_in,.hljs-builtin-name{color:#0086b3}.hljs-meta{color:#999;font-weight:bold}.hljs-deletion{background:#fdd}.hljs-addition{background:#dfd}.hljs-emphasis{font-style:italic}.hljs-strong{font-weight:bold}
--- a/0.2/customization/index.html
+++ b/0.2/customization/index.html
@ -1,236 +1,343 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="shortcut icon" href="../img/favicon.ico">
    <title>Customization - MIPLearn</title>
    <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.12.0/css/all.css">
    <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.12.0/css/v4-shims.css">
    <link rel="stylesheet" href="//cdn.jsdelivr.net/npm/hack-font@3.3.0/build/web/hack.min.css">
    <link href='//rsms.me/inter/inter.css' rel='stylesheet' type='text/css'>
    <link href='//fonts.googleapis.com/css?family=Open+Sans:300italic,400italic,700italic,400,300,600,700&subset=latin-ext,latin' rel='stylesheet' type='text/css'>
    <link href="../css/bootstrap-custom.min.css" rel="stylesheet">
    <link href="../css/base.min.css" rel="stylesheet">
    <link href="../css/cinder.min.css" rel="stylesheet">
 <!DOCTYPE html>
-        <link rel="stylesheet" href="//cdn.jsdelivr.net/gh/highlightjs/cdn-release@9.18.0/build/styles/github.min.css">
+<html>
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>3. Customization &#8212; MIPLearn&lt;br/&gt;&lt;small&gt;0.2.0&lt;/small&gt;</title>
  <link href="../_static/css/theme.css" rel="stylesheet" />
  <link href="../_static/css/index.c5995385ac14fb8791e8eb36b4908be2.css" rel="stylesheet" />
  <link rel="stylesheet"
    href="../_static/vendor/fontawesome/5.13.0/css/all.min.css">
  <link rel="preload" as="font" type="font/woff2" crossorigin
    href="../_static/vendor/fontawesome/5.13.0/webfonts/fa-solid-900.woff2">
  <link rel="preload" as="font" type="font/woff2" crossorigin
    href="../_static/vendor/fontawesome/5.13.0/webfonts/fa-brands-400.woff2">
    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
    <link rel="stylesheet" href="../_static/sphinx-book-theme.acff12b8f9c144ce68a297486a2fa670.css" type="text/css" />
    <link rel="stylesheet" type="text/css" href="../_static/custom.css" />
  <link rel="preload" as="script" href="../_static/js/index.1c5a1a01449ed65a7b51.js">
    <script id="documentation_options" data-url_root="../" src="../_static/documentation_options.js"></script>
    <script src="../_static/jquery.js"></script>
    <script src="../_static/underscore.js"></script>
    <script src="../_static/doctools.js"></script>
    <script src="../_static/sphinx-book-theme.12a9622fbb08dcb3a2a40b2c02b83a57.js"></script>
    <script async="async" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/latest.js?config=TeX-AMS-MML_HTMLorMML"></script>
    <script type="text/x-mathjax-config">MathJax.Hub.Config({"tex2jax": {"inlineMath": [["\\(", "\\)"]], "displayMath": [["\\[", "\\]"]], "processRefs": false, "processEnvironments": false}})</script>
    <link rel="author" title="About these documents" href="../about/" />
    <link rel="index" title="Index" href="../genindex/" />
    <link rel="search" title="Search" href="../search/" />
    <link rel="next" title="4. About" href="../about/" />
    <link rel="prev" title="2. Benchmarks" href="../benchmark/" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <meta name="docsearch:language" content="en" />
  </head>
  <body data-spy="scroll" data-target="#bd-toc-nav" data-offset="80">
    <div class="container-fluid" id="banner"></div>
    <div class="container-xl">
      <div class="row">
 <div class="col-12 col-md-3 bd-sidebar site-navigation show" id="site-navigation">
        <div class="navbar-brand-box">
    <a class="navbar-brand text-wrap" href="../">
      <h1 class="site-logo" id="site-title">MIPLearn<br/><small>0.2.0</small></h1>
    </a>
 </div><form class="bd-search d-flex align-items-center" action="../search/" method="get">
  <i class="icon fas fa-search"></i>
  <input type="search" class="form-control" name="q" id="search-input" placeholder="Search the docs ..." aria-label="Search the docs ..." autocomplete="off" >
 </form><nav class="bd-links" id="bd-docs-nav" aria-label="Main navigation">
    <div class="bd-toc-item active">
        <ul class="current nav bd-sidenav">
 <li class="toctree-l1">
  <a class="reference internal" href="../usage/">
   <span class="sectnum">
    1.
   </span>
   Using MIPLearn
  </a>
 </li>
 <li class="toctree-l1">
  <a class="reference internal" href="../benchmark/">
   <span class="sectnum">
    2.
   </span>
   Benchmarks
  </a>
 </li>
 <li class="toctree-l1 current active">
  <a class="current reference internal" href="#">
   <span class="sectnum">
    3.
   </span>
   Customization
  </a>
 </li>
 <li class="toctree-l1">
  <a class="reference internal" href="../about/">
   <span class="sectnum">
    4.
   </span>
   About
  </a>
 </li>
 </ul>
    </div>
 </nav> <!-- To handle the deprecated key -->
-    <link href="../css/custom.css" rel="stylesheet">
+</div>
    <!-- HTML5 shim and Respond.js IE8 support of HTML5 elements and media queries -->
    <!--[if lt IE 9]>
            <script src="https://cdn.jsdelivr.net/npm/html5shiv@3.7.3/dist/html5shiv.min.js"></script>
            <script src="https://cdn.jsdelivr.net/npm/respond.js@1.4.2/dest/respond.min.js"></script>
        <![endif]-->
 </head>
-<body>
+<main class="col py-md-3 pl-md-4 bd-content overflow-auto" role="main">
-    <div class="navbar navbar-default navbar-fixed-top" role="navigation">
+    <div class="topbar container-xl fixed-top">
-    <div class="container">
+    <div class="topbar-contents row">
        <div class="col-12 col-md-3 bd-topbar-whitespace site-navigation show"></div>
        <div class="col pl-md-4 topbar-main">
-        <!-- Collapsed navigation -->
+            <button id="navbar-toggler" class="navbar-toggler ml-0" type="button" data-toggle="collapse"
-        <div class="navbar-header">
+                data-toggle="tooltip" data-placement="bottom" data-target=".site-navigation" aria-controls="navbar-menu"
-            <!-- Expander button -->
+                aria-expanded="true" aria-label="Toggle navigation" aria-controls="site-navigation"
-            <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
+                title="Toggle navigation" data-toggle="tooltip" data-placement="left">
-                <span class="sr-only">Toggle navigation</span>
+                <i class="fas fa-bars"></i>
-                <span class="icon-bar"></span>
+                <i class="fas fa-arrow-left"></i>
-                <span class="icon-bar"></span>
+                <i class="fas fa-arrow-up"></i>
                <span class="icon-bar"></span>
            </button>
-            <!-- Main title -->
+<div class="dropdown-buttons-trigger">
-
+    <button id="dropdown-buttons-trigger" class="btn btn-secondary topbarbtn" aria-label="Download this page"><i
-            
+            class="fas fa-download"></i></button>
              <a class="navbar-brand" href="..">MIPLearn</a>
        </div>
        <!-- Expanded navigation -->
        <div class="navbar-collapse collapse">
                <!-- Main navigation -->
                <ul class="nav navbar-nav">
-                    <li >
+    <div class="dropdown-buttons">
-                        <a href="..">Home</a>
+        <!-- ipynb file if we had a myst markdown file -->
                    </li>
                    <li >
                        <a href="../usage/">Usage</a>
                    </li>
                    <li >
                        <a href="../problems/">Problems</a>
                    </li>
        <!-- Download raw file -->
        <a class="dropdown-buttons" href="../_sources/customization.md.txt"><button type="button"
                class="btn btn-secondary topbarbtn" title="Download source file" data-toggle="tooltip"
                data-placement="left">.md</button></a>
        <!-- Download PDF via print -->
        <button type="button" id="download-print" class="btn btn-secondary topbarbtn" title="Print to PDF"
            onClick="window.print()" data-toggle="tooltip" data-placement="left">.pdf</button>
    </div>
 </div>
            <!-- Source interaction buttons -->
-                    <li class="active">
+<div class="dropdown-buttons-trigger">
-                        <a href="./">Customization</a>
+    <button id="dropdown-buttons-trigger" class="btn btn-secondary topbarbtn"
-                    </li>
+        aria-label="Connect with source repository"><i class="fab fa-github"></i></button>
    <div class="dropdown-buttons sourcebuttons">
        <a class="repository-button"
            href="https://github.com/ANL-CEEESA/MIPLearn/"><button type="button" class="btn btn-secondary topbarbtn"
                data-toggle="tooltip" data-placement="left" title="Source repository"><i
                    class="fab fa-github"></i>repository</button></a>
    </div>
 </div>
-                    <li >
+            <!-- Full screen (wrap in <a> to have style consistency -->
                        <a href="../about/">About</a>
                    </li>
 <a class="full-screen-button"><button type="button" class="btn btn-secondary topbarbtn" data-toggle="tooltip"
        data-placement="bottom" onclick="toggleFullScreen()" aria-label="Fullscreen mode"
        title="Fullscreen mode"><i
            class="fas fa-expand"></i></button></a>
            <!-- Launch buttons -->
-                    <li >
+        </div>
                        <a href="../api/miplearn/index.html">API</a>
                    </li>
        <!-- Table of contents -->
        <div class="d-none d-md-block col-md-2 bd-toc show">
-                </ul>
+            <div class="tocsection onthispage pt-5 pb-3">
                <i class="fas fa-list"></i> Contents
            </div>
            <nav id="bd-toc-nav">
                <ul class="visible nav section-nav flex-column">
 <li class="toc-h2 nav-item toc-entry">
  <a class="reference internal nav-link" href="#customizing-solver-parameters">
   <span class="sectnum">
    3.1.
   </span>
   Customizing solver parameters
  </a>
  <ul class="nav section-nav flex-column">
   <li class="toc-h3 nav-item toc-entry">
    <a class="reference internal nav-link" href="#selecting-the-internal-mip-solver">
     Selecting the internal MIP solver
    </a>
   </li>
  </ul>
 </li>
 <li class="toc-h2 nav-item toc-entry">
  <a class="reference internal nav-link" href="#customizing-solver-components">
   <span class="sectnum">
    3.2.
   </span>
   Customizing solver components
  </a>
  <ul class="nav section-nav flex-column">
   <li class="toc-h3 nav-item toc-entry">
    <a class="reference internal nav-link" href="#selecting-components">
     Selecting components
    </a>
   </li>
   <li class="toc-h3 nav-item toc-entry">
    <a class="reference internal nav-link" href="#adjusting-component-aggressiveness">
     Adjusting component aggressiveness
    </a>
   </li>
   <li class="toc-h3 nav-item toc-entry">
    <a class="reference internal nav-link" href="#evaluating-component-performance">
     Evaluating component performance
    </a>
   </li>
   <li class="toc-h3 nav-item toc-entry">
    <a class="reference internal nav-link" href="#using-customized-ml-classifiers-and-regressors">
     Using customized ML classifiers and regressors
    </a>
   </li>
  </ul>
 </li>
 </ul>
-            <ul class="nav navbar-nav navbar-right">
+            </nav>
                    <li>
                        <a href="#" data-toggle="modal" data-target="#mkdocs_search_modal">
                            <i class="fas fa-search"></i> Search
                        </a>
                    </li>
                    <li >
                        <a rel="prev" href="../problems/">
                            <i class="fas fa-arrow-left"></i> Previous
                        </a>
                    </li>
                    <li >
                        <a rel="next" href="../about/">
                            Next <i class="fas fa-arrow-right"></i>
                        </a>
                    </li>
                    <li>
                        <a href="https://github.com/ANL-CEEESA/MIPLearn/edit/dev/docs/customization.md"><i class="fab fa-github"></i> Edit on GitHub</a>
                    </li>
            </ul>
        </div>
    </div>
 </div>
-
+    <div id="main-content" class="row">
-    <div class="container">
+        <div class="col-12 col-md-9 pl-md-3 pr-md-0">
-        
+        
-        
+              <div>
-        <div class="col-md-3"><div class="bs-sidebar hidden-print affix well" role="complementary">
+                
-    <ul class="nav bs-sidenav">
+  <div class="section" id="customization">
-        <li class="first-level active"><a href="#customization">Customization</a></li>
+<h1><span class="sectnum">3.</span> Customization<a class="headerlink" href="#customization" title="Permalink to this headline">¶</a></h1>
-            <li class="second-level"><a href="#customizing-solver-parameters">Customizing solver parameters</a></li>
+<div class="section" id="customizing-solver-parameters">
-                
+<h2><span class="sectnum">3.1.</span> Customizing solver parameters<a class="headerlink" href="#customizing-solver-parameters" title="Permalink to this headline">¶</a></h2>
-                <li class="third-level"><a href="#selecting-the-internal-mip-solver">Selecting the internal MIP solver</a></li>
+<div class="section" id="selecting-the-internal-mip-solver">
-            <li class="second-level"><a href="#customizing-solver-components">Customizing solver components</a></li>
+<h3>Selecting the internal MIP solver<a class="headerlink" href="#selecting-the-internal-mip-solver" title="Permalink to this headline">¶</a></h3>
-                
+<p>By default, <code class="docutils literal notranslate"><span class="pre">LearningSolver</span></code> uses <a class="reference external" href="https://www.gurobi.com/">Gurobi</a> as its internal MIP solver, and expects models to be provided using the Pyomo modeling language. Supported solvers and modeling languages include:</p>
-                <li class="third-level"><a href="#selecting-components">Selecting components</a></li>
+<ul class="simple">
-                <li class="third-level"><a href="#adjusting-component-aggressiveness">Adjusting component aggressiveness</a></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">GurobiPyomoSolver</span></code>: Gurobi with Pyomo (default).</p></li>
-                <li class="third-level"><a href="#evaluating-component-performance">Evaluating component performance</a></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">CplexPyomoSolver</span></code>: <a class="reference external" href="https://www.ibm.com/products/ilog-cplex-optimization-studio">IBM ILOG CPLEX</a> with Pyomo.</p></li>
-                <li class="third-level"><a href="#using-customized-ml-classifiers-and-regressors">Using customized ML classifiers and regressors</a></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">XpressPyomoSolver</span></code>: <a class="reference external" href="https://www.fico.com/en/products/fico-xpress-solver">FICO XPRESS Solver</a> with Pyomo.</p></li>
-    </ul>
+<li><p><code class="docutils literal notranslate"><span class="pre">GurobiSolver</span></code>: Gurobi without any modeling language.</p></li>
 </div></div>
        <div class="col-md-9" role="main">
 <h1 id="customization">Customization</h1>
 <h2 id="customizing-solver-parameters">Customizing solver parameters</h2>
 <h3 id="selecting-the-internal-mip-solver">Selecting the internal MIP solver</h3>
 <p>By default, <code>LearningSolver</code> uses <a href="https://www.gurobi.com/">Gurobi</a> as its internal MIP solver, and expects models to be provided using the Pyomo modeling language. Supported solvers and modeling languages include:</p>
 <ul>
 <li><code>GurobiPyomoSolver</code>: Gurobi with Pyomo (default).</li>
 <li><code>CplexPyomoSolver</code>: <a href="https://www.ibm.com/products/ilog-cplex-optimization-studio">IBM ILOG CPLEX</a> with Pyomo.</li>
 <li><code>XpressPyomoSolver</code>: <a href="https://www.fico.com/en/products/fico-xpress-solver">FICO XPRESS Solver</a> with Pyomo.</li>
 <li><code>GurobiSolver</code>: Gurobi without any modeling language.</li>
 </ul>
-<p>To switch between solvers, provide the desired class using the <code>solver</code> argument:</p>
+<p>To switch between solvers, provide the desired class using the <code class="docutils literal notranslate"><span class="pre">solver</span></code> argument:</p>
-<pre><code class="language-python">from miplearn import LearningSolver, CplexPyomoSolver
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">miplearn</span> <span class="kn">import</span> <span class="n">LearningSolver</span><span class="p">,</span> <span class="n">CplexPyomoSolver</span>
-solver = LearningSolver(solver=CplexPyomoSolver)
+<span class="n">solver</span> <span class="o">=</span> <span class="n">LearningSolver</span><span class="p">(</span><span class="n">solver</span><span class="o">=</span><span class="n">CplexPyomoSolver</span><span class="p">)</span>
-</code></pre>
+</pre></div>
-<p>To configure a particular solver, use the <code>params</code> constructor argument, as shown below.</p>
+</div>
-<pre><code class="language-python">from miplearn import LearningSolver, GurobiPyomoSolver
+<p>To configure a particular solver, use the <code class="docutils literal notranslate"><span class="pre">params</span></code> constructor argument, as shown below.</p>
-solver = LearningSolver(
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">miplearn</span> <span class="kn">import</span> <span class="n">LearningSolver</span><span class="p">,</span> <span class="n">GurobiPyomoSolver</span>
-    solver=lambda: GurobiPyomoSolver(
+<span class="n">solver</span> <span class="o">=</span> <span class="n">LearningSolver</span><span class="p">(</span>
-        params={
+    <span class="n">solver</span><span class="o">=</span><span class="k">lambda</span><span class="p">:</span> <span class="n">GurobiPyomoSolver</span><span class="p">(</span>
-            &quot;TimeLimit&quot;: 900,
+        <span class="n">params</span><span class="o">=</span><span class="p">{</span>
-            &quot;MIPGap&quot;: 1e-3,
+            <span class="s2">&quot;TimeLimit&quot;</span><span class="p">:</span> <span class="mi">900</span><span class="p">,</span>
-            &quot;NodeLimit&quot;: 1000,
+            <span class="s2">&quot;MIPGap&quot;</span><span class="p">:</span> <span class="mf">1e-3</span><span class="p">,</span>
-        }
+            <span class="s2">&quot;NodeLimit&quot;</span><span class="p">:</span> <span class="mi">1000</span><span class="p">,</span>
-    ),
+        <span class="p">}</span>
-)
+    <span class="p">),</span>
-</code></pre>
+<span class="p">)</span>
-<h2 id="customizing-solver-components">Customizing solver components</h2>
+</pre></div>
-<p><code>LearningSolver</code> is composed by a number of individual machine-learning components, each targeting a different part of the solution process. Each component can be individually enabled, disabled or customized. The following components are enabled by default:</p>
+</div>
-<ul>
+</div>
-<li><code>LazyConstraintComponent</code>: Predicts which lazy constraint to initially enforce.</li>
+</div>
-<li><code>ObjectiveValueComponent</code>: Predicts the optimal value of the optimization problem, given the optimal solution to the LP relaxation.</li>
+<div class="section" id="customizing-solver-components">
-<li><code>PrimalSolutionComponent</code>: Predicts optimal values for binary decision variables. In heuristic mode, this component fixes the variables to their predicted values. In exact mode, the predicted values are provided to the solver as a (partial) MIP start.</li>
+<h2><span class="sectnum">3.2.</span> Customizing solver components<a class="headerlink" href="#customizing-solver-components" title="Permalink to this headline">¶</a></h2>
 <p><code class="docutils literal notranslate"><span class="pre">LearningSolver</span></code> is composed by a number of individual machine-learning components, each targeting a different part of the solution process. Each component can be individually enabled, disabled or customized. The following components are enabled by default:</p>
 <ul class="simple">
 <li><p><code class="docutils literal notranslate"><span class="pre">LazyConstraintComponent</span></code>: Predicts which lazy constraint to initially enforce.</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">ObjectiveValueComponent</span></code>: Predicts the optimal value of the optimization problem, given the optimal solution to the LP relaxation.</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">PrimalSolutionComponent</span></code>: Predicts optimal values for binary decision variables. In heuristic mode, this component fixes the variables to their predicted values. In exact mode, the predicted values are provided to the solver as a (partial) MIP start.</p></li>
 </ul>
 <p>The following components are also available, but not enabled by default:</p>
-<ul>
+<ul class="simple">
-<li><code>BranchPriorityComponent</code>: Predicts good branch priorities for decision variables.</li>
+<li><p><code class="docutils literal notranslate"><span class="pre">BranchPriorityComponent</span></code>: Predicts good branch priorities for decision variables.</p></li>
 </ul>
 <div class="section" id="selecting-components">
 <h3>Selecting components<a class="headerlink" href="#selecting-components" title="Permalink to this headline">¶</a></h3>
 <p>To create a <code class="docutils literal notranslate"><span class="pre">LearningSolver</span></code> with a specific set of components, the <code class="docutils literal notranslate"><span class="pre">components</span></code> constructor argument may be used, as the next example shows:</p>
 <div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># Create a solver without any components</span>
 <span class="n">solver1</span> <span class="o">=</span> <span class="n">LearningSolver</span><span class="p">(</span><span class="n">components</span><span class="o">=</span><span class="p">[])</span>
 <span class="c1"># Create a solver with only two components</span>
 <span class="n">solver2</span> <span class="o">=</span> <span class="n">LearningSolver</span><span class="p">(</span><span class="n">components</span><span class="o">=</span><span class="p">[</span>
    <span class="n">LazyConstraintComponent</span><span class="p">(</span><span class="o">...</span><span class="p">),</span>
    <span class="n">PrimalSolutionComponent</span><span class="p">(</span><span class="o">...</span><span class="p">),</span>
 <span class="p">])</span>
 </pre></div>
 </div>
 </div>
 <div class="section" id="adjusting-component-aggressiveness">
 <h3>Adjusting component aggressiveness<a class="headerlink" href="#adjusting-component-aggressiveness" title="Permalink to this headline">¶</a></h3>
 <p>The aggressiveness of classification components, such as <code class="docutils literal notranslate"><span class="pre">PrimalSolutionComponent</span></code> and <code class="docutils literal notranslate"><span class="pre">LazyConstraintComponent</span></code>, can be adjusted through the <code class="docutils literal notranslate"><span class="pre">threshold</span></code> constructor argument. Internally, these components ask the machine learning models how confident are they on each prediction they make, then automatically discard all predictions that have low confidence. The <code class="docutils literal notranslate"><span class="pre">threshold</span></code> argument specifies how confident should the ML models be for a prediction to be considered trustworthy. Lowering a component’s threshold increases its aggressiveness, while raising a component’s threshold makes it more conservative.</p>
 <p>For example, if the ML model predicts that a certain binary variable will assume value <code class="docutils literal notranslate"><span class="pre">1.0</span></code> in the optimal solution with 75% confidence, and if the <code class="docutils literal notranslate"><span class="pre">PrimalSolutionComponent</span></code> is configured to discard all predictions with less than 90% confidence, then this variable will not be included in the predicted MIP start.</p>
 <p>MIPLearn currently provides two types of thresholds:</p>
 <ul class="simple">
 <li><p><code class="docutils literal notranslate"><span class="pre">MinProbabilityThreshold(p:</span> <span class="pre">List[float])</span></code> A threshold which indicates that a prediction is trustworthy if its probability of being correct, as computed by the machine learning model, is above a fixed value.</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">MinPrecisionThreshold(p:</span> <span class="pre">List[float])</span></code> A dynamic threshold which automatically adjusts itself during training to ensure that the component achieves at least a given precision on the training data set. Note that increasing a component’s precision may reduce its recall.</p></li>
 </ul>
-<h3 id="selecting-components">Selecting components</h3>
+<p>The example below shows how to build a <code class="docutils literal notranslate"><span class="pre">PrimalSolutionComponent</span></code> which fixes variables to zero with at least 80% precision, and to one with at least 95% precision. Other components are configured similarly.</p>
-<p>To create a <code>LearningSolver</code> with a specific set of components, the <code>components</code> constructor argument may be used, as the next example shows:</p>
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">miplearn</span> <span class="kn">import</span> <span class="n">PrimalSolutionComponent</span><span class="p">,</span> <span class="n">MinPrecisionThreshold</span>
-<pre><code class="language-python"># Create a solver without any components
+
-solver1 = LearningSolver(components=[])
+<span class="n">PrimalSolutionComponent</span><span class="p">(</span>
-
+    <span class="n">mode</span><span class="o">=</span><span class="s2">&quot;heuristic&quot;</span><span class="p">,</span>
-# Create a solver with only two components
+    <span class="n">threshold</span><span class="o">=</span><span class="n">MinPrecisionThreshold</span><span class="p">([</span><span class="mf">0.80</span><span class="p">,</span> <span class="mf">0.95</span><span class="p">]),</span>
-solver2 = LearningSolver(components=[
+<span class="p">)</span>
-    LazyConstraintComponent(...),
+</pre></div>
-    PrimalSolutionComponent(...),
+</div>
-])
+</div>
-</code></pre>
+<div class="section" id="evaluating-component-performance">
-<h3 id="adjusting-component-aggressiveness">Adjusting component aggressiveness</h3>
+<h3>Evaluating component performance<a class="headerlink" href="#evaluating-component-performance" title="Permalink to this headline">¶</a></h3>
 <p>The aggressiveness of classification components (such as <code>PrimalSolutionComponent</code> and <code>LazyConstraintComponent</code>) can
 be adjusted through the <code>threshold</code> constructor argument. Internally, these components ask the ML models how confident
 they are on each prediction (through the <code>predict_proba</code> method in the sklearn API), and only take into account
 predictions which have probabilities above the threshold. Lowering a component's threshold increases its aggressiveness,
 while raising a component's threshold makes it more conservative. </p>
 <p>MIPLearn also includes <code>MinPrecisionThreshold</code>, a dynamic threshold which adjusts itself automatically during training
 to achieve a minimum desired true positive rate (also known as precision). The example below shows how to initialize
 a <code>PrimalSolutionComponent</code> which achieves 95% precision, possibly at the cost of a lower recall. To make the component
 more aggressive, this precision may be lowered.</p>
 <pre><code class="language-python">PrimalSolutionComponent(threshold=MinPrecisionThreshold(0.95))
 </code></pre>
 <h3 id="evaluating-component-performance">Evaluating component performance</h3>
 <p>MIPLearn allows solver components to be modified, trained and evaluated in isolation. In the following example, we build and
-fit <code>PrimalSolutionComponent</code> outside the solver, then evaluate its performance.</p>
+fit <code class="docutils literal notranslate"><span class="pre">PrimalSolutionComponent</span></code> outside the solver, then evaluate its performance.</p>
-<pre><code class="language-python">from miplearn import PrimalSolutionComponent
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">miplearn</span> <span class="kn">import</span> <span class="n">PrimalSolutionComponent</span>
-# User-provided set of previously-solved instances
+<span class="c1"># User-provided set of previously-solved instances</span>
-train_instances = [...]
+<span class="n">train_instances</span> <span class="o">=</span> <span class="p">[</span><span class="o">...</span><span class="p">]</span>
-# Construct and fit component on a subset of training instances
+<span class="c1"># Construct and fit component on a subset of training instances</span>
-comp = PrimalSolutionComponent()
+<span class="n">comp</span> <span class="o">=</span> <span class="n">PrimalSolutionComponent</span><span class="p">()</span>
-comp.fit(train_instances[:100])
+<span class="n">comp</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">train_instances</span><span class="p">[:</span><span class="mi">100</span><span class="p">])</span>
-# Evaluate performance on an additional set of training instances
+<span class="c1"># Evaluate performance on an additional set of training instances</span>
-ev = comp.evaluate(train_instances[100:150])
+<span class="n">ev</span> <span class="o">=</span> <span class="n">comp</span><span class="o">.</span><span class="n">evaluate</span><span class="p">(</span><span class="n">train_instances</span><span class="p">[</span><span class="mi">100</span><span class="p">:</span><span class="mi">150</span><span class="p">])</span>
-</code></pre>
+</pre></div>
-<p>The method <code>evaluate</code> returns a dictionary with performance evaluation statistics for each training instance provided,
+</div>
 <p>The method <code class="docutils literal notranslate"><span class="pre">evaluate</span></code> returns a dictionary with performance evaluation statistics for each training instance provided,
 and for each type of prediction the component makes. To obtain a summary across all instances, pandas may be used, as below:</p>
-<pre><code class="language-python">import pandas as pd
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">pandas</span> <span class="k">as</span> <span class="nn">pd</span>
-pd.DataFrame(ev[&quot;Fix one&quot;]).mean(axis=1)
+<span class="n">pd</span><span class="o">.</span><span class="n">DataFrame</span><span class="p">(</span><span class="n">ev</span><span class="p">[</span><span class="s2">&quot;Fix one&quot;</span><span class="p">])</span><span class="o">.</span><span class="n">mean</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
-</code></pre>
+</pre></div>
-<pre><code class="language-text">Predicted positive          3.120000
+</div>
 <div class="highlight-text notranslate"><div class="highlight"><pre><span></span>Predicted positive          3.120000
 Predicted negative        196.880000
 Condition positive         62.500000
 Condition negative        137.500000
@ -251,147 +358,77 @@ True negative (%)          68.720000
 False positive (%)          0.030000
 False negative (%)         29.720000
 dtype: float64
-</code></pre>
+</pre></div>
-<p>Regression components (such as <code>ObjectiveValueComponent</code>) can also be trained and evaluated similarly,
+</div>
 <p>Regression components (such as <code class="docutils literal notranslate"><span class="pre">ObjectiveValueComponent</span></code>) can also be trained and evaluated similarly,
 as the next example shows:</p>
-<pre><code class="language-python">from miplearn import ObjectiveValueComponent
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">miplearn</span> <span class="kn">import</span> <span class="n">ObjectiveValueComponent</span>
-comp = ObjectiveValueComponent()
+<span class="n">comp</span> <span class="o">=</span> <span class="n">ObjectiveValueComponent</span><span class="p">()</span>
-comp.fit(train_instances[:100])
+<span class="n">comp</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">train_instances</span><span class="p">[:</span><span class="mi">100</span><span class="p">])</span>
-ev = comp.evaluate(train_instances[100:150])
+<span class="n">ev</span> <span class="o">=</span> <span class="n">comp</span><span class="o">.</span><span class="n">evaluate</span><span class="p">(</span><span class="n">train_instances</span><span class="p">[</span><span class="mi">100</span><span class="p">:</span><span class="mi">150</span><span class="p">])</span>
-
+
-import pandas as pd
+<span class="kn">import</span> <span class="nn">pandas</span> <span class="k">as</span> <span class="nn">pd</span>
-pd.DataFrame(ev).mean(axis=1)
+<span class="n">pd</span><span class="o">.</span><span class="n">DataFrame</span><span class="p">(</span><span class="n">ev</span><span class="p">)</span><span class="o">.</span><span class="n">mean</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
-</code></pre>
+</pre></div>
-<pre><code class="language-text">Mean squared error       7001.977827
+</div>
 <div class="highlight-text notranslate"><div class="highlight"><pre><span></span>Mean squared error       7001.977827
 Explained variance          0.519790
 Max error                 242.375804
 Mean absolute error        65.843924
 R2                          0.517612
 Median absolute error      65.843924
 dtype: float64
-</code></pre>
+</pre></div>
-<h3 id="using-customized-ml-classifiers-and-regressors">Using customized ML classifiers and regressors</h3>
+</div>
-<p>By default, given a training set of instantes, MIPLearn trains a fixed set of ML classifiers and regressors, then
+</div>
-selects the best one based on cross-validation performance. Alternatively, the user may specify which ML model a component
+<div class="section" id="using-customized-ml-classifiers-and-regressors">
-should use through the <code>classifier</code> or <code>regressor</code> contructor parameters. The provided classifiers and regressors must 
+<h3>Using customized ML classifiers and regressors<a class="headerlink" href="#using-customized-ml-classifiers-and-regressors" title="Permalink to this headline">¶</a></h3>
-follow the sklearn API. In particular, classifiers must provide the methods <code>fit</code>, <code>predict_proba</code> and <code>predict</code>,
+<p>By default, given a training set of instantes, MIPLearn trains a fixed set of ML classifiers and regressors, then selects the best one based on cross-validation performance. Alternatively, the user may specify which ML model a component should use through the <code class="docutils literal notranslate"><span class="pre">classifier</span></code> or <code class="docutils literal notranslate"><span class="pre">regressor</span></code> contructor parameters. Scikit-learn classifiers and regressors are currently supported. A future version of the package will add compatibility with Keras models.</p>
-while regressors must provide the methods <code>fit</code> and <code>predict</code></p>
+<p>The example below shows how to construct a <code class="docutils literal notranslate"><span class="pre">PrimalSolutionComponent</span></code> which internally uses scikit-learn’s <code class="docutils literal notranslate"><span class="pre">KNeighborsClassifiers</span></code>. Any other scikit-learn classifier or pipeline can be used. It needs to be wrapped in <code class="docutils literal notranslate"><span class="pre">ScikitLearnClassifier</span></code> to ensure that all the proper data transformations are applied.</p>
-<div class="admonition danger">
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">miplearn</span> <span class="kn">import</span> <span class="n">PrimalSolutionComponent</span><span class="p">,</span> <span class="n">ScikitLearnClassifier</span>
-<p class="admonition-title">Danger</p>
+<span class="kn">from</span> <span class="nn">sklearn.neighbors</span> <span class="kn">import</span> <span class="n">KNeighborsClassifier</span>
-<p>MIPLearn must be able to generate a copy of any custom ML classifiers and regressors through 
+
-the standard  <code>copy.deepcopy</code> method. This currently makes it incompatible with Keras and TensorFlow
+<span class="n">comp</span> <span class="o">=</span> <span class="n">PrimalSolutionComponent</span><span class="p">(</span>
-predictors. This is a known limitation, which will be addressed in a future version.</p>
+    <span class="n">classifier</span><span class="o">=</span><span class="n">ScikitLearnClassifier</span><span class="p">(</span>
        <span class="n">KNeighborsClassifier</span><span class="p">(</span><span class="n">n_neighbors</span><span class="o">=</span><span class="mi">5</span><span class="p">),</span>
    <span class="p">),</span>
 <span class="p">)</span>
 <span class="n">comp</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">train_instances</span><span class="p">)</span>
 </pre></div>
 </div>
 </div>
 </div>
 </div>
 <p>The example below shows how to construct a <code>PrimalSolutionComponent</code> which internally uses
 sklearn's <code>KNeighborsClassifiers</code>. Any other sklearn classifier or pipeline can be used. </p>
 <pre><code class="language-python">from miplearn import PrimalSolutionComponent
 from sklearn.neighbors import KNeighborsClassifier
 comp = PrimalSolutionComponent(classifier=KNeighborsClassifier(n_neighbors=5))
 comp.fit(train_instances)
 </code></pre></div>
    </div>
      <footer class="col-md-12 text-center">
            <hr>
            <p>
            <small>Copyright © 2020, UChicago Argonne, LLC. All Rights Reserved.</small><br>
            <small>Documentation built with <a href="http://www.mkdocs.org/">MkDocs</a>.</small>
            </p>
              </div>
-      </footer>
+        <div class='prev-next-bottom'>
-    <script src="//ajax.googleapis.com/ajax/libs/jquery/1.12.4/jquery.min.js"></script>
+    <a class='left-prev' id="prev-link" href="../benchmark/" title="previous page"><span class="sectnum">2.</span> Benchmarks</a>
-    <script src="../js/bootstrap-3.0.3.min.js"></script>
+    <a class='right-next' id="next-link" href="../about/" title="next page"><span class="sectnum">4.</span> About</a>
        </div>
-    <script src="//cdn.jsdelivr.net/gh/highlightjs/cdn-release@9.18.0/build/highlight.min.js"></script>
+        </div>
    </div>
    <footer class="footer mt-5 mt-md-0">
    <div class="container">
      <p>
-    <script>hljs.initHighlightingOnLoad();</script>
+            &copy; Copyright 2020-2021, UChicago Argonne, LLC.<br/>
      </p>
    </div>
  </footer>
 </main>
-    <script>var base_url = ".."</script>
+      </div>
    </div>
-    <script src="../js/base.js"></script>
+  <script src="../_static/js/index.1c5a1a01449ed65a7b51.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
    <script src="../js/mathjax.js"></script>
    <script src="../search/main.js"></script>
    <div class="modal" id="mkdocs_search_modal" tabindex="-1" role="dialog" aria-labelledby="searchModalLabel" aria-hidden="true">
    <div class="modal-dialog modal-lg">
        <div class="modal-content">
            <div class="modal-header">
                <button type="button" class="close" data-dismiss="modal">
                    <span aria-hidden="true">&times;</span>
                    <span class="sr-only">Close</span>
                </button>
                <h4 class="modal-title" id="searchModalLabel">Search</h4>
            </div>
            <div class="modal-body">
                <p>
                    From here you can search these documents. Enter
                    your search terms below.
                </p>
                <form>
                    <div class="form-group">
                        <input type="text" class="form-control" placeholder="Search..." id="mkdocs-search-query" title="Type search term here">
                    </div>
                </form>
                <div id="mkdocs-search-results"></div>
            </div>
            <div class="modal-footer">
            </div>
        </div>
    </div>
 </div><div class="modal" id="mkdocs_keyboard_modal" tabindex="-1" role="dialog" aria-labelledby="keyboardModalLabel" aria-hidden="true">
    <div class="modal-dialog">
        <div class="modal-content">
            <div class="modal-header">
                <h4 class="modal-title" id="keyboardModalLabel">Keyboard Shortcuts</h4>
                <button type="button" class="close" data-dismiss="modal"><span aria-hidden="true">&times;</span><span class="sr-only">Close</span></button>
            </div>
            <div class="modal-body">
              <table class="table">
                <thead>
                  <tr>
                    <th style="width: 20%;">Keys</th>
                    <th>Action</th>
                  </tr>
                </thead>
                <tbody>
                  <tr>
                    <td class="help shortcut"><kbd>?</kbd></td>
                    <td>Open this help</td>
                  </tr>
                  <tr>
                    <td class="next shortcut"><kbd>n</kbd></td>
                    <td>Next page</td>
                  </tr>
                  <tr>
                    <td class="prev shortcut"><kbd>p</kbd></td>
                    <td>Previous page</td>
                  </tr>
                  <tr>
                    <td class="search shortcut"><kbd>s</kbd></td>
                    <td>Search</td>
                  </tr>
                </tbody>
              </table>
            </div>
            <div class="modal-footer">
            </div>
        </div>
    </div>
 </div>
    </body>
  </body>
 </html>
--- a/Show More
+++ b/Show More
		`@ -0,0 +1 @@`
							<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" width="38.73" height="50" viewBox="0 0 38.73 50"><defs><style>.cls-1{fill:#767677;}.cls-2{fill:#f37726;}.cls-3{fill:#9e9e9e;}.cls-4{fill:#616262;}.cls-5{font-size:17.07px;fill:#fff;font-family:Roboto-Regular, Roboto;}</style></defs><title>logo_jupyterhub</title><g id="Canvas"><path id="path7_fill" data-name="path7 fill" class="cls-1" d="M39.51,3.53a3,3,0,0,1-1.7,2.9A3,3,0,0,1,34.48,6a3,3,0,0,1-.82-3.26,3,3,0,0,1,1.05-1.41A3,3,0,0,1,37.52.86a2.88,2.88,0,0,1,1,.6,3,3,0,0,1,.7.93,3.18,3.18,0,0,1,.28,1.14Z" transform="translate(-1.87 -0.69)"/><path id="path8_fill" data-name="path8 fill" class="cls-2" d="M21.91,38.39c-8,0-15.06-2.87-18.7-7.12a19.93,19.93,0,0,0,37.39,0C37,35.52,30,38.39,21.91,38.39Z" transform="translate(-1.87 -0.69)"/><path id="path9_fill" data-name="path9 fill" class="cls-2" d="M21.91,10.78c8,0,15.05,2.87,18.69,7.12a19.93,19.93,0,0,0-37.39,0C6.85,13.64,13.86,10.78,21.91,10.78Z" transform="translate(-1.87 -0.69)"/><path id="path10_fill" data-name="path10 fill" class="cls-3" d="M10.88,46.66a3.86,3.86,0,0,1-.52,2.15,3.81,3.81,0,0,1-1.62,1.51,3.93,3.93,0,0,1-2.19.34,3.79,3.79,0,0,1-2-.94,3.73,3.73,0,0,1-1.14-1.9,3.79,3.79,0,0,1,.1-2.21,3.86,3.86,0,0,1,1.33-1.78,3.92,3.92,0,0,1,3.54-.53,3.85,3.85,0,0,1,2.14,1.93,3.74,3.74,0,0,1,.37,1.43Z" transform="translate(-1.87 -0.69)"/><path id="path11_fill" data-name="path11 fill" class="cls-4" d="M4.12,9.81A2.18,2.18,0,0,1,2.9,9.48a2.23,2.23,0,0,1-.84-1A2.26,2.26,0,0,1,1.9,7.26a2.13,2.13,0,0,1,.56-1.13,2.18,2.18,0,0,1,2.36-.56,2.13,2.13,0,0,1,1,.76,2.18,2.18,0,0,1,.42,1.2A2.22,2.22,0,0,1,4.12,9.81Z" transform="translate(-1.87 -0.69)"/></g><text class="cls-5" transform="translate(5.24 30.01)">Hub</text></svg>
		`@ -1 +0,0 @@`
			html{scroll-padding-top:70px}body{padding-top:70px}p>img{max-width:100%;height:auto}ul.nav li.first-level{font-weight:bold}ul.nav li.third-level{padding-left:12px}div.col-md-3{padding-left:0}div.col-md-9{padding-bottom:100px}div.source-links{float:right}.bs-sidebar.affix{position:static}.bs-sidebar.well{padding:0}.bs-sidenav{margin-top:30px;margin-bottom:30px;padding-top:10px;padding-bottom:10px;border-radius:5px}.bs-sidebar .nav>li>a{display:block;padding:5px 20px;z-index:1}.bs-sidebar .nav>li>a:hover,.bs-sidebar .nav>li>a:focus{text-decoration:none;border-right:1px solid}.bs-sidebar .nav>.active>a,.bs-sidebar .nav>.active:hover>a,.bs-sidebar .nav>.active:focus>a{font-weight:bold;background-color:transparent;border-right:1px solid}.bs-sidebar .nav .nav{display:none;margin-bottom:8px}.bs-sidebar .nav .nav>li>a{padding-top:3px;padding-bottom:3px;padding-left:30px;font-size:90%}@media(min-width:992px){.bs-sidebar .nav>.active>ul{display:block}.bs-sidebar.affix,.bs-sidebar.affix-bottom{width:213px}.bs-sidebar.affix{position:fixed;top:80px;max-height:calc(100% - 180px);overflow-y:auto}.bs-sidebar.affix-bottom{position:absolute}.bs-sidebar.affix-bottom .bs-sidenav,.bs-sidebar.affix .bs-sidenav{margin-top:0;margin-bottom:0}}@media(min-width:1200px){.bs-sidebar.affix-bottom,.bs-sidebar.affix{width:263px}}.dropdown-submenu{position:relative}.dropdown-submenu>.dropdown-menu{top:0;left:100%;margin-top:0;margin-left:0}.dropdown-submenu:hover>.dropdown-menu{display:block}.dropdown-submenu>a:after{display:block;content:" ";float:right;width:0;height:0;border-color:transparent;border-style:solid;border-width:5px 0 5px 5px;border-left-color:#ccc;margin-top:5px;margin-right:-10px}.dropdown-submenu:hover>a:after{border-left-color:#fff}.dropdown-submenu.pull-left{float:none}.dropdown-submenu.pull-left>.dropdown-menu{left:-100%;margin-left:00px}.bs-callout{padding:20px;margin:20px 0;border:1px solid #eee;border-left-width:5px;border-radius:3px;background-color:#fcfdff}.bs-callout h4{font-style:normal;font-weight:400;margin-top:0;margin-bottom:5px}.bs-callout p:last-child{margin-bottom:0}.bs-callout code{border-radius:3px}.bs-callout+.bs-callout{margin-top:-5px}.bs-callout-default{border-left-color:#fa023c}.bs-callout-default h4{color:#fa023c}.bs-callout-primary{border-left-color:#428bca}.bs-callout-primary h4{color:#428bca}.bs-callout-success{border-left-color:#5cb85c}.bs-callout-success h4{color:#5cb85c}.bs-callout-danger{border-left-color:#d9534f}.bs-callout-danger h4{color:#d9534f}.bs-callout-warning{border-left-color:#f0ad4e}.bs-callout-warning h4{color:#f0ad4e}.bs-callout-info{border-left-color:#5bc0de}.bs-callout-info h4{color:#5bc0de}.headerlink{display:none;padding-left:.5em}h1:hover .headerlink,h2:hover .headerlink,h3:hover .headerlink,h4:hover .headerlink,h5:hover .headerlink,h6:hover .headerlink{display:inline-block}.admonition{padding:20px;margin:20px 0;border:1px solid #eee;border-left-width:5px;border-radius:3px;background-color:#fcfdff}.admonition p:last-child{margin-bottom:0}.admonition code{border-radius:3px}.admonition+.admonition{margin-top:-5px}.admonition.note{border-left-color:#428bca}.admonition.warning{border-left-color:#f0ad4e}.admonition.danger{border-left-color:#d9534f}.admonition-title{font-size:19px;font-style:normal;font-weight:400;margin-top:0;margin-bottom:5px}.admonition.note>.admonition-title{color:#428bca}.admonition.warning>.admonition-title{color:#f0ad4e}.admonition.danger>.admonition-title{color:#d9534f}
		`@ -1 +0,0 @@`
			body{font-family:"Open Sans","Helvetica Neue",Helvetica,Arial,sans-serif;font-size:16px;line-height:1.7;background-color:#FFF;color:#343838}h1,h2,h3,h4,h5,h6{font-family:'Inter','Helvetica Neue',Helvetica,Arial,sans-serif;color:#222}h1 small,h2 small,h3 small,h4 small,h5 small,h6 small,.h1 small,.h2 small,.h3 small,.h4 small,.h5 small,.h6 small,h1 .small,h2 .small,h3 .small,h4 .small,h5 .small,h6 .small,.h1 .small,.h2 .small,.h3 .small,.h4 .small,.h5 .small,.h6 .small{color:#b1b7b9}h2{margin-top:35px}h1,h2{font-weight:700}h4{font-family:'Inter','Helvetica Neue',Helvetica,Arial,sans-serif;font-weight:300;margin-top:20px;font-style:italic}h5{font-family:'Inter','Helvetica Neue',Helvetica,Arial,sans-serif;font-weight:300;font-variant:small-caps}pre,code{background-color:#fcfdff}pre>code{font-size:13px}pre{margin-top:25px;margin-bottom:25px}.lead{font-family:"Inter","Helvetica Neue",Helvetica,Arial,sans-serif;font-weight:400;line-height:1.4;letter-spacing:.0312em;color:#b1b7b9}.navbar-default{background-color:#343838;border-bottom:8px #ebf2f2 solid}.bs-sidenav{background-image:url("../img/grid11.png");background-repeat:repeat;font-family:Inter,"Helvetica Neue",Helvetica,Arial,sans-serif;font-size:13px}.well{background-color:#fcfdff}.btn-default{background-color:#fcfdff}.table-striped>tbody>tr:nth-child(2n+1)>td,.table-striped>tbody>tr:nth-child(2n+1)>th{background-color:#fcfdff}#mkdocs-search-query:focus{outline:0;-webkit-box-shadow:none;box-shadow:none}#mkdocs-search-query{font-family:"Inter","Helvetica Neue",Helvetica,Arial,sans-serif;font-size:20px;font-weight:700;color:#343838;height:45px}footer>hr{width:35%}
		`@ -1 +0,0 @@`
			.hljs{display:block;overflow-x:auto;padding:.5em;color:#333;background:#fcfdff}.hljs-comment,.hljs-quote{color:#998;font-style:italic}.hljs-keyword,.hljs-selector-tag,.hljs-subst{color:#333;font-weight:bold}.hljs-number,.hljs-literal,.hljs-variable,.hljs-template-variable,.hljs-tag .hljs-attr{color:teal}.hljs-string,.hljs-doctag{color:#d14}.hljs-title,.hljs-section,.hljs-selector-id{color:#900;font-weight:bold}.hljs-subst{font-weight:normal}.hljs-type,.hljs-class .hljs-title{color:#458;font-weight:bold}.hljs-tag,.hljs-name,.hljs-attribute{color:navy;font-weight:normal}.hljs-regexp,.hljs-link{color:#009926}.hljs-symbol,.hljs-bullet{color:#990073}.hljs-built_in,.hljs-builtin-name{color:#0086b3}.hljs-meta{color:#999;font-weight:bold}.hljs-deletion{background:#fdd}.hljs-addition{background:#dfd}.hljs-emphasis{font-style:italic}.hljs-strong{font-weight:bold}