def plot_truncnorm_cdf(): import matplotlib.pyplot as plt H = 100. # mm B = 300. # mm fig, axs = plt.subplots(1, 2, dpi=90, facecolor='w', edgecolor='k', figsize=(B / 25.4, H / 25.4)) x = np.linspace(0, 5, 200) t = phuzzy.TruncNorm(alpha0=[1, 5], number_of_alpha_levels=25) p = t.pdf(x) P = t.cdf(x) axs[0].plot(x, p, label="pdf ana", lw=1) axs[1].plot(x, P, label="cdf ana", lw=1) f = phuzzy.FuzzyNumber(alpha0=[1, 2], alpha1=[1.1, 1.4], number_of_alpha_levels=5) f.df = t.df.copy() print(f.df) pf = f.pdf(x) Pf = f.cdf(x) mix_mpl(f) f.plot(show=False, ppf=[0, 0.01, .5, .99, 1]) axs[0].plot(x, pf, label="pdf num", lw=3, c="r", alpha=.5) axs[1].plot(x, Pf, label="cdf num", lw=3, c="r", alpha=.5) axs[0].legend(loc="best") axs[1].legend(loc="best") plt.show()
def atest_sub(): t = phuzzy.TruncNorm(alpha0=[1, 3], alpha1=[2], number_of_alpha_levels=15, name="t") print(t) assert len(t.df) == 15 p = phuzzy.Trapezoid(alpha0=[1, 4], alpha1=[2, 3], number_of_alpha_levels=5, name="p") print(p) assert len(p.df) == 5 a = t - p a.name = "t-p" print(a) print(a.df) mix_mpl(t) mix_mpl(p) mix_mpl(a) t.plot() p.plot() a.plot() print(a.df) a.df.iloc[10, a.df.columns.get_loc("r")] = 1.5 a.make_convex() a.name += "!" print(a.df) a.plot(show=True)
def atest_div(): t = phuzzy.TruncNorm(alpha0=[2, 3], alpha1=[], number_of_alpha_levels=15, name="t") print(t) assert len(t.df) == 15 p = phuzzy.Trapezoid(alpha0=[0, 4], alpha1=[2, 3], number_of_alpha_levels=5, name="p") print(p) assert len(p.df) == 5 a = t ** p a = p ** t a.name = "t**p" print(a) print(a.df) mix_mpl(t) mix_mpl(p) mix_mpl(a) t.plot() p.plot() a.plot() print(a.df) # a.df.iloc[10, a.df.columns.get_loc("max")] = 8.5 # a.make_convex() a.name += "!" print(a.df) a.plot(show=True)
def test_poor_mens_alpha_optimization_pow_fuzzy2(): t = phuzzy.TruncNorm(alpha0=[2, 3], alpha1=[], number_of_alpha_levels=5, name="t") p = phuzzy.Trapezoid(alpha0=[0, 4], alpha1=[2, 3], number_of_alpha_levels=5, name="p") # a = t ** p a = p**t a.name = "t**p" print(a.df.values.tolist()) print(a) print(a.df) assert np.allclose( a.df.values.tolist(), [[0.0, 0.0, 64.0], [0.25, 0.125, 52.734375], [0.5, 1.0, 42.875], [0.75, 2.25, 34.328125], [1.0, 4.0, 27.0]]) # mix_mpl(a) # a.plot(show=True) print(a.df.values.tolist()) a = t**p print(a.df.values.tolist()) # mix_mpl(a) # a.plot(show=True) assert np.allclose(a.df.values.tolist(), [[0.0, 1.0, 81.0], [0.25, 1.0, 59.51536637372663], [0.5, 1.0, 52.84832630002708], [0.75, 1.0, 47.58354751779905], [1.0, 1.0, 39.0625]])
def plot_sub(): H = 100. # mm B = 300. # mm fig, axs = plt.subplots(1, 3, dpi=90, facecolor='w', edgecolor='k', figsize=(B / 25.4, H / 25.4)) x = phuzzy.Trapezoid(alpha0=[0, 4], alpha1=[2, 3], number_of_alpha_levels=5) mix_mpl(x) x.plot(ax=axs[0]) y = phuzzy.TruncNorm(alpha0=[1, 3], number_of_alpha_levels=15, name="y") mix_mpl(y) y.plot(ax=axs[1]) z = x - y z.name = "x-y" mix_mpl(z) z.plot(ax=axs[2]) fig.tight_layout() fig.savefig("x-y.png") plt.show()
def test_alo(): v1 = phuzzy.Triangle(alpha0=[0, 4], alpha1=[1], number_of_alpha_levels=5) v2 = phuzzy.Superellipse(alpha0=[-1, 2.], alpha1=None, m=1.0, n=.5, number_of_alpha_levels=6) v3 = phuzzy.TruncGenNorm(alpha0=[1, 4], alpha1=[2, 3], number_of_alpha_levels=5, beta=3.) v4 = phuzzy.Trapezoid(alpha0=[0, 4], alpha1=[2, 3], number_of_alpha_levels=5) v5 = phuzzy.TruncNorm(alpha0=[1, 3], number_of_alpha_levels=5, name="y") v6 = phuzzy.Triangle(alpha0=[1, 4], alpha1=[3], number_of_alpha_levels=5) obj_function = '-1*((x[0] - 1) ** 2 + (x[1] + .1) ** 2 + .1 - (x[2] + 2) ** 2 - (x[3] - 0.1) ** 2 - (x[4] * x[5]) ** 2)' name = 'Opti_Test' kwargs = { 'var1': v1, 'var2': v2, 'var3': v3, 'var4': v4, 'var5': v5, 'var6': v6, 'obj_function': obj_function, 'name': name } # alo = phuzzy.analysis.alo.Alpha_Level_Optimization(name="test", obj_function=obj_function, vars=[v1, v2, v3, v4, v5, v6]) alo = phuzzy.analysis.alo.Alpha_Level_Optimization(**kwargs) alo.calculation() print(alo)
def test_mul(): t = phuzzy.TruncNorm(alpha0=[1, 3], alpha1=[2], number_of_alpha_levels=3, name="t") print(t) print(t.df.values.tolist()) assert len(t.df) == 3 p = phuzzy.Trapezoid(alpha0=[1, 4], alpha1=[2, 3], number_of_alpha_levels=3, name="p") print(p) assert len(p.df) == 3 a = t * p a.name = "t*p" print(a) print(a.df.values.tolist()) assert np.allclose( a.df.values.tolist(), [[0.0, 1.0, 12.0], [0.5, 2.4112937437280677, 8.373647931301177], [1.0, 4.0, 6.0]]) b = t * 1. print(b) print(b.df) print(b.df.values.tolist()) assert np.allclose( b.df.values.tolist(), [[0.0, 1.0, 3.0], [0.5, 1.6075291624853785, 2.392470837514622], [1.0, 2.0, 2.0]]) b = t * 2. print(b) print(b.df) print(b.df.values.tolist()) assert np.allclose( b.df.values.tolist(), [[0.0, 2.0, 6.0], [0.5, 3.215058324970757, 4.784941675029244], [1.0, 4.0, 4.0]]) b = 2. * t print(b) print(b.df) print(b.df.values.tolist()) assert np.allclose( b.df.values.tolist(), [[0.0, 2.0, 6.0], [0.5, 3.215058324970757, 4.784941675029244], [1.0, 4.0, 4.0]]) p = phuzzy.Trapezoid(alpha0=[-1, 4], alpha1=[2, 3], number_of_alpha_levels=3, name="p") z = p * p print(z.df)
def test_dynamic_mixin_on_instance(): p = phuzzy.TruncNorm(alpha0=[1, 3], number_of_alpha_levels=15, name="y") print(p) print(p.df) extend_instance(p, MPL_Mixin) assert hasattr(p, "plot")
def test_f2(): def f(x): x1 = x[0] x2 = x[1] return x1**2 + x2**2 x = phuzzy.TruncNorm(alpha0=[-6, 6], name="x", number_of_alpha_levels=11) y = phuzzy.TruncNorm(alpha0=[-6, 6], name="y", number_of_alpha_levels=11) # y = phuzzy.Triangle(alpha0=[-6, 6], alpha1=[6], name="y", number_of_alpha_levels=11) # y = phuzzy.Uniform(alpha0=[-6, 6], name="y", number_of_alpha_levels=11) pa = phuzzy.analysis.FuzzyAnalysis(designvars=[x, y], function=f) print(pa) sensibilities = pa.lcefa() print(sensibilities) assert np.isclose(x.sk, .5) assert np.isclose(y.sk, .5)
def atest_add(): t = phuzzy.TruncNorm(alpha0=[1, 3], alpha1=[2], number_of_alpha_levels=15) print(t) assert len(t.df) == 15 p = phuzzy.Trapezoid(alpha0=[1, 4], alpha1=[2, 3], number_of_alpha_levels=5) print(p) assert len(p.df) == 5 a = t + p print(a) print(a.df)
def test_power(): t = phuzzy.TruncNorm(alpha0=[2, 3], alpha1=[], number_of_alpha_levels=2, name="t") print(t) assert len(t.df) == 2 # p = phuzzy.Trapezoid(alpha0=[0, 4], alpha1=[2, 3], number_of_alpha_levels=2, name="p") # print(p) # assert len(p.df) == 2 # # a = t ** p # a = p ** t # a.name = "t**p" # print(a.df.values.tolist()) # assert np.allclose(a.df.values.tolist(), # [[0.0, 1e-30, 64.0], [1.0, 5.656854249492381, 15.588457268119896]] # ) # print(a) # print(a.df) b = t**3. print(b) print(b.df) print(b.df.values.tolist()) assert np.allclose(b.df.values.tolist(), [[0.0, 8.0, 27.0], [1.0, 15.625, 15.625]]) b = t**0. print(b) print(b.df) print(b.df.values.tolist()) assert np.allclose(b.df.values.tolist(), [[0.0, 1.0, 1.0], [1.0, 1.0, 1.0]]) c = 3**t print(c) print(c.df) print(c.df.values.tolist()) assert np.allclose( c.df.values.tolist(), [[0.0, 9.0, 27.0], [1.0, 15.588457268119896, 15.588457268119896]]) c = 0**t print(c) print(c.df) print(c.df.values.tolist()) assert np.allclose(c.df.values.tolist(), [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]])
def test_sst(): number_of_alpha_levels = 31 # load P P0 = 5000. # N dP = 0.01 * P0 # N P = ph.Triangle(alpha0=[P0 - dP, P0 + dP], alpha1=[P0], name="P", number_of_alpha_levels=number_of_alpha_levels) # dimensions L, W, H W0 = 50 # mm H0 = 100 # mm L0 = 2000 # mm dW = 0.01 * W0 # mm dH = 0.01 * H0 # mm dL = 0.01 * L0 # mm L = ph.Triangle(alpha0=[L0 - dL, L0 + dL], alpha1=[L0], name="L", number_of_alpha_levels=number_of_alpha_levels) W = ph.Triangle(alpha0=[W0 - dW, W0 + dW], alpha1=[W0], name="W", number_of_alpha_levels=number_of_alpha_levels) H = ph.Triangle(alpha0=[H0 - dH, H0 + dH], alpha1=[H0], name="H", number_of_alpha_levels=number_of_alpha_levels) # material E0 = 30000. # N/mm2 dE = 0.1 * E0 # N/mm2 E = ph.TruncNorm(alpha0=[E0 - dE, E0 + dE], alpha1=[E0], name="E", number_of_alpha_levels=number_of_alpha_levels) def calc_w(X): P = X[0] L = X[1] W = X[2] H = X[3] E = X[4] A = W * H A.name = "A" I = W * H** 3 / 12. I.name = "I" w = P * L ** 3 / (48 * E * I) w.name = r"P L^3 / (48 EI)" return w for x in [P, L, W, H, E]: print(x) pa = phuzzy.analysis.FuzzyAnalysis(designvars=[P, L, W, H, E], function=calc_w) print(pa) pa.lcefa()
def test_div(): t = phuzzy.TruncNorm(alpha0=[2, 3], alpha1=[], number_of_alpha_levels=3, name="t") print(t.df.values.tolist()) print(t) assert len(t.df) == 3 p = phuzzy.Trapezoid(alpha0=[0, 4], alpha1=[2, 3], number_of_alpha_levels=3, name="p") print(p) assert len(p.df) == 3 # a = t / p a = p / t a.name = "t/p" print(a.df.values.tolist()) assert np.allclose( a.df.values.tolist(), [[0.0, 3.3333333333333335e-11, 2.0], [0.5, 0.37088749487272066, 1.519252456825272], [1.0, 0.8, 1.2]]) print(a) print(a.df) print("_" * 80) b = t / 1. print(b) print(b.df) print(b.df.values.tolist()) assert np.allclose( b.df.values.tolist(), [[0.0, 2.0, 3.0], [0.5, 2.3037645812426892, 2.6962354187573108], [1.0, 2.5, 2.5]]) print(a) print(a.df) print("_" * 80) b = t / 2. print(b) print(b.df) print(b.df.values.tolist()) assert np.allclose( b.df.values.tolist(), [[0.0, 1.0, 1.5], [0.5, 1.1518822906213446, 1.3481177093786554], [1.0, 1.25, 1.25]])
def test_f1(): def f(x): x1 = x[0] x2 = x[1] return x1 + 2 x = phuzzy.TruncNorm(alpha0=[-6, 6], name="x", number_of_alpha_levels=11) y = phuzzy.Triangle(alpha0=[-6, 6], alpha1=[6], name="y", number_of_alpha_levels=11) pa = phuzzy.analysis.FuzzyAnalysis(designvars=[x, y], function=f) print(pa) vars = pa.lcefa() assert np.isclose(x.sk, 1) assert np.isclose(y.sk, 0)
def atest_f3(): def f(x): x1 = x[0] x2 = x[1] return np.sin(x1) + np.sin(4*x2) x = phuzzy.TruncNorm(alpha0=[0, 2*np.pi], name="x", number_of_alpha_levels=2) y = phuzzy.Triangle(alpha0=[0, 2*np.pi], alpha1=[6], name="y", number_of_alpha_levels=2) pa = phuzzy.analysis.FuzzyAnalysis(designvars=[x, y], function=f) print(pa) sensibilities = pa.lcefa() print(sensibilities) assert np.isclose(x.sk, .5) assert np.isclose(y.sk, .5)
def test_fuzzy_analysis(): a = 1.23 def f(x): x1 = x[0] x2 = x[1] return (x1+1.15)**2+(x2+.4)**2 + a x = phuzzy.TruncNorm(alpha0=[-6, 2], name="x", number_of_alpha_levels=2) y = phuzzy.Triangle(alpha0=[-6, 6], alpha1=[6], name="y", number_of_alpha_levels=2) pa = phuzzy.analysis.FuzzyAnalysis(designvars=[x, y], function=f) print(pa) z = pa.eval(ntgo=1000) print(z) assert np.isclose(z.min(), a)
def test_lcefalr(): a = 1.23 def f(x): x1 = x[0] x2 = x[1] return (x1+1.15)**2+(x2+.4)**4 + a x = phuzzy.TruncNorm(alpha0=[-6, 2], name="x", number_of_alpha_levels=2) y = phuzzy.Triangle(alpha0=[-6, 6], alpha1=[-6], name="y", number_of_alpha_levels=2) z = phuzzy.Triangle(alpha0=[-6, 6], alpha1=[6], name="z", number_of_alpha_levels=2) pa = phuzzy.analysis.FuzzyAnalysis(designvars=[x, y, z], function=f) print(pa) df = pa.lcefalr() print(df)
def test_add(): t = phuzzy.TruncNorm(alpha0=[1, 3], alpha1=[2], number_of_alpha_levels=3) print(t) assert len(t.df) == 3 p = phuzzy.Trapezoid(alpha0=[1, 4], alpha1=[2, 3], number_of_alpha_levels=5) print(p) assert len(p.df) == 5 a = t + p print(a) print(a.df) print(a.df.values.tolist()) assert np.allclose( a.df.values.tolist(), [[0.0, 2.0, 7.0], [0.25, 2.5537645812426892, 6.446235418757311], [0.5, 3.1075291624853785, 5.892470837514622], [0.75, 3.5537645812426892, 5.446235418757311], [1.0, 4.0, 5.0]]) # mix_mpl(t) # mix_mpl(p) # mix_mpl(a) # t.plot() # p.plot() # a.plot(show=True) b = t + 4. print(b) print(b.df) print(b.df.values.tolist()) assert np.allclose( b.df.values.tolist(), [[0.0, 5.0, 7.0], [0.5, 5.6075291624853785, 6.392470837514622], [1.0, 6.0, 6.0]]) b = 4 - t print(b) print(b.df) print(b.df.values.tolist()) assert np.allclose( b.df.values.tolist(), [[0.0, -3.0, -1.0], [0.5, -2.3924708375146215, -1.607529162485378], [1.0, -2.0, -2.0]])
def test_sub(): t = phuzzy.TruncNorm(alpha0=[1, 3], alpha1=[2], number_of_alpha_levels=3, name="t") print(t) assert len(t.df) == 3 p = phuzzy.Trapezoid(alpha0=[1, 4], alpha1=[2, 3], number_of_alpha_levels=3, name="p") print(p) assert len(p.df) == 3 a = t - p a.name = "t-p" print(a.df) print(a.df.values.tolist()) assert np.allclose( a.df.values.tolist(), [[0.0, -3.0, 2.0], [0.5, -1.8924708375146215, 0.892470837514622], [1.0, -1.0, 0.0]]) b = t - 4. print(b) print(b.df) print(b.df.values.tolist()) assert np.allclose( b.df.values.tolist(), [[0.0, -3.0, -1.0], [0.5, -2.3924708375146215, -1.607529162485378], [1.0, -2.0, -2.0]]) b = 4. - t print(b) print(b.df) print(b.df.values.tolist()) assert np.allclose( b.df.values.tolist(), [[0.0, -3.0, -1.0], [0.5, -2.3924708375146215, -1.607529162485378], [1.0, -2.0, -2.0]])
def test_expression(): x = phuzzy.TruncNorm(alpha0=[1, 2], name="x") y = phuzzy.Triangle(alpha0=[3, 6], alpha1=[4], name="y") z = f(x, y) expr = phuzzy.approx.doe.Expression(designvars=[x, y], function=f, name="f(x,y)") expr.generate_training_doe(name="train", n=10, method="lhs") expr.eval() z = expr.get_fuzzynumber_from_results() print(z.df) expr.fit_model() print(expr.model) expr.generate_prediction_doe(name="prediction", n=10000, method="lhs") u = expr.predict(name="u") print(u)
cmap = "autumn" csc = axc.contourf(Xs, Ys, Zs, alpha=1, cmap=cmap) csc2 = axc.contour(Xs, Ys, Zs, colors="k") axc.clabel(csc2, fontsize=9, inline=1, alpha=1) print(dir(csc)) norm = matplotlib.colors.Normalize(vmin=csc.zmin, vmax=csc.zmax) sm = plt.cm.ScalarMappable(norm=norm, cmap=csc.cmap) sm.set_array([]) cbar = fig.colorbar(sm, ticks=csc.levels) cbar.set_label("z") x = ph.Trapezoid(alpha0=[-1, 2], alpha1=[-.5, .5]) y = ph.TruncNorm(alpha0=[-1, 0.5]) z = f(x, y) z.name = "z" print(z.df) # left # cs = axl.contourf(Xs, Ys, Zs, alpha=.2, cmap="hot") norml = matplotlib.colors.Normalize(vmin=z.df.l.min(), vmax=z.df.l.max()) sml = plt.cm.ScalarMappable(norm=norml, cmap=cmap) sml.set_array([]) csl2 = axl.contour(Xs, Ys, Zs, colors="k") # cs2k = axl.contour(Xs, Ys, Zs, colors="k") axl.clabel(csl2, fontsize=9, inline=1, alpha=1) cbarl = fig.colorbar(sml, ticks=[z.df.l.min(), z.df.l.max()], ax=axl) cbarl.set_label("z.l")
cmap = "autumn" # cmap = "viridis" csc = axc.contourf(Xs, Ys, Zs, alpha=1, cmap=cmap) csc2 = axc.contour(Xs, Ys, Zs, colors="k") axc.clabel(csc2, fontsize=9, inline=1, alpha=1) norm = matplotlib.colors.Normalize(vmin=Zs.min(), vmax=Zs.max()) # norm= matplotlib.colors.Normalize(vmin=csc.vmin, vmax=csc.vmax) sm = plt.cm.ScalarMappable(norm=norm, cmap=csc.cmap) sm.set_array([]) cbar = fig.colorbar(sm, ticks=csc.levels, ax=axc) cbar.set_label("z") x = ph.Trapezoid(alpha0=[-1, 2], alpha1=[-.5, .5]) y = ph.TruncNorm(alpha0=[-1, 0.5], name="y") z = f(x, y) z.name = "z" print(z.df) # left # cs = axl.contourf(Xs, Ys, Zs, alpha=.2, cmap="hot") norml = matplotlib.colors.Normalize(vmin=z.df.l.min(), vmax=z.df.l.max()) sml = plt.cm.ScalarMappable(norm=norml, cmap=cmap) sml.set_array([]) csl2 = axl.contour(Xs, Ys, Zs, colors="k") # cs2k = axl.contour(Xs, Ys, Zs, colors="k") axl.clabel(csl2, fontsize=9, inline=1, alpha=1) cbarl = fig.colorbar(sml, ticks=[z.df.l.min(), z.df.l.max()], ax=axl) cbarl.set_label("z.l")
from phuzzy.mpl import mix_mpl import phuzzy.mpl.plots import matplotlib.pyplot as plt import phuzzy.approx.doe import numpy as np import pandas as pd from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt import phuzzy.mpl.plots import matplotlib.pyplot as plt from sklearn import neighbors from sklearn.svm import SVR from sklearn.model_selection import GridSearchCV x = phuzzy.TruncNorm(alpha0=[1, 2], name="x") y = phuzzy.TruncNorm(alpha0=[1, 2], name="y") # y = phuzzy.Triangle(alpha0=[3, 6], alpha1=[4], name="y") mix_mpl(x) mix_mpl(y) def f(x1, x2): return (x1-1)**2+(x2+.4)**2 + .1 z = f(x,y) doe = phuzzy.approx.doe.DOE(designvars = [x,y], name="xy") print(doe) # #############################################################################
number_of_alpha_levels=number_of_alpha_levels) W = ph.Triangle(alpha0=[W0 - dW, W0 + dW], alpha1=[W0], name="W", number_of_alpha_levels=number_of_alpha_levels) H = ph.Triangle(alpha0=[H0 - dH, H0 + dH], alpha1=[H0], name="H", number_of_alpha_levels=number_of_alpha_levels) # material E0 = 30000. # N/mm2 dE = 0.1 * E0 # N/mm2 E = ph.TruncNorm(alpha0=[E0 - dE, E0 + dE], alpha1=[E0], name="E", number_of_alpha_levels=number_of_alpha_levels) I0 = W0 * H0**3 / 12. w0 = P0 * L0**3 / (48 * E0 * I0) print("I0 = {:.4g} mm^4".format(I0)) # I0 = 4.167e+06 mm^4 print("w0 = {:.4g} mm".format(w0)) # w0 = 6.667 mm I = W * H**3 / 12. I.name = "I" w = P * L**3 / (48 * E * I) w.name = r"P L^3 / (48 EI)"
def plot_pow2(): H = 300. # mm B = 300. # mm fig, axs = plt.subplots(3, 3, dpi=90, facecolor='w', edgecolor='k', figsize=(B / 25.4, H / 25.4)) for i in range(3): axs[0, i].get_shared_x_axes().join(axs[0, i], axs[1, i], axs[2, i]) for i in range(1, 3): axs[i, 0].set_xlabel("x") axs[i, 1].set_xlabel("y") axs[i, 2].set_xlabel("x^y") i = 2 axs[i, 0].get_shared_y_axes().join(axs[i, 0], axs[i, 1], axs[i, 2]) x = phuzzy.Trapezoid(alpha0=[0, 4], alpha1=[2, 3], number_of_alpha_levels=5) mix_mpl(x) x.plot(ax=axs[0, 0]) y = phuzzy.TruncNorm(alpha0=[1, 3], number_of_alpha_levels=15, name="y") mix_mpl(y) y.plot(ax=axs[0, 1]) z = x**y z.name = "x^y" mix_mpl(z) z.plot(ax=axs[0, 2]) b = np.linspace(-1, 5, 200) px = x.pdf(b) Px = x.cdf(b) axs[1, 0].fill_between(b, 0, px, alpha=.2) axs[1, 0].plot(b, px, label="pdf", lw=1) axs[2, 0].fill_between(b, 0, Px, alpha=.2) axs[2, 0].plot(b, Px, label="cdf", lw=1) py = y.pdf(b) Py = y.cdf(b) axs[1, 1].fill_between(b, 0, py, alpha=.2) axs[1, 1].plot(b, py, label="pdf", lw=1) axs[2, 1].fill_between(b, 0, Py, alpha=.2) axs[2, 1].plot(b, Py, label="cdf", lw=1) b = np.linspace(z.alpha0["low"], z.alpha0["high"], 200) pz = z.pdf(b) Pz = z.cdf(b) axs[1, 2].fill_between(b, 0, pz, alpha=.2) axs[1, 2].plot(b, pz, label="pdf", lw=1) axs[2, 2].fill_between(b, 0, Pz, alpha=.2) axs[2, 2].plot(b, Pz, label="cdf", lw=1) for i in range(3): axs[2, i].axhline(1, alpha=.4, c="k", lw=.5) # axs[1,i].set_ylabel("pdf") # axs[2,i].set_ylabel("cdf") axs[1, i].annotate('pdf', (0.01, 0.99), xycoords='axes fraction', size=8, ha='left', va='top', textcoords='axes fraction') axs[2, i].annotate('cdf', (0.01, 0.99), xycoords='axes fraction', size=8, ha='left', va='top', textcoords='axes fraction') # axs[1,1].sharex = axs[0,1] # axs[2,1].sharex = axs[0,1] # axs[1,1].share_x_axes(axs[0,1]) for ax in axs.ravel(): ax.set_ylim(0, None) fig.tight_layout() fig.savefig("x**y_pdf_cdf.png") plt.show()