Metadata-Version: 2.1
Name: paretoset
Version: 1.0.0
Summary: Compute the Pareto (non-dominated) set, i.e., skyline operator/query.
Home-page: https://github.com/tommyod/paretoset
Author: tommyod
Author-email: tommy.odland@gmail.com
License: MIT
Description: # paretoset [![Build Status](https://travis-ci.com/tommyod/paretoset.svg?branch=master)](https://travis-ci.com/tommyod/paretoset) [![PyPI version](https://badge.fury.io/py/paretoset.svg)](https://pypi.org/project/paretoset/)[![Downloads](https://pepy.tech/badge/paretoset)](https://pepy.tech/project/paretoset) [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
        
        paretoset operator/query for computing the Pareto (non-dominated) frontier.
        
        There are two common ways to optimize a function of several variables: 
        
        - **Scalarization** combines the variables using a weighted sum: this gives a linear ordering and *single a minimum value*.
        - **paretoset query** returns the Pareto (non-dominated) frontier: his gives a partial ordering and *a set of minimal values*.
        
        The disadvantage of scalarization is that objectives must be weighted beforehand.
        The paretoset query returns every value that could be obtained by scalarization, but also values that could not have been found by scalarization.
        
        ## Examples - paretoset queries for data analysis and insight
        
        The folllowing example is from the paper "*The paretoset Operator*" by Börzsönyi et al.
        
        Suppose you are going on holiday and you are looking for a hotel that is cheap and close to the beach. 
        These two goals are complementary as the hotels near the beach tend to be more expensive. 
        
        >The database system at your travel agents' is unable to decide which hotel is best for you, but it can at least present you all interesting hotels. 
        Interesting are all hotels that are not worse than any other hotel in both dimensions. 
        We call this set of interesting hotels the *paretoset*. 
        From the paretoset, you can now your final decision, thereby weighing your personal preferences for price and distance to the beach.
        
        ```python
        from paretoset import paretoset
        import pandas as pd
        
        hotels = pd.DataFrame({"price": [50, 53, 62, 87, 83, 39, 60, 44], 
                               "distance_to_beach": [13, 21, 19, 13, 5, 22, 22, 25]})
        mask = paretoset(hotels, sense=["min", "min"])
        paretoset_hotels = hotels[mask]
        ```
        
        ![](scripts/example_hotels.png)
        
        Suppose you wish to query a database for salespeople that might be eligible for a raise.
        To find top performers (low salary, but high sales) for every department:
        
        ```python
        from paretoset import paretoset
        import pandas as pd
        
        salespeople = pd.DataFrame(
            {
                "salary": [94, 107, 67, 87, 153, 62, 43, 115, 78, 77, 119, 127],
                "sales": [123, 72, 80, 40, 64, 104, 106, 135, 61, 81, 162, 60],
                "department": ["c", "c", "c", "b", "b", "a", "a", "c", "b", "a", "b", "a"],
            }
        )
        mask = paretoset(salespeople, sense=["min", "max", "diff"])
        top_performers = salespeople[mask]
        ```
        
        ![](scripts/example_salespeople.png)
        
        ## Examples - Pareto efficient solutions (non-dominated front) in multiobjective optimization
        
        Suppose you wish to query a database for salespeople that might be eligible for a raise.
        To find top performers (low salary, but high sales) for every department:
        
        ```python
        from paretoset import paretoset
        import numpy as np
        from collections import namedtuple
        
        np.random.seed(42)
        
        # Create Solution objects holding the problem solution and objective values
        Solution = namedtuple("Solution", ["solution", "objective_values"])
        solutions = [Solution(solution=object, objective_values=np.random.randn(2)) for _ in range(999)]
        
        # Create an array of shape (solutions, objectives) and compute the non-dominated set
        objective_values_array = np.vstack([s.objective_values for s in solutions])
        mask = paretoset(objective_values_array, sense=[min, min])
        
        # Filter the list of solutions, keeping only the non-dominated solutions
        efficient_solutions = [solution for (solution, m) in zip(solutions, mask) if m]
        ```
        
        ![](scripts/example_optimization.png)
        
        ## Installation
        
        The software is available through GitHub, and through [PyPI](https://pypi.org/project/paretoset/).
        You may install the software using `pip`.
        
        ```bash
        pip install paretoset
        ```
        
        ## Contributing
        
        You are very welcome to scrutinize the code and make pull requests if you have suggestions and improvements.
        Your submitted code must be PEP8 compliant, and all tests must pass.
        
        ## Performance
        
        
Platform: UNKNOWN
Classifier: Development Status :: 3 - Alpha
Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Description-Content-Type: text/markdown
