diff --git a/docs/_static/references.bib b/docs/_static/references.bib
index 71c4e12..92019ee 100644
--- a/docs/_static/references.bib
+++ b/docs/_static/references.bib
@@ -1,3 +1,33 @@
+@article{schutz1951MeasurementIncome,
+ title = {On the {{Measurement}} of {{Income Inequality}}},
+ author = {Schutz, Robert R.},
+ year = {1951},
+ journal = {The American Economic Review},
+ volume = {41},
+ number = {1},
+ eprint = {1815968},
+ eprinttype = {jstor},
+ pages = {107--122},
+ publisher = {American Economic Association},
+ issn = {0002-8282},
+ urldate = {2024-07-22},
+ file = {/home/serge/Zotero/storage/B54Q8IH7/Schutz - 1951 - On the Measurement of Income Inequality.pdf}
+}
+
+
+@Article{Atkinson_1970_Measurement,
+ title = {On the Measurement of Inequality},
+ author = {Atkinson, Anthony B},
+ year = {1970},
+ journal = {Journal of Economic Theory},
+ volume = {2},
+ number = {3},
+ pages = {244--263},
+ issn = {00220531},
+ doi = {10.1016/0022-0531(70)90039-6},
+ urldate = {2024-08-09},
+}
+
@article{care_2012,
author = {Care, David C. and Pinkerton, Ruth M. and Poot, Jacques and Coleman, Andrew},
title = {{Residential sorting across Auckland neighbourhoods}},
diff --git a/docs/api.rst b/docs/api.rst
index f863a0c..0f40c12 100644
--- a/docs/api.rst
+++ b/docs/api.rst
@@ -7,17 +7,15 @@ API reference
.. _inequality_api:
-Theil Inequality Measures
--------------------------
+
+Atkinson Inequality Measures
+----------------------------
.. autosummary::
:toctree: generated/
- inequality.theil.Theil
- inequality.theil.TheilD
- inequality.theil.TheilDSim
-
-
+ inequality.atkinson.Atkinson
+
Gini Inequality Measures
------------------------
@@ -27,6 +25,26 @@ Gini Inequality Measures
inequality.gini.Gini
inequality.gini.Gini_Spatial
+Schutz Inequality Measures
+--------------------------
+
+.. autosummary::
+ :toctree: generated/
+
+ inequality.schutz.Schutz
+
+
+Theil Inequality Measures
+-------------------------
+
+.. autosummary::
+ :toctree: generated/
+
+ inequality.theil.Theil
+ inequality.theil.TheilD
+ inequality.theil.TheilDSim
+
+
Pengram
-------
diff --git a/inequality/__init__.py b/inequality/__init__.py
index 4bafd1e..806fe5f 100644
--- a/inequality/__init__.py
+++ b/inequality/__init__.py
@@ -7,7 +7,7 @@
import contextlib
from importlib.metadata import PackageNotFoundError, version
-from . import gini, theil
+from . import atkinson, gini, schutz, theil
from ._indices import (
abundance,
ellison_glaeser_egg,
diff --git a/inequality/atkinson.py b/inequality/atkinson.py
new file mode 100644
index 0000000..37230d0
--- /dev/null
+++ b/inequality/atkinson.py
@@ -0,0 +1,112 @@
+import numpy as np
+
+__all__ = ["Atkinson", "atkinson"]
+
+
+def atkinson(y, epsilon):
+ """Compute the Atkinson index for a given distribution of income or wealth.
+
+ The Atkinson index is a measure of economic inequality that takes
+ into account the social aversion to inequality. It is sensitive to
+ changes in different parts of the income distribution depending on
+ the value of the parameter epsilon.
+
+ Parameters
+ ----------
+ y : array-like
+ An array of income or wealth values.
+ epsilon : float
+ The inequality aversion parameter. Higher values of epsilon
+ give more weight to the lower end of the distribution, making
+ the index more sensitive to changes in the lower tail.
+
+ Returns
+ -------
+ float
+ The Atkinson index, which ranges from 0 (perfect equality) to
+ 1 (maximum inequality).
+
+ Notes
+ -----
+ - If epsilon equals 0, the Atkinson index is 0 regardless of the
+ distribution, as it implies no aversion to inequality.
+ - If epsilon equals 1, the Atkinson index is calculated using the
+ geometric mean.
+ - The input array y should contain positive values for a
+ meaningful calculation.
+
+ Example
+ -------
+ >>> import numpy as np
+ >>> incomes = np.array([10, 20, 30, 40, 50])
+ >>> float(round(atkinson(incomes, 0.5), 5))
+ 0.06315
+ >>> float(round(atkinson(incomes, 1),5))
+ 0.13161
+
+ """
+ y = np.asarray(y)
+ if epsilon == 1:
+ geom_mean = np.exp(np.mean(np.log(y)))
+ return 1 - geom_mean / y.mean()
+ else:
+ ye = y ** (1 - epsilon)
+ ye_bar = ye.mean()
+ ye_bar = ye_bar ** (1 / (1 - epsilon))
+ return 1 - ye_bar / y.mean()
+
+
+class Atkinson:
+ """A class to calculate and store the Atkinson index and the equally
+ distributed equivalent(EDE).
+
+ The Atkinson index is a measure of economic inequality that takes
+ into account the social aversion to inequality. The equally
+ distributed equivalent (EDE) represents the level of income that,
+ if equally distributed, would give the same level of social
+ welfare as the actual distribution.
+
+ See: cite: `Atkinson_1970_Measurement`.
+
+ Parameters
+ ----------
+ y: array-like
+ An array of income or wealth values.
+ epsilon: float
+ The inequality aversion parameter. Higher values of epsilon
+ give more weight to the lower end of the distribution, making
+ the index more sensitive to changes in the lower tail.
+
+ Attributes
+ ----------
+ y: array-like
+ The input array of income or wealth values.
+ epsilon: float
+ The inequality aversion parameter.
+ A: float
+ The calculated Atkinson index.
+ EDE: float
+ The equally distributed equivalent(EDE) of the income or
+ wealth distribution.
+
+ Example
+ -------
+ >> > incomes = np.array([10, 20, 30, 40, 50])
+ >> > atkinson = Atkinson(incomes, 0.5)
+ >> > float(round(atkinson.A, 5))
+ 0.06315
+ >> > float(round(atkinson.EDE, 5))
+ 28.1054
+ >> > atkinson = Atkinson(incomes, 1)
+ >> > float(round(atkinson.A, 5))
+ 0.13161
+ >> > float(round(atkinson.EDE, 5))
+ 26.05171
+
+ """
+
+ def __init__(self, y, epsilon):
+ self.y = np.asarray(y)
+ self.epsilon = epsilon
+ self.A = atkinson(y, epsilon)
+ self.EDE = y.mean() * (1 - self.A)
diff --git a/inequality/schutz.py b/inequality/schutz.py
new file mode 100644
index 0000000..7288b71
--- /dev/null
+++ b/inequality/schutz.py
@@ -0,0 +1,197 @@
+import matplotlib.pyplot as plt
+
+__all__ = ["Schutz"]
+
+
+class Schutz:
+ """The Schutz class calculates measures of inequality in an income
+ distribution.
+
+ It calculates the Schutz distance, which is the maximum distance
+ between the line of perfect equality and the Lorenz curve.
+ Additionally, it computes the intersection point with the line of
+ perfect equality where the Schutz distance occurs and the original
+ Schutz coefficient.
+ See :cite:`schutz1951MeasurementIncome`.
+
+ Parameters
+ ----------
+ df : pd.DataFrame
+ The input DataFrame containing the data.
+ column_name : str
+ The name of the column for which the Schutz coefficient is to
+ be calculated.
+
+ Attributes
+ ----------
+ df : pd.DataFrame
+ The input DataFrame containing the data.
+ column_name : str
+ The name of the column for which the Schutz coefficient is to
+ be calculated.
+ df_processed : pd.DataFrame
+ The processed DataFrame with additional columns.
+ distance : float
+ The maximum distance between the line of perfect equality and
+ the Lorenz curve.
+ intersection_point : float
+ The x and y coordinate of the intersection point where the
+ Schutz distance occurs.
+ coefficient : float
+ The original Schutz coefficient.
+
+ Examples
+ --------
+ >>> import pandas as pd
+ >>> gdf = pd.DataFrame({
+ ... 'NAME': ['A', 'B', 'C', 'D', 'E'],
+ ... 'Y': [1000, 2000, 1500, 3000, 2500]
+ ... })
+ >>> schutz_obj = Schutz(gdf, 'Y')
+ >>> print("Schutz Distance:", round(float(schutz_obj.distance),2))
+ Schutz Distance: 0.15
+ >>> print("Intersection Point:", round(schutz_obj.intersection_point, 1))
+ Intersection Point: 0.6
+ >>> print("Schutz Coefficient:", round(schutz_obj.coefficient, 1))
+ Schutz Coefficient: 7.5
+ """
+
+ def __init__(self, df, column_name):
+ """
+ Initialize the Schutz object, calculate the Schutz distance,
+ the intersection point with the line of perfect equality, and
+ the original Schutz coefficient.
+
+ Parameters
+ ----------
+ df: pd.DataFrame
+ The input DataFrame containing the data.
+ column_name: str
+ The name of the column for which the Schutz coefficient is
+ to be calculated.
+ """
+ self.df = df
+ self.column_name = column_name
+ self.df_processed = self._prepare_dataframe()
+ self.distance = self.calculate_schutz_distance()
+ self.intersection_point = self.calculate_intersection_point()
+ self.coefficient = self.calculate_schutz_coefficient()
+
+ def _prepare_dataframe(self):
+ """
+ Prepare the DataFrame by sorting and calculating necessary
+ columns.
+
+ Returns
+ -------
+ pd.DataFrame
+ The processed DataFrame with additional columns.
+ """
+ df = (
+ self.df[[self.column_name]]
+ .sort_values(by=self.column_name)
+ .reset_index(drop=True)
+ )
+ df["unit"] = 1
+ df["upct"] = df.unit / df.unit.sum()
+ df["ypct"] = df[self.column_name] / df[self.column_name].sum()
+ df["ucpct"] = df.upct.cumsum()
+ df["ycpct"] = df.ypct.cumsum()
+ df["distance"] = df["ucpct"] - df["ycpct"]
+ df["slope"] = df.ypct / df.upct
+ df["coefficient"] = 10 * (df.slope - 1)
+ return df
+
+ def calculate_schutz_distance(self):
+ """
+ Calculate the Schutz distance, which is the maximum distance
+ between the line of perfect equality and the Lorenz curve.
+
+ Returns
+ -------
+ float
+ The maximum distance indicating the level of inequality.
+ """
+ return self.df_processed["distance"].max()
+
+ def calculate_intersection_point(self):
+ """
+ Calculate the intersection point of the line of perfect equality
+ and the Lorenz curve.
+
+ Returns
+ -------
+ float
+ The x and y coordinate of the intersection point where the
+ Schutz distance occurs.
+ """
+ max_distance_row = self.df_processed[
+ self.df_processed["distance"] == self.distance
+ ].iloc[0]
+ intersection_point = max_distance_row["ucpct"]
+ return intersection_point
+
+ def calculate_schutz_coefficient(self):
+ """
+ Calculate the original Schutz coefficient.
+
+ Returns
+ -------
+ float
+ The Schutz coefficient.
+ """
+ coefficient = self.df_processed[
+ self.df_processed["coefficient"] > 0
+ ].coefficient.sum()
+ return coefficient
+
+ def plot(
+ self,
+ xlabel="Cumulative Share of the Population",
+ ylabel="Cumulative Share of Income",
+ grid=True,
+ ):
+ """
+ Plot the Lorenz curve, the line of perfect equality, and the
+ Schutz line.
+
+ The plot shows the Lorenz curve, a 45-degree line representing
+ perfect equality, and the Schutz line dropping vertically from
+ the intersection point on the line of perfect equality to the
+ Lorenz curve.
+ """
+ plt.figure(figsize=(10, 6))
+
+ # Plot Lorenz curve
+ plt.plot(
+ [0] + self.df_processed["ucpct"].tolist(),
+ [0] + self.df_processed["ycpct"].tolist(),
+ label="Lorenz Curve",
+ color="blue",
+ )
+
+ # Plot 45-degree line of perfect equality
+ plt.plot(
+ [0, 1],
+ [0, 1],
+ label="Line of Perfect Equality",
+ color="black",
+ linestyle="--",
+ )
+
+ # Plot Schutz line
+ plt.plot(
+ [self.intersection_point, self.intersection_point],
+ [self.intersection_point, self.intersection_point - self.distance],
+ label="Schutz Line",
+ color="red",
+ linestyle=":",
+ )
+
+ # Add labels and title
+ plt.xlabel(xlabel)
+ plt.ylabel(ylabel)
+ plt.title("Lorenz Curve with Line of Perfect Equality and Schutz Line")
+ plt.legend()
+ plt.grid(grid)
+ plt.show()
diff --git a/inequality/tests/test_atkinson.py b/inequality/tests/test_atkinson.py
new file mode 100644
index 0000000..b5d8b5c
--- /dev/null
+++ b/inequality/tests/test_atkinson.py
@@ -0,0 +1,67 @@
+import numpy as np
+import pytest
+from inequality.atkinson import Atkinson, atkinson
+
+
+def testatkinson_function():
+ # Test case for epsilon = 0.5
+ incomes = np.array([10, 20, 30, 40, 50])
+ result = atkinson(incomes, 0.5)
+ expected = 0.06315
+ assert np.isclose(
+ result, expected, atol=1e-5
+ ), f"Expected {expected}, but got {result}"
+
+ # Test case for epsilon = 1
+ result = atkinson(incomes, 1)
+ expected = 0.1316096
+ assert np.isclose(
+ result, expected, atol=1e-5
+ ), f"Expected {expected}, but got {result}"
+
+ # Test case for epsilon = 0
+ result = atkinson(incomes, 0)
+ expected = 0
+ assert np.isclose(
+ result, expected, atol=1e-5
+ ), f"Expected {expected}, but got {result}"
+
+
+def testatkinson_class():
+ # Test case for epsilon = 0.5
+ incomes = np.array([10, 20, 30, 40, 50])
+ atkinson = Atkinson(incomes, 0.5)
+ expected_A = 0.06315
+ expected_EDE = 28.105398233
+ assert np.isclose(
+ atkinson.A, expected_A, atol=1e-5
+ ), f"Expected Atkinson index {expected_A}, but got {atkinson.A}"
+ assert np.isclose(
+ atkinson.EDE, expected_EDE, atol=1e-5
+ ), f"Expected EDE {expected_EDE}, but got {atkinson.EDE}"
+
+ # Test case for epsilon = 1
+ atkinson = Atkinson(incomes, 1)
+ expected_A = 0.1316096
+ expected_EDE = 26.0517108
+ assert np.isclose(
+ atkinson.A, expected_A, atol=1e-5
+ ), f"Expected Atkinson index {expected_A}, but got {atkinson.A}"
+ assert np.isclose(
+ atkinson.EDE, expected_EDE, atol=1e-5
+ ), f"Expected EDE {expected_EDE}, but got {atkinson.EDE}"
+
+ # Test case for epsilon = 0
+ atkinson = Atkinson(incomes, 0)
+ expected_A = 0
+ expected_EDE = incomes.mean()
+ assert np.isclose(
+ atkinson.A, expected_A, atol=1e-5
+ ), f"Expected Atkinson index {expected_A}, but got {atkinson.A}"
+ assert np.isclose(
+ atkinson.EDE, expected_EDE, atol=1e-5
+ ), f"Expected EDE {expected_EDE}, but got {atkinson.EDE}"
+
+
+if __name__ == "__main__":
+ pytest.main()
diff --git a/inequality/tests/test_pengram.py b/inequality/tests/test_pengram.py
index be53039..db91332 100644
--- a/inequality/tests/test_pengram.py
+++ b/inequality/tests/test_pengram.py
@@ -1,9 +1,14 @@
import geopandas as gpd
+import matplotlib
import matplotlib.pyplot as plt
import pandas as pd
import pytest
-
from inequality.pen import _check_deps, pen, pengram
+from shapely.geometry import Polygon
+
+# Set the backend to 'Agg' to prevent GUI windows from opening
+matplotlib.use("Agg")
+
# Test Data Setup
@@ -23,9 +28,6 @@ def sample_df():
def sample_gdf():
"""Sample GeoDataFrame for testing the pengram function."""
data = {"region": ["A", "B", "C", "D"], "income": [50000, 60000, 70000, 80000]}
- # Random polygons for simplicity
- from shapely.geometry import Polygon
-
polygons = [
Polygon([(0, 0), (1, 0), (1, 1), (0, 1)]),
Polygon([(1, 0), (2, 0), (2, 1), (1, 1)]),
@@ -60,6 +62,8 @@ def test_pen_basic(sample_df):
assert isinstance(ax, plt.Axes)
assert ax.get_ylabel() == "income"
assert ax.get_xlabel() == "region"
+ assert len(ax.patches) == len(sample_df), "All regions should be plotted."
+ plt.close(ax.figure) # Close the figure to free up resources
def test_pen_weighted(sample_df):
@@ -69,6 +73,16 @@ def test_pen_weighted(sample_df):
assert isinstance(ax, plt.Axes)
assert ax.get_ylabel() == "income"
assert ax.get_xlabel() == "region"
+ plt.close(ax.figure) # Close the figure to free up resources
+
+
+@pytest.mark.parametrize("weight_col", ["population", None])
+def test_pen_parametrized(sample_df, weight_col):
+ """Test pen function with and without weighting using parameterization."""
+ ax = pen(sample_df, col="income", x="region", weight=weight_col)
+ assert ax is not None
+ assert isinstance(ax, plt.Axes)
+ plt.close(ax.figure) # Close the figure to free up resources
# Test pengram function
@@ -81,6 +95,8 @@ def test_pengram_basic(sample_gdf):
assert inset_ax is not None
assert isinstance(ax, plt.Axes)
assert isinstance(inset_ax, plt.Axes)
+ plt.close(ax.figure) # Close the main figure to free up resources
+ plt.close(inset_ax.figure) # Close the inset figure to free up resources
def test_pengram_custom_inset_size(sample_gdf):
@@ -90,6 +106,8 @@ def test_pengram_custom_inset_size(sample_gdf):
assert inset_ax is not None
assert isinstance(ax, plt.Axes)
assert isinstance(inset_ax, plt.Axes)
+ plt.close(ax.figure) # Close the main figure to free up resources
+ plt.close(inset_ax.figure) # Close the inset figure to free up resources
# Test invalid cases
@@ -97,11 +115,11 @@ def test_pengram_custom_inset_size(sample_gdf):
def test_invalid_weight_column(sample_df):
"""Test pen function with an invalid weight column."""
- with pytest.raises(KeyError):
+ with pytest.raises(KeyError, match="invalid_column"):
pen(sample_df, col="income", x="region", weight="invalid_column")
def test_invalid_query_column(sample_gdf):
"""Test pengram function with an invalid query column."""
- with pytest.raises(KeyError):
+ with pytest.raises(KeyError, match="invalid_column"):
pengram(sample_gdf, col="income", name="invalid_column", query=["A", "C"])
diff --git a/inequality/tests/test_schutz.py b/inequality/tests/test_schutz.py
new file mode 100644
index 0000000..1a90d1e
--- /dev/null
+++ b/inequality/tests/test_schutz.py
@@ -0,0 +1,56 @@
+import os
+
+import matplotlib.pyplot as plt
+import pandas as pd
+import pytest
+from inequality.schutz import Schutz
+
+
+@pytest.fixture
+def example_dataframe():
+ data = {"NAME": ["A", "B", "C", "D", "E"], "Y": [1000, 2000, 1500, 3000, 2500]}
+ return pd.DataFrame(data)
+
+
+def test_schutz_distance(example_dataframe):
+ schutz_obj = Schutz(example_dataframe, "Y")
+ expected_distance = 0.15
+ assert pytest.approx(schutz_obj.distance, 0.01) == expected_distance
+
+
+def test_schutz_intersection_point(example_dataframe):
+ schutz_obj = Schutz(example_dataframe, "Y")
+ expected_intersection_point = 0.6
+ assert (
+ pytest.approx(schutz_obj.intersection_point, 0.1) == expected_intersection_point
+ )
+
+
+def test_schutz_coefficient(example_dataframe):
+ schutz_obj = Schutz(example_dataframe, "Y")
+ expected_coefficient = 7.5
+ assert pytest.approx(schutz_obj.coefficient, 0.1) == expected_coefficient
+
+
+def test_schutz_plot_runs_without_errors(example_dataframe):
+ schutz_obj = Schutz(example_dataframe, "Y")
+ try:
+ schutz_obj.plot()
+ except Exception as e:
+ pytest.fail(f"Plotting failed: {e}")
+
+
+def test_schutz_plot_output(example_dataframe, tmpdir):
+ """Test if the plot output matches the expected result by saving
+ the plot and comparing it."""
+ schutz_obj = Schutz(example_dataframe, "Y")
+
+ # Save the plot to a temporary directory
+ plot_file = os.path.join(tmpdir, "schutz_plot.png")
+ plt.figure()
+ schutz_obj.plot()
+ plt.savefig(plot_file)
+ plt.close()
+
+ # Ensure that the plot file was created
+ assert os.path.exists(plot_file), "Plot file was not created."
diff --git a/notebooks/shutz.ipynb b/notebooks/shutz.ipynb
new file mode 100644
index 0000000..62735bc
--- /dev/null
+++ b/notebooks/shutz.ipynb
@@ -0,0 +1,600 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "cfa03ecf-6e5d-4cb7-8060-048cd4e1ca6c",
+ "metadata": {},
+ "source": [
+ "## Schutz Measures of Inequality\n",
+ "\n",
+ "The Schutz class calculates measures of inequality in an income distribution.\n",
+ "\n",
+ "It calculates the Schutz distance, which is the maximum distance between the line of perfect equality and the Lorenz curve. Additionally, it computes the intersection point with the line of perfect equality where the Schutz distance occurs and the original Schutz coefficient. \n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "id": "b5841f7c-a8bd-4ecb-bb34-10d51aa36fef",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from inequality.schutz import Schutz"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "id": "471d3791-e3c5-47bc-92fa-9dd5b3e5c2a5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "id": "7879bc81-3d53-40f6-8108-ee2fbc07529e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import pandas as pd"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "id": "9f32cb7a-2210-4a50-bc5c-9cd1bbbd9ee7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "df = pd.DataFrame(data=np.array([1000, 2000, 1500, 3000, 2500]), columns=['GDP'])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "id": "f52b60af-f136-46d9-8fb9-91ccdb7b1601",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "s = Schutz(df, 'GDP')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "id": "8b72184b-86c8-4bed-b946-70d2e472a1cc",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "np.float64(0.15000000000000008)"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "s.distance"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "id": "acd62bd1-5830-4b2b-ba22-f9dc9381d9c4",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "np.float64(0.6000000000000001)"
+ ]
+ },
+ "execution_count": 25,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "s.intersection_point"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "id": "2d4bdf0a-72c7-4eda-83aa-8b82eb8e3706",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " GDP | \n",
+ " unit | \n",
+ " upct | \n",
+ " ypct | \n",
+ " ucpct | \n",
+ " ycpct | \n",
+ " distance | \n",
+ " slope | \n",
+ " coefficient | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 1000 | \n",
+ " 1 | \n",
+ " 0.2 | \n",
+ " 0.10 | \n",
+ " 0.2 | \n",
+ " 0.10 | \n",
+ " 0.10 | \n",
+ " 0.50 | \n",
+ " -5.0 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 1500 | \n",
+ " 1 | \n",
+ " 0.2 | \n",
+ " 0.15 | \n",
+ " 0.4 | \n",
+ " 0.25 | \n",
+ " 0.15 | \n",
+ " 0.75 | \n",
+ " -2.5 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 2000 | \n",
+ " 1 | \n",
+ " 0.2 | \n",
+ " 0.20 | \n",
+ " 0.6 | \n",
+ " 0.45 | \n",
+ " 0.15 | \n",
+ " 1.00 | \n",
+ " 0.0 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " 2500 | \n",
+ " 1 | \n",
+ " 0.2 | \n",
+ " 0.25 | \n",
+ " 0.8 | \n",
+ " 0.70 | \n",
+ " 0.10 | \n",
+ " 1.25 | \n",
+ " 2.5 | \n",
+ "
\n",
+ " \n",
+ " | 4 | \n",
+ " 3000 | \n",
+ " 1 | \n",
+ " 0.2 | \n",
+ " 0.30 | \n",
+ " 1.0 | \n",
+ " 1.00 | \n",
+ " 0.00 | \n",
+ " 1.50 | \n",
+ " 5.0 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "s.plot()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "156b5de7-88b7-4bf8-9fd4-237cb1e72f90",
+ "metadata": {},
+ "source": [
+ "### Increase the inequality"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "id": "a2ab7983-d0c6-45eb-a393-45464b6d8a7a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "y = np.array([20,50,80,100,100,100,100,120, 150,180])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "id": "c2fa9119-df17-4dbb-b6de-71c486355ced",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "df = pd.DataFrame(data=y, columns=['GDP'])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "id": "f4cd0cf8-3458-4a05-87a8-6a387d0f05c4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "s = Schutz(df, 'GDP')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "id": "8fdc3fb5-f926-46a2-ae79-15f2b82dd192",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "np.float64(14.999999999999996)"
+ ]
+ },
+ "execution_count": 32,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "s.coefficient"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "id": "0a77128b-2b2c-41ab-b479-2cc30339e3d4",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " GDP | \n",
+ " unit | \n",
+ " upct | \n",
+ " ypct | \n",
+ " ucpct | \n",
+ " ycpct | \n",
+ " distance | \n",
+ " slope | \n",
+ " coefficient | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 20 | \n",
+ " 1 | \n",
+ " 0.1 | \n",
+ " 0.02 | \n",
+ " 0.1 | \n",
+ " 0.02 | \n",
+ " 8.000000e-02 | \n",
+ " 0.2 | \n",
+ " -8.0 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 50 | \n",
+ " 1 | \n",
+ " 0.1 | \n",
+ " 0.05 | \n",
+ " 0.2 | \n",
+ " 0.07 | \n",
+ " 1.300000e-01 | \n",
+ " 0.5 | \n",
+ " -5.0 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 80 | \n",
+ " 1 | \n",
+ " 0.1 | \n",
+ " 0.08 | \n",
+ " 0.3 | \n",
+ " 0.15 | \n",
+ " 1.500000e-01 | \n",
+ " 0.8 | \n",
+ " -2.0 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " 100 | \n",
+ " 1 | \n",
+ " 0.1 | \n",
+ " 0.10 | \n",
+ " 0.4 | \n",
+ " 0.25 | \n",
+ " 1.500000e-01 | \n",
+ " 1.0 | \n",
+ " 0.0 | \n",
+ "
\n",
+ " \n",
+ " | 4 | \n",
+ " 100 | \n",
+ " 1 | \n",
+ " 0.1 | \n",
+ " 0.10 | \n",
+ " 0.5 | \n",
+ " 0.35 | \n",
+ " 1.500000e-01 | \n",
+ " 1.0 | \n",
+ " 0.0 | \n",
+ "
\n",
+ " \n",
+ " | 5 | \n",
+ " 100 | \n",
+ " 1 | \n",
+ " 0.1 | \n",
+ " 0.10 | \n",
+ " 0.6 | \n",
+ " 0.45 | \n",
+ " 1.500000e-01 | \n",
+ " 1.0 | \n",
+ " 0.0 | \n",
+ "
\n",
+ " \n",
+ " | 6 | \n",
+ " 100 | \n",
+ " 1 | \n",
+ " 0.1 | \n",
+ " 0.10 | \n",
+ " 0.7 | \n",
+ " 0.55 | \n",
+ " 1.500000e-01 | \n",
+ " 1.0 | \n",
+ " 0.0 | \n",
+ "
\n",
+ " \n",
+ " | 7 | \n",
+ " 120 | \n",
+ " 1 | \n",
+ " 0.1 | \n",
+ " 0.12 | \n",
+ " 0.8 | \n",
+ " 0.67 | \n",
+ " 1.300000e-01 | \n",
+ " 1.2 | \n",
+ " 2.0 | \n",
+ "
\n",
+ " \n",
+ " | 8 | \n",
+ " 150 | \n",
+ " 1 | \n",
+ " 0.1 | \n",
+ " 0.15 | \n",
+ " 0.9 | \n",
+ " 0.82 | \n",
+ " 8.000000e-02 | \n",
+ " 1.5 | \n",
+ " 5.0 | \n",
+ "
\n",
+ " \n",
+ " | 9 | \n",
+ " 180 | \n",
+ " 1 | \n",
+ " 0.1 | \n",
+ " 0.18 | \n",
+ " 1.0 | \n",
+ " 1.00 | \n",
+ " -1.110223e-16 | \n",
+ " 1.8 | \n",
+ " 8.0 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "