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