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_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 normal_estimator():
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))
alpha0 = [-3, 8]
alpha1 = [-1]
size = 5000
data = np.random.triangular(alpha0[0], alpha1[0], alpha0[1], size)
p0 = phuzzy.Triangle(name="org", alpha0=alpha0, alpha1=alpha1)
p = phuzzy.Triangle.from_data(data=data, name="estimate")
print(p.df)
mix_mpl(p)
mix_mpl(p0)
p0.plot(ax=axs[1])
p.plot(ax=axs[1], labels=False)
print(data.mean())
print(data.shape)
p.plot(ax=axs[0])
h = axs[0].hist(data, bins=50, normed=True, alpha=.5)
fig.tight_layout()
plt.show()
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_number_of_alpha_levels():
t = phuzzy.Triangle(alpha0=[1, 3], alpha1=[2], number_of_alpha_levels=4)
print(t.number_of_alpha_levels)
print(t.df)
assert t.number_of_alpha_levels == 4
t.number_of_alpha_levels = 5
# t.convert_df(alpha_levels=5)
print(t.number_of_alpha_levels)
print(t.df)
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 test_lcefalr2():
a = 1.23
def f(x):
x2 = x[0]
return x2
# x = phuzzy.TruncNorm(alpha0=[-6, 2], name="x", number_of_alpha_levels=3)
y = phuzzy.Triangle(alpha0=[-6, 6], alpha1=[6], name="y", number_of_alpha_levels=3)
# z = phuzzy.Triangle(alpha0=[-6, 6], alpha1=[6], name="z", number_of_alpha_levels=3)
pa = phuzzy.analysis.FuzzyAnalysis(designvars=[y], function=f)
print(pa)
df = pa.lcefalr()
print(df)
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_triangle():
t = phuzzy.Triangle(alpha0=[1, 3], alpha1=[2], number_of_alpha_levels=15)
print(t)
print(t.__class__.__name__)
print(t.df)
assert len(t.df) == 15
print([t])
print(t.get_01)
print(t.df.columns)
assert all([
x == y
for x, y in zip(sorted(t.df.columns), sorted(["alpha", "l", "r"]))
])
s = t.to_str()
print(s)
pdf = t.pdf([2])
print(pdf)
cdf = t.cdf([2])
print(cdf)
t.discretize(alpha0=[1, 3], alpha1=[2], alpha_levels=5)
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)
def test_operation_class():
tra = phuzzy.Trapezoid(alpha0=[1, 4],
alpha1=[2, 3],
number_of_alpha_levels=5)
tri = phuzzy.Triangle(alpha0=[1, 4],
alpha1=[2, 3],
number_of_alpha_levels=5)
uni = phuzzy.Uniform(alpha0=[1, 4],
alpha1=[2, 3],
number_of_alpha_levels=5)
x = tra + tra
assert isinstance(x, phuzzy.Trapezoid)
x = uni + uni
assert isinstance(x, phuzzy.Uniform)
x = tri + uni
assert isinstance(x, phuzzy.Triangle)
x = uni + tri
print(x.__class__)
assert isinstance(x, phuzzy.Triangle)
x = tra + uni
assert isinstance(x, phuzzy.Trapezoid)
x = uni + tra
assert isinstance(x, phuzzy.Trapezoid)
x = tra + tri
assert isinstance(x, phuzzy.Trapezoid)
x = tri + tra
assert isinstance(x, phuzzy.Trapezoid)
x = uni + tri + tra
assert isinstance(x, phuzzy.Trapezoid)
x = uni + 2.
assert isinstance(x, phuzzy.Uniform)
def test_fuzzy():
n = phuzzy.FuzzyNumber()
print(n)
print(n.__class__.__name__)
assert hasattr(n, "name")
assert hasattr(n, "df")
assert hasattr(n, "number_of_alpha_levels")
t = phuzzy.FuzzyNumber.from_data(data=[1, 3, 5], number_of_alpha_levels=3)
print(t.df)
assert len(t.df) == 3
print(t.__class__.__name__)
s = t.to_str()
print(s)
pdf = t.pdf([2])
print(pdf)
cdf = t.cdf([2])
print(cdf)
n = phuzzy.FuzzyNumber()
with pytest.raises(NotImplementedError) as exp:
s = n.to_str()
print(s)
with pytest.raises(NotImplementedError) as exp:
s = phuzzy.FuzzyNumber.from_str("!")
print(s)
t = phuzzy.Triangle(alpha0=[1, 3], alpha1=[2], number_of_alpha_levels=15)
p = phuzzy.Trapezoid(alpha0=[1, 4],
alpha1=[2, 3],
number_of_alpha_levels=5)
n = t + p
pdf = n.pdf([2])
print(pdf)
cdf = n.cdf([2])
print(cdf)
def plot_tria_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, 6, 200)
t = phuzzy.Triangle(alpha0=[1, 4], alpha1=[2], number_of_alpha_levels=5)
p = t.pdf(x)
P = t.cdf(x)
axs[0].plot(x, p, label="pdf", lw=2)
axs[1].plot(x, P, label="cdf", lw=2)
axs[0].legend(loc="best")
axs[1].legend(loc="best")
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)
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()
import matplotlib.pyplot as plt
add_selectbox = st.sidebar.selectbox("phuzzy numbers",
("Triangle", "Uniform", "Trapezoid"))
st.text('phuzzy')
p1_slot = st.empty()
uniform = phuzzy.Uniform(alpha0=[1, 2])
mix_mpl(uniform)
trapezoid = phuzzy.Trapezoid(alpha0=[1, 2], alpha1=[1.2, 1.5])
mix_mpl(trapezoid)
triangle = phuzzy.Triangle(alpha0=[1, 2], alpha1=[1.8])
mix_mpl(triangle)
p_dict = {"Triangle": triangle, "Uniform": uniform, "Trapezoid": trapezoid}
print(add_selectbox)
p = p_dict.get(add_selectbox, triangle)
def plot_phuzzy_number(p):
H = 170. #mm
B = 270. #mm
fig, ax = plt.subplots(dpi=90,
facecolor='w',
edgecolor='k',
figsize=(B / 25.4, H / 25.4))
# -*- coding: utf-8 -*-
import phuzzy as ph
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],
