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])