def test_utilitarian_replication():
data = datasets.make_uniform(seed=42, size=300, mu=1, nbin=None)
k = 2 # factor
y = k * data.data["x"].tolist()
df2 = pd.DataFrame({"x": y})
dr2 = ApodeData(df2, income_column="x")
assert data.welfare("utilitarian") == dr2.welfare("utilitarian")
def make_chisquare(seed=None, size=100, df=5, c=10, nbin=None):
"""Chisquare Distribution.
Parameters
----------
seed: int, optional(default=None)
size: int, optional(default=100)
df: float, optional(default=5)
c: float, optional(default=10)
nbin: int, optional(default=None)
Return
------
out: float array
Array of random numbers.
"""
random = np.random.RandomState(seed=seed)
y = c * random.chisquare(df=df, size=size)
df = pd.DataFrame({"x": y})
if nbin is None:
return ApodeData(df, income_column="x")
else:
df = binning(df, nbin=nbin)
return ApodeData(df, income_column="x")
def make_uniform(seed=None, size=100, mu=100, nbin=None):
"""Uniform Distribution.
Parameters
----------
seed: int, optional(default=None)
size: int, optional(default=100)
mu: float, optional(default=100)
nbin: int, optional(default=None)
Return
------
out: float array
Array of random numbers.
"""
random = np.random.RandomState(seed=seed)
y = random.uniform(size=size) * mu
df = pd.DataFrame({"x": y})
if nbin is None:
return ApodeData(df, income_column="x")
else:
df = binning(df, nbin=nbin)
return ApodeData(df, income_column="x")
def make_exponential(seed=None, size=100, scale=1, c=50, nbin=None):
"""Exponential Distribution.
Parameters
----------
seed: int, optional(default=None)
size: int, optional(default=100)
scale: float, optional(default=1.0)
c: float, optional(default=50)
nbin: int, optional(default=None)
Return
------
out: float array
Array of random numbers.
"""
random = np.random.RandomState(seed=seed)
y = c * random.exponential(scale=scale, size=size)
df = pd.DataFrame({"x": y})
if nbin is None:
return ApodeData(df, income_column="x")
else:
df = binning(df, nbin=nbin)
return ApodeData(df, income_column="x")
def make_lognormal(seed=None, size=100, sigma=1.0, nbin=None):
"""Lognormal Distribution.
Parameters
----------
seed: int, optional(default=None)
size: int, optional(default=100)
sigma: float, optional(default=1.0)
nbin: int, optional(default=None)
Return
------
out: float array
Array of random numbers.
"""
random = np.random.RandomState(seed=seed)
y = random.lognormal(mean=3.3, sigma=sigma, size=size)
df = pd.DataFrame({"x": y})
if nbin is None:
return ApodeData(df, income_column="x")
else:
df = binning(df, nbin=nbin)
return ApodeData(df, income_column="x")
def make_bimodal(size=100, nbin=None):
"""Bimodal Distribution.
Parameters
----------
size: int, optional(default=100)
nbin: int, optional(default=None)
Return
------
out: float array
"""
n1 = size // 2
a = np.power(np.arange(1, n1 + 1), 0.5)
b = n1**2
y = np.concatenate((b - a, b + a))
y = np.sort(y - np.min(y) + 1)
y = np.concatenate((np.zeros(size - 1), [10]))
df = pd.DataFrame({"x": y})
if nbin is None:
return ApodeData(df, income_column="x")
else:
df = binning(df, nbin=nbin)
return ApodeData(df, income_column="x")
def make_pareto(seed=None, a=5, size=100, c=200, nbin=None):
"""Pareto Distribution.
Parameters
----------
seed: int, optional(default=None)
a: float, optional(default=5)
size: int, optional(default=100)
c: int, optional(default=200)
nbin: int, optional(default=None)
Return
------
out: float array
Array of random numbers.
"""
random = np.random.RandomState(seed=seed)
y = c * random.pareto(a=a, size=size)
df = pd.DataFrame({"x": y})
if nbin is None:
return ApodeData(df, income_column="x")
else:
df = binning(df, nbin=nbin)
return ApodeData(df, income_column="x")
def test_rawlsian_symmetry():
data = datasets.make_uniform(seed=42, size=300, mu=1, nbin=None)
y = data.data["x"].tolist()
np.random.shuffle(y)
df2 = pd.DataFrame({"x": y})
dr2 = ApodeData(df2, income_column="x")
assert data.welfare(method="rawlsian") == dr2.welfare(method="rawlsian")
def test_theilt_replication():
ad = datasets.make_uniform(seed=42, size=300, mu=1, nbin=None)
k = 2 # factor
y = k * ad.data["x"].tolist()
df2 = pd.DataFrame({"x": y})
ad2 = ApodeData(df2, income_column="x")
assert ad.welfare("theilt") == ad2.welfare("theilt")
def test_fgt_replication():
ad = datasets.make_uniform(seed=42, size=300, mu=1, nbin=None)
k = 2 # factor
pline = np.mean(ad.data.values)
y = k * ad.data["x"].tolist()
df2 = pd.DataFrame({"x": y})
ad2 = ApodeData(df2, income_column="x")
assert ad.poverty("fgt", pline=pline) == ad2.poverty("fgt", pline=pline)
def test_wolfson_symmetry():
ad = datasets.make_uniform(seed=42, size=300, mu=1, nbin=None)
y = ad.data["x"].tolist()
np.random.shuffle(y)
df2 = pd.DataFrame({"x": y})
ad2 = ApodeData(df2, income_column="x")
assert ad.polarization(method="wolfson") == ad2.polarization(
method="wolfson")
def test_utilitarian_homogeneity():
ad = datasets.make_uniform(seed=42, size=300, mu=1, nbin=None)
k = 2 # factor
y = ad.data["x"].tolist()
y = k * y
df2 = pd.DataFrame({"x": y})
ad2 = ApodeData(df2, income_column="x")
assert ad.welfare("utilitarian") == ad2.welfare("utilitarian")
def test_theilt_homogeneity():
data = datasets.make_uniform(seed=42, size=300, mu=1, nbin=None)
k = 2 # factor
y = data.data["x"].tolist()
y = k * y
df2 = pd.DataFrame({"x": y})
dr2 = ApodeData(df2, income_column="x")
assert data.welfare("theilt") == dr2.welfare("theilt")
def test_utilitarian_symmetry():
data = datasets.make_uniform(seed=42, size=300, mu=1, nbin=None)
y = data.data["x"].tolist()
np.random.shuffle(y)
df2 = pd.DataFrame({"x": y})
dr2 = ApodeData(df2, income_column="x")
np.testing.assert_allclose(data.welfare(method="utilitarian"),
dr2.welfare(method="utilitarian"))
def test_entropy_symmetry():
ad = datasets.make_uniform(seed=42, size=300, mu=1, nbin=None)
y = ad.data["x"].tolist()
np.random.shuffle(y)
df2 = pd.DataFrame({"x": y})
ad2 = ApodeData(df2, income_column="x")
np.testing.assert_allclose(ad.inequality(method="entropy"),
ad2.inequality(method="entropy"))
def test_bd_replication():
data = datasets.make_uniform(seed=42, size=300, mu=1, nbin=None)
k = 2 # factor
pline = np.mean(data.data.values)
y = k * data.data["x"].tolist()
df2 = pd.DataFrame({"x": y})
dr2 = ApodeData(df2, income_column="x")
assert data.poverty("bd", pline=pline) == dr2.poverty("bd", pline=pline)
def test_rosenbluth_symmetry():
data = datasets.make_uniform(seed=42, size=300, mu=1, nbin=None)
y = data.data["x"].tolist()
np.random.shuffle(y)
df2 = pd.DataFrame({"x": y})
dr2 = ApodeData(df2, income_column="x")
assert data.concentration(method="rosenbluth") == dr2.concentration(
method="rosenbluth")
def test_bd_homogeneity():
ad = datasets.make_uniform(seed=42, size=300, mu=1, nbin=None)
k = 2 # factor
pline = np.mean(ad.data.values)
y = ad.data["x"].tolist()
y = [yi * k for yi in y]
df2 = pd.DataFrame({"x": y})
ad2 = ApodeData(df2, income_column="x")
assert ad.poverty("bd", pline=pline) == ad2.poverty("bd", pline=pline * k)
def test_concentration_ratio_symmetry():
ad = datasets.make_uniform(seed=42, size=300, mu=1, nbin=None)
y = ad.data["x"].tolist()
np.random.shuffle(y)
df2 = pd.DataFrame({"x": y})
ad2 = ApodeData(df2, income_column="x")
assert ad.concentration(method="concentration_ratio",
k=20) == ad2.concentration(
method="concentration_ratio", k=20)
def test_thon_symmetry():
ad = datasets.make_uniform(seed=42, size=300, mu=1, nbin=None)
pline = np.mean(ad.data.values)
y = ad.data["x"].tolist()
np.random.shuffle(y)
df2 = pd.DataFrame({"x": y})
ad2 = ApodeData(df2, income_column="x")
assert ad.poverty(method="thon", pline=pline) == ad2.poverty(method="thon",
pline=pline)
def test_bd_symmetry():
data = datasets.make_uniform(seed=42, size=300, mu=1, nbin=None)
pline = np.mean(data.data.values)
y = data.data["x"].tolist()
np.random.shuffle(y)
df2 = pd.DataFrame({"x": y})
dr2 = ApodeData(df2, income_column="x")
assert data.poverty(method="bd", pline=pline) == dr2.poverty(method="bd",
pline=pline)
def test_watts_replication():
data = datasets.make_uniform(seed=42, size=300, mu=1, nbin=None)
k = 2 # factor
pline = np.mean(data.data.values)
y = k * data.data["x"].tolist()
df2 = pd.DataFrame({"x": y})
dr2 = ApodeData(df2, income_column="x")
np.testing.assert_allclose(data.poverty("watts", pline=pline),
dr2.poverty("watts", pline=pline))
def test_isoelastic_symmetry():
ad = datasets.make_uniform(seed=42, size=300, mu=1, nbin=None)
y = ad.data["x"].tolist()
np.random.shuffle(y)
df2 = pd.DataFrame({"x": y})
ad2 = ApodeData(df2, income_column="x")
np.testing.assert_allclose(
ad.welfare(method="isoelastic", alpha=0),
ad2.welfare(method="isoelastic", alpha=0),
)
def test_thon_homogeneity():
data = datasets.make_uniform(seed=42, size=300, mu=1, nbin=None)
k = 2 # factor
pline = np.mean(data.data.values)
y = data.data["x"].tolist()
y = [yi * k for yi in y]
df2 = pd.DataFrame({"x": y})
dr2 = ApodeData(df2, income_column="x")
assert data.poverty("thon", pline=pline) == dr2.poverty("thon",
pline=pline * k)
def test_takayama_replication():
ad = datasets.make_uniform(seed=42, size=300, mu=1, nbin=None)
k = 2 # factor
pline = np.mean(ad.data.values)
y = k * ad.data["x"].tolist()
df2 = pd.DataFrame({"x": y})
ad2 = ApodeData(df2, income_column="x")
np.testing.assert_allclose(
ad.poverty("takayama", pline=pline),
ad2.poverty("takayama", pline=pline),
)
def test_gini_extreme_values():
y = np.zeros(300)
y[0] = 10
np.random.shuffle(y)
df = pd.DataFrame({"x": y})
# data_min = ApodeData(df, income_column="x") #noqa
y = np.ones(300) * 10
df = pd.DataFrame({"x": y})
data_max = ApodeData(df, income_column="x")
# assert data_min.inequality.gini() == 1 #CHECK, fails
assert data_max.inequality.gini() == 0
def make_constant(size=100, nbin=None):
"""Constant value Distribution.
Parameters
----------
size: int, optional(default=100)
nbin: int, optional(default=None)
Return
------
out: float array
"""
y = np.ones(size) * 10.0
df = pd.DataFrame({"x": y})
if nbin is None:
return ApodeData(df, income_column="x")
else:
df = binning(df, nbin=nbin)
return ApodeData(df, income_column="x")
def make_extreme(size=100, nbin=None):
"""Extreme value Distribution.
Parameters
----------
size: int, optional(default=100)
nbin: int, optional(default=None)
Return
------
out: float array
"""
y = np.concatenate((np.zeros(size - 1), [10])) + 0.0
df = pd.DataFrame({"x": y})
if nbin is None:
return ApodeData(df, income_column="x")
else:
df = binning(df, nbin=nbin)
return ApodeData(df, income_column="x")
def make_squared(size=100, nbin=None):
"""Squared value Distribution.
Parameters
----------
size: int, optional(default=100)
nbin: int, optional(default=None)
Return
------
out: float array
"""
y = np.power(np.arange(1, size + 1), 2)
df = pd.DataFrame({"x": y})
if nbin is None:
return ApodeData(df, income_column="x")
else:
df = binning(df, nbin=nbin)
return ApodeData(df, income_column="x")
def test_entropy_values(income_arrays, inequality_results):
ad1 = ApodeData(income_arrays, income_column="y1")
ad2 = ApodeData(income_arrays, income_column="y2")
ad3 = ApodeData(income_arrays, income_column="y3")
ad4 = ApodeData(income_arrays, income_column="y4")
ad5 = ApodeData(income_arrays, income_column="y5")
ad6 = ApodeData(income_arrays, income_column="y6")
# alpha = 0
# Relative tets modified (avoid division by zero):
# test = ((val1+1)-(val2+1))/(val1+1)
np.testing.assert_allclose(
ad1.inequality.entropy(alpha=0) + 1,
inequality_results.entropy0[0] + 1)
np.testing.assert_allclose(ad2.inequality.entropy(alpha=0),
inequality_results.entropy0[1])
np.testing.assert_allclose(ad3.inequality.entropy(alpha=0),
inequality_results.entropy0[2])
np.testing.assert_allclose(ad4.inequality.entropy(alpha=0),
inequality_results.entropy0[3])
np.testing.assert_allclose(ad5.inequality.entropy(alpha=0),
inequality_results.entropy0[4])
np.testing.assert_allclose(ad6.inequality.entropy(alpha=0),
inequality_results.entropy0[5])
# alpha = 1
# Relative tets modified (avoid division by zero):
# test = ((val1+1)-(val2+1))/(val1+1)
np.testing.assert_allclose(
ad1.inequality.entropy(alpha=1) + 1,
inequality_results.entropy1[0] + 1)
# Falla, 0.31443337122879683, ver formula stata
# np.testing.assert_allclose(
# ad2.inequality.entropy(alpha=1), inequality_results.entropy1[1]
# )
# np.testing.assert_allclose(
# ad3.inequality.entropy(alpha=1), inequality_results.entropy1[2]
# )
# np.testing.assert_allclose(
# ad4.inequality.entropy(alpha=1), inequality_results.entropy1[3]
# )
np.testing.assert_allclose(ad5.inequality.entropy(alpha=1),
inequality_results.entropy1[4])
np.testing.assert_allclose(ad6.inequality.entropy(alpha=1),
inequality_results.entropy1[5])
# alpha = 2
# Relative tets modified (avoid division by zero):
# test = ((val1+1)-(val2+1))/(val1+1)
np.testing.assert_allclose(
ad1.inequality.entropy(alpha=2) + 1,
inequality_results.entropy2[0] + 1)
np.testing.assert_allclose(ad2.inequality.entropy(alpha=2),
inequality_results.entropy2[1])
np.testing.assert_allclose(ad3.inequality.entropy(alpha=2),
inequality_results.entropy2[2])
np.testing.assert_allclose(ad4.inequality.entropy(alpha=2),
inequality_results.entropy2[3])
np.testing.assert_allclose(ad5.inequality.entropy(alpha=2),
inequality_results.entropy2[4])
np.testing.assert_allclose(ad6.inequality.entropy(alpha=2),
inequality_results.entropy2[5])