From 7108b22b4633bacad63f7dae4ee599bf57b63ec4 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Tue, 23 Jul 2024 11:34:55 -0700 Subject: [PATCH 01/18] ENH: Atkinson inequality index --- inequality/__init__.py | 2 +- inequality/atkinson.py | 117 ++++++++++++++++++++++++++++++ inequality/tests/test_atkinson.py | 68 +++++++++++++++++ 3 files changed, 186 insertions(+), 1 deletion(-) create mode 100644 inequality/atkinson.py create mode 100644 inequality/tests/test_atkinson.py diff --git a/inequality/__init__.py b/inequality/__init__.py index 4bafd1e..2bcd940 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 gini, theil, atkinson from ._indices import ( abundance, ellison_glaeser_egg, diff --git a/inequality/atkinson.py b/inequality/atkinson.py new file mode 100644 index 0000000..69b505a --- /dev/null +++ b/inequality/atkinson.py @@ -0,0 +1,117 @@ +import numpy as np + +__all__ = ["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]) + >>> _atkinson(incomes, 0.5) + 0.06315339222708616 + >>> _atkinson(incomes, 1) + 0.1316096384342157 + """ + 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. + + 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) + >>> atkinson.A + 0.06315339222708616 + >>> atkinson.EDE + 28.105398233187415 + >>> atkinson = Atkinson(incomes, 1) + >>> atkinson.A + 0.1316096384342157 + >>> atkinson.EDE + 26.051710846973528 + """ + + 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) + +# Example usage +if __name__ == "__main__": + incomes = np.array([10, 20, 30, 40, 50]) + + # Using the _atkinson function + print(f"_atkinson(incomes, 0.5): {_atkinson(incomes, 0.5)}") # Output: 0.06315339222708616 + print(f"_atkinson(incomes, 1): {_atkinson(incomes, 1)}") # Output: 0.1316096384342157 + + # Using the Atkinson class + atkinson = Atkinson(incomes, 0.5) + print(f"Atkinson index (epsilon=0.5): {atkinson.A}") # Output: 0.06315339222708616 + print(f"EDE (epsilon=0.5): {atkinson.EDE}") # Output: 28.105398233187415 + + atkinson = Atkinson(incomes, 1) + print(f"Atkinson index (epsilon=1): {atkinson.A}") # Output: 0.1316096384342157 + print(f"EDE (epsilon=1): {atkinson.EDE}") # Output: 26.051710846973528 diff --git a/inequality/tests/test_atkinson.py b/inequality/tests/test_atkinson.py new file mode 100644 index 0000000..659e515 --- /dev/null +++ b/inequality/tests/test_atkinson.py @@ -0,0 +1,68 @@ +import numpy as np +import pytest + +from inequality.atkinson import Atkinson, _atkinson + + +def test_atkinson_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 test_atkinson_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() From 00ad4388a816ce45aae35d5f34341489cbb899f6 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Wed, 24 Jul 2024 09:03:29 -0700 Subject: [PATCH 02/18] ENH: Schutz index and plot --- inequality/__init__.py | 2 +- inequality/schutz.py | 178 ++++++++++++++++++++++++++++++++ inequality/tests/test_schutz.py | 25 +++++ 3 files changed, 204 insertions(+), 1 deletion(-) create mode 100644 inequality/schutz.py create mode 100644 inequality/tests/test_schutz.py diff --git a/inequality/__init__.py b/inequality/__init__.py index 2bcd940..fff2d5c 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, atkinson +from . import gini, theil, atkinson, schutz from ._indices import ( abundance, ellison_glaeser_egg, diff --git a/inequality/schutz.py b/inequality/schutz.py new file mode 100644 index 0000000..35227e1 --- /dev/null +++ b/inequality/schutz.py @@ -0,0 +1,178 @@ +import matplotlib.pyplot as plt +import pandas as pd + +__all__ = ["Schutz"] + + +class Schutz: + """ + The Schutz class calculates measures of inequality based on the given 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. + + 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:", schutz_obj.distance) + Schutz Distance: 0.15 + >>> print("Intersection Point (x=y):", schutz_obj.intersection_point) + Intersection Point (x=y): 0.6 + >>> print("Schutz Coefficient:", schutz_obj.coefficient) + Schutz Coefficient: 15 + """ + + 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): + """ + 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("Cumulative Share of Population") + plt.ylabel("Cumulative Share of Income") + plt.title("Lorenz Curve with Line of Perfect Equality and Schutz Line") + plt.legend() + plt.grid(True) + plt.show() diff --git a/inequality/tests/test_schutz.py b/inequality/tests/test_schutz.py new file mode 100644 index 0000000..25a00e8 --- /dev/null +++ b/inequality/tests/test_schutz.py @@ -0,0 +1,25 @@ +import pandas as pd +import pytest +import numpy as np +from inequality.schutz import Schutz # Replace 'your_module' with the actual name of the module where Schutz is defined + +def test_schutz(): + # Sample DataFrame + data = np.array([20, 50, 80, 100, 100, 100, 100, 120, 150, 180]) + gdf = pd.DataFrame({'NAME': range(len(data)), 'Y': data}) + + # Create Schutz object + schutz_obj = Schutz(gdf, 'Y') + + # Assert the Schutz distance + assert schutz_obj.distance == pytest.approx(0.15, rel=1e-9) + + # Assert the intersection point (x=y) + assert schutz_obj.intersection_point == pytest.approx(0.3, rel=1e-9) + + # Assert the Schutz coefficient + assert schutz_obj.coefficient == pytest.approx(15, rel=1e-9) + +if __name__ == '__main__': + pytest.main() + From cb7fee02409794ee52575f749d987ef361be46b5 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Wed, 24 Jul 2024 13:32:46 -0700 Subject: [PATCH 03/18] ENH: options for labels and grid in schutz plot --- inequality/schutz.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/inequality/schutz.py b/inequality/schutz.py index 35227e1..846fd73 100644 --- a/inequality/schutz.py +++ b/inequality/schutz.py @@ -137,7 +137,8 @@ def calculate_schutz_coefficient(self): return coefficient - def plot(self): + 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. @@ -170,9 +171,9 @@ def plot(self): ) # Add labels and title - plt.xlabel("Cumulative Share of Population") - plt.ylabel("Cumulative Share of Income") + plt.xlabel(xlabel) + plt.ylabel(ylabel) plt.title("Lorenz Curve with Line of Perfect Equality and Schutz Line") plt.legend() - plt.grid(True) + plt.grid(grid) plt.show() From 5a9906187af16029399c404b4861e3d0d49a32da Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Tue, 20 Aug 2024 11:52:01 -0700 Subject: [PATCH 04/18] ENH: Atkinson measures and reference --- docs/_static/references.bib | 13 ++++++++++ docs/api.rst | 22 +++++++++++------ inequality/__init__.py | 35 +++++++------------------- inequality/atkinson.py | 49 +++++++++++++++++++++++-------------- 4 files changed, 67 insertions(+), 52 deletions(-) diff --git a/docs/_static/references.bib b/docs/_static/references.bib index 71c4e12..c9d287f 100644 --- a/docs/_static/references.bib +++ b/docs/_static/references.bib @@ -1,3 +1,16 @@ +@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..2a18a9c 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -7,17 +7,14 @@ 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 +24,17 @@ Gini Inequality Measures inequality.gini.Gini inequality.gini.Gini_Spatial +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 2bcd940..f8bd27b 100644 --- a/inequality/__init__.py +++ b/inequality/__init__.py @@ -7,32 +7,15 @@ import contextlib from importlib.metadata import PackageNotFoundError, version -from . import gini, theil, atkinson -from ._indices import ( - abundance, - ellison_glaeser_egg, - ellison_glaeser_egg_pop, - fractionalization_gs, - gini_gi, - gini_gi_m, - gini_gig, - herfindahl_hd, - hoover_hi, - isolation_ii, - isolation_isg, - margalev_md, - maurel_sedillot_msg, - maurel_sedillot_msg_pop, - menhinick_mi, - modified_segregation_msg, - polarization, - segregation_gsg, - shannon_se, - similarity_w_wd, - simpson_sd, - simpson_so, - theil_th, -) +from . import atkinson, gini, theil +from ._indices import (abundance, ellison_glaeser_egg, ellison_glaeser_egg_pop, + fractionalization_gs, gini_gi, gini_gi_m, gini_gig, + herfindahl_hd, hoover_hi, isolation_ii, isolation_isg, + margalev_md, maurel_sedillot_msg, + maurel_sedillot_msg_pop, menhinick_mi, + modified_segregation_msg, polarization, segregation_gsg, + shannon_se, similarity_w_wd, simpson_sd, simpson_so, + theil_th) with contextlib.suppress(PackageNotFoundError): __version__ = version("inequality") diff --git a/inequality/atkinson.py b/inequality/atkinson.py index 69b505a..8329d93 100644 --- a/inequality/atkinson.py +++ b/inequality/atkinson.py @@ -2,6 +2,7 @@ __all__ = ["Atkinson"] + def _atkinson(y, epsilon): """ Compute the Atkinson index for a given distribution of income or wealth. @@ -35,10 +36,10 @@ def _atkinson(y, epsilon): ------- >>> import numpy as np >>> incomes = np.array([10, 20, 30, 40, 50]) - >>> _atkinson(incomes, 0.5) - 0.06315339222708616 - >>> _atkinson(incomes, 1) - 0.1316096384342157 + >>> float(round(_atkinson(incomes, 0.5), 5)) + 0.06315 + >>> float(round(_atkinson(incomes, 1),5)) + 0.13161 """ y = np.asarray(y) if epsilon == 1: @@ -50,6 +51,7 @@ def _atkinson(y, epsilon): 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). @@ -58,6 +60,8 @@ class Atkinson: 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 @@ -82,36 +86,43 @@ class Atkinson: ------- >>> incomes = np.array([10, 20, 30, 40, 50]) >>> atkinson = Atkinson(incomes, 0.5) - >>> atkinson.A - 0.06315339222708616 - >>> atkinson.EDE - 28.105398233187415 + >>> float(round(atkinson.A, 5)) + 0.06315 + >>> float(round(atkinson.EDE, 5)) + 28.1054 >>> atkinson = Atkinson(incomes, 1) - >>> atkinson.A - 0.1316096384342157 - >>> atkinson.EDE - 26.051710846973528 + >>> 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) + # Example usage if __name__ == "__main__": incomes = np.array([10, 20, 30, 40, 50]) # Using the _atkinson function - print(f"_atkinson(incomes, 0.5): {_atkinson(incomes, 0.5)}") # Output: 0.06315339222708616 - print(f"_atkinson(incomes, 1): {_atkinson(incomes, 1)}") # Output: 0.1316096384342157 + # Output: 0.06315339222708616 + print(f"_atkinson(incomes, 0.5): {_atkinson(incomes, 0.5)}") + # Output: 0.1316096384342157 + print(f"_atkinson(incomes, 1): {_atkinson(incomes, 1)}") # Using the Atkinson class atkinson = Atkinson(incomes, 0.5) - print(f"Atkinson index (epsilon=0.5): {atkinson.A}") # Output: 0.06315339222708616 - print(f"EDE (epsilon=0.5): {atkinson.EDE}") # Output: 28.105398233187415 + # Output: 0.06315339222708616 + print(f"Atkinson index (epsilon=0.5): {atkinson.A}") + # Output: 28.105398233187415 + print(f"EDE (epsilon=0.5): {atkinson.EDE}") atkinson = Atkinson(incomes, 1) - print(f"Atkinson index (epsilon=1): {atkinson.A}") # Output: 0.1316096384342157 - print(f"EDE (epsilon=1): {atkinson.EDE}") # Output: 26.051710846973528 + # Output: 0.1316096384342157 + print(f"Atkinson index (epsilon=1): {atkinson.A}") + # Output: 26.051710846973528 + print(f"EDE (epsilon=1): {atkinson.EDE}") From e11d797371b4255725293abe12370cc4294c6fb7 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Wed, 21 Aug 2024 14:28:58 -0700 Subject: [PATCH 05/18] ENH: Schutz inequality measures --- docs/_static/references.bib | 17 + docs/api.rst | 28 +- inequality/schutz.py | 84 +++-- notebooks/shutz.ipynb | 600 ++++++++++++++++++++++++++++++++++++ 4 files changed, 687 insertions(+), 42 deletions(-) create mode 100644 notebooks/shutz.ipynb diff --git a/docs/_static/references.bib b/docs/_static/references.bib index 71c4e12..db60650 100644 --- a/docs/_static/references.bib +++ b/docs/_static/references.bib @@ -1,3 +1,20 @@ +@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{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..f020890 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -7,25 +7,35 @@ API reference .. _inequality_api: -Theil Inequality Measures -------------------------- + +Gini Inequality Measures +------------------------ .. autosummary:: :toctree: generated/ - inequality.theil.Theil - inequality.theil.TheilD - inequality.theil.TheilDSim + inequality.gini.Gini + inequality.gini.Gini_Spatial +Schutz Inequality Measures +-------------------------- -Gini Inequality Measures ------------------------- +.. autosummary:: + :toctree: generated/ + + inequality.schutz.Schutz + + +Theil Inequality Measures +------------------------- .. autosummary:: :toctree: generated/ - inequality.gini.Gini - inequality.gini.Gini_Spatial + inequality.theil.Theil + inequality.theil.TheilD + inequality.theil.TheilDSim + Pengram ------- diff --git a/inequality/schutz.py b/inequality/schutz.py index 846fd73..ed37cad 100644 --- a/inequality/schutz.py +++ b/inequality/schutz.py @@ -1,37 +1,44 @@ import matplotlib.pyplot as plt -import pandas as pd __all__ = ["Schutz"] class Schutz: - """ - The Schutz class calculates measures of inequality based on the given income distribution. + """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`. + - 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. 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. + 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. + 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. + 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. + The x and y coordinate of the intersection point where the + Schutz distance occurs. coefficient : float The original Schutz coefficient. @@ -43,26 +50,28 @@ class Schutz: ... 'Y': [1000, 2000, 1500, 3000, 2500] ... }) >>> schutz_obj = Schutz(gdf, 'Y') - >>> print("Schutz Distance:", schutz_obj.distance) + >>> print("Schutz Distance:", round(float(schutz_obj.distance),2)) Schutz Distance: 0.15 - >>> print("Intersection Point (x=y):", schutz_obj.intersection_point) + >>> print("Intersection Point:", round(schutz_obj.intersection_point, 1)) + Intersection Point (x=y): 0.6 - >>> print("Schutz Coefficient:", schutz_obj.coefficient) - Schutz Coefficient: 15 + >>> 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. + the intersection point with the line of perfect equality, and + the original Schutz coefficient. Parameters ---------- - df : pd.DataFrame + 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. + 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 @@ -73,7 +82,8 @@ def __init__(self, df, column_name): def _prepare_dataframe(self): """ - Prepare the DataFrame by sorting and calculating necessary columns. + Prepare the DataFrame by sorting and calculating necessary + columns. Returns ------- @@ -97,8 +107,8 @@ def _prepare_dataframe(self): def calculate_schutz_distance(self): """ - Calculate the Schutz distance, which is the maximum distance between - the line of perfect equality and the Lorenz curve. + Calculate the Schutz distance, which is the maximum distance + between the line of perfect equality and the Lorenz curve. Returns ------- @@ -109,12 +119,14 @@ def calculate_schutz_distance(self): def calculate_intersection_point(self): """ - Calculate the intersection point of the line of perfect equality and the Lorenz curve. + 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. + 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 @@ -136,15 +148,16 @@ def calculate_schutz_coefficient(self): ].coefficient.sum() return coefficient - def plot(self, xlabel="Cumulative Share of the Population", - ylabel="Cumulative Share of Income", grid=True): + ylabel="Cumulative Share of Income", grid=True): """ - Plot the Lorenz curve, the line of perfect equality, and the Schutz line. + 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. + 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)) @@ -158,7 +171,10 @@ def plot(self, xlabel="Cumulative Share of the Population", # Plot 45-degree line of perfect equality plt.plot( - [0, 1], [0, 1], label="Line of Perfect Equality", color="black", linestyle="--" + [0, 1], [0, 1], + label="Line of Perfect Equality", + color="black", + linestyle="--" ) # Plot Schutz line @@ -173,7 +189,9 @@ def plot(self, xlabel="Cumulative Share of the Population", # Add labels and title plt.xlabel(xlabel) plt.ylabel(ylabel) - plt.title("Lorenz Curve with Line of Perfect Equality and Schutz Line") + plt.title( + "Lorenz Curve with Line of Perfect Equality and Schutz Line" + ) plt.legend() plt.grid(grid) plt.show() 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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
GDPunitupctypctucpctycpctdistanceslopecoefficient
0100010.20.100.20.100.100.50-5.0
1150010.20.150.40.250.150.75-2.5
2200010.20.200.60.450.151.000.0
3250010.20.250.80.700.101.252.5
4300010.20.301.01.000.001.505.0
\n", + "
" + ], + "text/plain": [ + " GDP unit upct ypct ucpct ycpct distance slope coefficient\n", + "0 1000 1 0.2 0.10 0.2 0.10 0.10 0.50 -5.0\n", + "1 1500 1 0.2 0.15 0.4 0.25 0.15 0.75 -2.5\n", + "2 2000 1 0.2 0.20 0.6 0.45 0.15 1.00 0.0\n", + "3 2500 1 0.2 0.25 0.8 0.70 0.10 1.25 2.5\n", + "4 3000 1 0.2 0.30 1.0 1.00 0.00 1.50 5.0" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.df_processed" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "ff41b6d0-f4f2-4dc1-b485-5cac4fb2d29a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(7.499999999999998)" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.coefficient" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "5294f208-5b2e-4e86-aa7f-190b82555a2f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
GDPunitupctypctucpctycpctdistanceslopecoefficient
02010.10.020.10.028.000000e-020.2-8.0
15010.10.050.20.071.300000e-010.5-5.0
28010.10.080.30.151.500000e-010.8-2.0
310010.10.100.40.251.500000e-011.00.0
410010.10.100.50.351.500000e-011.00.0
510010.10.100.60.451.500000e-011.00.0
610010.10.100.70.551.500000e-011.00.0
712010.10.120.80.671.300000e-011.22.0
815010.10.150.90.828.000000e-021.55.0
918010.10.181.01.00-1.110223e-161.88.0
\n", + "
" + ], + "text/plain": [ + " GDP unit upct ypct ucpct ycpct distance slope coefficient\n", + "0 20 1 0.1 0.02 0.1 0.02 8.000000e-02 0.2 -8.0\n", + "1 50 1 0.1 0.05 0.2 0.07 1.300000e-01 0.5 -5.0\n", + "2 80 1 0.1 0.08 0.3 0.15 1.500000e-01 0.8 -2.0\n", + "3 100 1 0.1 0.10 0.4 0.25 1.500000e-01 1.0 0.0\n", + "4 100 1 0.1 0.10 0.5 0.35 1.500000e-01 1.0 0.0\n", + "5 100 1 0.1 0.10 0.6 0.45 1.500000e-01 1.0 0.0\n", + "6 100 1 0.1 0.10 0.7 0.55 1.500000e-01 1.0 0.0\n", + "7 120 1 0.1 0.12 0.8 0.67 1.300000e-01 1.2 2.0\n", + "8 150 1 0.1 0.15 0.9 0.82 8.000000e-02 1.5 5.0\n", + "9 180 1 0.1 0.18 1.0 1.00 -1.110223e-16 1.8 8.0" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.df_processed" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "191b0379-fa2b-48a8-83e3-4b1513b9ef33", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.15000000000000002)" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.distance" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "fe18ada3-a3b1-4543-b31f-290236823e24", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.30000000000000004)" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.intersection_point" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "dc17f5bc-9d85-42eb-9cfe-fbc153439e89", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "s.plot()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From e1748234d16d3088797d59ae587cd69c08f44548 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Wed, 21 Aug 2024 14:33:35 -0700 Subject: [PATCH 06/18] Correct docstring format --- inequality/schutz.py | 1 - 1 file changed, 1 deletion(-) diff --git a/inequality/schutz.py b/inequality/schutz.py index ed37cad..6c6316c 100644 --- a/inequality/schutz.py +++ b/inequality/schutz.py @@ -53,7 +53,6 @@ class Schutz: >>> print("Schutz Distance:", round(float(schutz_obj.distance),2)) Schutz Distance: 0.15 >>> print("Intersection Point:", round(schutz_obj.intersection_point, 1)) - Intersection Point (x=y): 0.6 >>> print("Schutz Coefficient:", round(schutz_obj.coefficient, 1)) Schutz Coefficient: 7.5 From 234f4e17d953dfdbdcfce39db291c75595e868e7 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Wed, 21 Aug 2024 14:36:32 -0700 Subject: [PATCH 07/18] Fix docstring --- inequality/schutz.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/inequality/schutz.py b/inequality/schutz.py index 6c6316c..05d956b 100644 --- a/inequality/schutz.py +++ b/inequality/schutz.py @@ -53,7 +53,7 @@ class Schutz: >>> print("Schutz Distance:", round(float(schutz_obj.distance),2)) Schutz Distance: 0.15 >>> print("Intersection Point:", round(schutz_obj.intersection_point, 1)) - Intersection Point (x=y): 0.6 + Intersection Point: 0.6 >>> print("Schutz Coefficient:", round(schutz_obj.coefficient, 1)) Schutz Coefficient: 7.5 """ From 4f33d37ee7bae214f88e3cf8cad5e4ffd531b004 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Wed, 21 Aug 2024 14:46:05 -0700 Subject: [PATCH 08/18] Ruff --- inequality/__init__.py | 33 +++++++++++++++++++++++++-------- 1 file changed, 25 insertions(+), 8 deletions(-) diff --git a/inequality/__init__.py b/inequality/__init__.py index a7ecd2a..806fe5f 100644 --- a/inequality/__init__.py +++ b/inequality/__init__.py @@ -8,14 +8,31 @@ from importlib.metadata import PackageNotFoundError, version from . import atkinson, gini, schutz, theil -from ._indices import (abundance, ellison_glaeser_egg, ellison_glaeser_egg_pop, - fractionalization_gs, gini_gi, gini_gi_m, gini_gig, - herfindahl_hd, hoover_hi, isolation_ii, isolation_isg, - margalev_md, maurel_sedillot_msg, - maurel_sedillot_msg_pop, menhinick_mi, - modified_segregation_msg, polarization, segregation_gsg, - shannon_se, similarity_w_wd, simpson_sd, simpson_so, - theil_th) +from ._indices import ( + abundance, + ellison_glaeser_egg, + ellison_glaeser_egg_pop, + fractionalization_gs, + gini_gi, + gini_gi_m, + gini_gig, + herfindahl_hd, + hoover_hi, + isolation_ii, + isolation_isg, + margalev_md, + maurel_sedillot_msg, + maurel_sedillot_msg_pop, + menhinick_mi, + modified_segregation_msg, + polarization, + segregation_gsg, + shannon_se, + similarity_w_wd, + simpson_sd, + simpson_so, + theil_th, +) with contextlib.suppress(PackageNotFoundError): __version__ = version("inequality") From daea79e12edd33a77ebcaa73c6340775869624b6 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 21 Aug 2024 21:48:23 +0000 Subject: [PATCH 09/18] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- inequality/schutz.py | 17 ++++++++++------- inequality/tests/test_schutz.py | 13 ++++++++----- 2 files changed, 18 insertions(+), 12 deletions(-) diff --git a/inequality/schutz.py b/inequality/schutz.py index 05d956b..53b4264 100644 --- a/inequality/schutz.py +++ b/inequality/schutz.py @@ -147,8 +147,12 @@ def calculate_schutz_coefficient(self): ].coefficient.sum() return coefficient - def plot(self, xlabel="Cumulative Share of the Population", - ylabel="Cumulative Share of Income", grid=True): + 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. @@ -170,10 +174,11 @@ def plot(self, xlabel="Cumulative Share of the Population", # Plot 45-degree line of perfect equality plt.plot( - [0, 1], [0, 1], + [0, 1], + [0, 1], label="Line of Perfect Equality", color="black", - linestyle="--" + linestyle="--", ) # Plot Schutz line @@ -188,9 +193,7 @@ def plot(self, xlabel="Cumulative Share of the Population", # Add labels and title plt.xlabel(xlabel) plt.ylabel(ylabel) - plt.title( - "Lorenz Curve with Line of Perfect Equality and Schutz Line" - ) + 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_schutz.py b/inequality/tests/test_schutz.py index 25a00e8..158e6e1 100644 --- a/inequality/tests/test_schutz.py +++ b/inequality/tests/test_schutz.py @@ -1,15 +1,18 @@ import pandas as pd import pytest import numpy as np -from inequality.schutz import Schutz # Replace 'your_module' with the actual name of the module where Schutz is defined +from inequality.schutz import ( + Schutz, +) # Replace 'your_module' with the actual name of the module where Schutz is defined + def test_schutz(): # Sample DataFrame data = np.array([20, 50, 80, 100, 100, 100, 100, 120, 150, 180]) - gdf = pd.DataFrame({'NAME': range(len(data)), 'Y': data}) + gdf = pd.DataFrame({"NAME": range(len(data)), "Y": data}) # Create Schutz object - schutz_obj = Schutz(gdf, 'Y') + schutz_obj = Schutz(gdf, "Y") # Assert the Schutz distance assert schutz_obj.distance == pytest.approx(0.15, rel=1e-9) @@ -20,6 +23,6 @@ def test_schutz(): # Assert the Schutz coefficient assert schutz_obj.coefficient == pytest.approx(15, rel=1e-9) -if __name__ == '__main__': - pytest.main() +if __name__ == "__main__": + pytest.main() From bb31d79887e8769bc618497e4bf05e83bf502543 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Wed, 21 Aug 2024 15:20:06 -0700 Subject: [PATCH 10/18] Update tests --- inequality/atkinson.py | 24 ------------- inequality/tests/test_schutz.py | 64 +++++++++++++++++++++++---------- 2 files changed, 46 insertions(+), 42 deletions(-) diff --git a/inequality/atkinson.py b/inequality/atkinson.py index f770fd7..67f0c33 100644 --- a/inequality/atkinson.py +++ b/inequality/atkinson.py @@ -110,27 +110,3 @@ def __init__(self, y, epsilon): self.epsilon = epsilon self.A = _atkinson(y, epsilon) self.EDE = y.mean() * (1 - self.A) - - -# Example usage -if __name__ == "__main__": - incomes = np.array([10, 20, 30, 40, 50]) - - # Using the _atkinson function - # Output: 0.06315339222708616 - print(f"_atkinson(incomes, 0.5): {_atkinson(incomes, 0.5)}") - # Output: 0.1316096384342157 - print(f"_atkinson(incomes, 1): {_atkinson(incomes, 1)}") - - # Using the Atkinson class - atkinson = Atkinson(incomes, 0.5) - # Output: 0.06315339222708616 - print(f"Atkinson index (epsilon=0.5): {atkinson.A}") - # Output: 28.105398233187415 - print(f"EDE (epsilon=0.5): {atkinson.EDE}") - - atkinson = Atkinson(incomes, 1) - # Output: 0.1316096384342157 - print(f"Atkinson index (epsilon=1): {atkinson.A}") - # Output: 26.051710846973528 - print(f"EDE (epsilon=1): {atkinson.EDE}") diff --git a/inequality/tests/test_schutz.py b/inequality/tests/test_schutz.py index 158e6e1..2cc7e19 100644 --- a/inequality/tests/test_schutz.py +++ b/inequality/tests/test_schutz.py @@ -1,28 +1,56 @@ +import os + +import matplotlib.pyplot as plt import pandas as pd import pytest -import numpy as np -from inequality.schutz import ( - Schutz, -) # Replace 'your_module' with the actual name of the module where Schutz is defined +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(): - # Sample DataFrame - data = np.array([20, 50, 80, 100, 100, 100, 100, 120, 150, 180]) - gdf = pd.DataFrame({"NAME": range(len(data)), "Y": data}) +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 - # Create Schutz object - schutz_obj = Schutz(gdf, "Y") - # Assert the Schutz distance - assert schutz_obj.distance == pytest.approx(0.15, rel=1e-9) +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}") - # Assert the intersection point (x=y) - assert schutz_obj.intersection_point == pytest.approx(0.3, rel=1e-9) - # Assert the Schutz coefficient - assert schutz_obj.coefficient == pytest.approx(15, rel=1e-9) +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() -if __name__ == "__main__": - pytest.main() + # Ensure that the plot file was created + assert os.path.exists(plot_file), "Plot file was not created." From 6fec5931023fb026b35afb9d2fcd4d2eec3082db Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 21 Aug 2024 22:24:03 +0000 Subject: [PATCH 11/18] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- inequality/tests/test_schutz.py | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/inequality/tests/test_schutz.py b/inequality/tests/test_schutz.py index 2cc7e19..1a90d1e 100644 --- a/inequality/tests/test_schutz.py +++ b/inequality/tests/test_schutz.py @@ -8,32 +8,32 @@ @pytest.fixture def example_dataframe(): - data = {'NAME': ['A', 'B', 'C', 'D', 'E'], - 'Y': [1000, 2000, 1500, 3000, 2500]} + 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') + 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') + schutz_obj = Schutz(example_dataframe, "Y") expected_intersection_point = 0.6 - assert pytest.approx(schutz_obj.intersection_point, - 0.1) == expected_intersection_point + assert ( + pytest.approx(schutz_obj.intersection_point, 0.1) == expected_intersection_point + ) def test_schutz_coefficient(example_dataframe): - schutz_obj = Schutz(example_dataframe, 'Y') + 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') + schutz_obj = Schutz(example_dataframe, "Y") try: schutz_obj.plot() except Exception as e: @@ -43,7 +43,7 @@ def test_schutz_plot_runs_without_errors(example_dataframe): 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') + schutz_obj = Schutz(example_dataframe, "Y") # Save the plot to a temporary directory plot_file = os.path.join(tmpdir, "schutz_plot.png") From 56a51a604bb91b74cb3fef4a146132825bdb3cde Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Thu, 22 Aug 2024 11:01:46 -0700 Subject: [PATCH 12/18] REF: make atkinson function public --- inequality/atkinson.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/inequality/atkinson.py b/inequality/atkinson.py index 67f0c33..7ea3d89 100644 --- a/inequality/atkinson.py +++ b/inequality/atkinson.py @@ -1,9 +1,9 @@ import numpy as np -__all__ = ["Atkinson"] +__all__ = ["Atkinson", "atkinson"] -def _atkinson(y, epsilon): +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 @@ -62,7 +62,7 @@ class Atkinson: 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, + distributed equivalent (EDE) represents the level of income that, if equally distributed, would give the same level of social welfare as the actual distribution. @@ -108,5 +108,5 @@ class Atkinson: def __init__(self, y, epsilon): self.y = np.asarray(y) self.epsilon = epsilon - self.A = _atkinson(y, epsilon) + self.A = atkinson(y, epsilon) self.EDE = y.mean() * (1 - self.A) From 927dad522210512b8af48641a25356e11cf0a9d0 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Thu, 22 Aug 2024 11:02:17 -0700 Subject: [PATCH 13/18] adjust tests for public atkinson --- inequality/tests/test_atkinson.py | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/inequality/tests/test_atkinson.py b/inequality/tests/test_atkinson.py index 659e515..b5d8b5c 100644 --- a/inequality/tests/test_atkinson.py +++ b/inequality/tests/test_atkinson.py @@ -1,34 +1,33 @@ import numpy as np import pytest +from inequality.atkinson import Atkinson, atkinson -from inequality.atkinson import Atkinson, _atkinson - -def test_atkinson_function(): +def testatkinson_function(): # Test case for epsilon = 0.5 incomes = np.array([10, 20, 30, 40, 50]) - result = _atkinson(incomes, 0.5) + 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) + 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) + result = atkinson(incomes, 0) expected = 0 assert np.isclose( result, expected, atol=1e-5 ), f"Expected {expected}, but got {result}" -def test_atkinson_class(): +def testatkinson_class(): # Test case for epsilon = 0.5 incomes = np.array([10, 20, 30, 40, 50]) atkinson = Atkinson(incomes, 0.5) From 9011aeed2596b7a1a69e551d4a9f8e53da324456 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Thu, 22 Aug 2024 11:05:20 -0700 Subject: [PATCH 14/18] REF public atkinson --- inequality/atkinson.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/inequality/atkinson.py b/inequality/atkinson.py index 7ea3d89..37230d0 100644 --- a/inequality/atkinson.py +++ b/inequality/atkinson.py @@ -39,9 +39,9 @@ def atkinson(y, epsilon): ------- >>> import numpy as np >>> incomes = np.array([10, 20, 30, 40, 50]) - >>> float(round(_atkinson(incomes, 0.5), 5)) + >>> float(round(atkinson(incomes, 0.5), 5)) 0.06315 - >>> float(round(_atkinson(incomes, 1),5)) + >>> float(round(atkinson(incomes, 1),5)) 0.13161 """ From 3eb67f2fc69b3398e1517d2490e005f1a96f9940 Mon Sep 17 00:00:00 2001 From: Sergio Rey Date: Thu, 22 Aug 2024 11:38:56 -0700 Subject: [PATCH 15/18] Update inequality/schutz.py Co-authored-by: James Gaboardi --- inequality/schutz.py | 1 - 1 file changed, 1 deletion(-) diff --git a/inequality/schutz.py b/inequality/schutz.py index 53b4264..7d53835 100644 --- a/inequality/schutz.py +++ b/inequality/schutz.py @@ -15,7 +15,6 @@ class Schutz: See :cite:`schutz1951MeasurementIncome`. - Parameters ---------- df : pd.DataFrame From f031729fca520160c689ab5c962d73e433f4eb86 Mon Sep 17 00:00:00 2001 From: Sergio Rey Date: Thu, 22 Aug 2024 11:39:03 -0700 Subject: [PATCH 16/18] Update inequality/schutz.py Co-authored-by: James Gaboardi --- inequality/schutz.py | 1 - 1 file changed, 1 deletion(-) diff --git a/inequality/schutz.py b/inequality/schutz.py index 7d53835..7288b71 100644 --- a/inequality/schutz.py +++ b/inequality/schutz.py @@ -14,7 +14,6 @@ class Schutz: Schutz coefficient. See :cite:`schutz1951MeasurementIncome`. - Parameters ---------- df : pd.DataFrame From ddd245d7a3d2a63f93b4f8089f8f1889990caa80 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sun, 1 Sep 2024 08:52:50 -0700 Subject: [PATCH 17/18] TEST: refactor for testing on windows/ci --- inequality/tests/test_pengram.py | 39 ++++++++++++++++++++++++-------- 1 file changed, 30 insertions(+), 9 deletions(-) diff --git a/inequality/tests/test_pengram.py b/inequality/tests/test_pengram.py index be53039..f952ebf 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 @@ -22,10 +27,8 @@ def sample_df(): @pytest.fixture 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 - + data = {"region": ["A", "B", "C", "D"], + "income": [50000, 60000, 70000, 80000]} polygons = [ Polygon([(0, 0), (1, 0), (1, 1), (0, 1)]), Polygon([(1, 0), (2, 0), (2, 1), (1, 1)]), @@ -60,6 +63,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 +74,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,15 +96,20 @@ 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): """Test pengram function with custom inset size.""" - ax, inset_ax = pengram(sample_gdf, col="income", name="region", inset_size="50%") + ax, inset_ax = pengram(sample_gdf, col="income", + name="region", inset_size="50%") assert ax is not None 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 +117,12 @@ 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): - pengram(sample_gdf, col="income", name="invalid_column", query=["A", "C"]) + with pytest.raises(KeyError, match="invalid_column"): + pengram(sample_gdf, col="income", + name="invalid_column", query=["A", "C"]) From b7a0947c0be933b25faa8eeb19f19b7e40a5aada Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Sun, 1 Sep 2024 15:55:11 +0000 Subject: [PATCH 18/18] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- inequality/tests/test_pengram.py | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/inequality/tests/test_pengram.py b/inequality/tests/test_pengram.py index f952ebf..db91332 100644 --- a/inequality/tests/test_pengram.py +++ b/inequality/tests/test_pengram.py @@ -7,7 +7,7 @@ from shapely.geometry import Polygon # Set the backend to 'Agg' to prevent GUI windows from opening -matplotlib.use('Agg') +matplotlib.use("Agg") # Test Data Setup @@ -27,8 +27,7 @@ def sample_df(): @pytest.fixture def sample_gdf(): """Sample GeoDataFrame for testing the pengram function.""" - data = {"region": ["A", "B", "C", "D"], - "income": [50000, 60000, 70000, 80000]} + data = {"region": ["A", "B", "C", "D"], "income": [50000, 60000, 70000, 80000]} polygons = [ Polygon([(0, 0), (1, 0), (1, 1), (0, 1)]), Polygon([(1, 0), (2, 0), (2, 1), (1, 1)]), @@ -102,8 +101,7 @@ def test_pengram_basic(sample_gdf): def test_pengram_custom_inset_size(sample_gdf): """Test pengram function with custom inset size.""" - ax, inset_ax = pengram(sample_gdf, col="income", - name="region", inset_size="50%") + ax, inset_ax = pengram(sample_gdf, col="income", name="region", inset_size="50%") assert ax is not None assert inset_ax is not None assert isinstance(ax, plt.Axes) @@ -124,5 +122,4 @@ def test_invalid_weight_column(sample_df): def test_invalid_query_column(sample_gdf): """Test pengram function with an invalid query column.""" with pytest.raises(KeyError, match="invalid_column"): - pengram(sample_gdf, col="income", - name="invalid_column", query=["A", "C"]) + pengram(sample_gdf, col="income", name="invalid_column", query=["A", "C"])