Отделение значений от массива с помощью Python
**** У меня есть такая функция:****
aC1_l, bC1_l, cC1_l = 7, 8, 9
aC1_m, bC1_m, cC1_m = 7, 8, 9
aC1_u, bC1_u, cC1_u = 8, 9, 9
...
aC7_l, bC7_l, cC7_l = 4, 5, 6
aC7_m, bC7_m, cC7_m = 5, 6, 7
aC7_u, bC7_u, cC7_u = 5, 6, 7
out = []
while len(out) < 5000:
for aC1 in aC1_l, aC1_m, aC1_u:
if aC1_l == aC1_m == aC1_u :
mean_TFN_aC1 = aC1_l
stdev_TFN_aC1=0
x_aC1 = 0
y_aC1 = 0
z_aC1 = 0
alpha_aC1 = 0
beta_aC1 = 0
aC1 = aC1_l
else:
mean_TFN_aC1 = (aC1_l + 4*aC1_m + aC1_u)/6.
stdev_TFN_aC1=(aC1_u - aC1_l)/6.
x_aC1 = (mean_TFN_aC1 - aC1_l)/(aC1_u - aC1_l)
y_aC1 = (mean_TFN_aC1 - aC1_l)*(aC1_u - mean_TFN_aC1)/(stdev_TFN_aC1**2)
z_aC1 = y_aC1 - 1
alpha_aC1 = x_aC1 * z_aC1
beta_aC1 = ((aC1_u-mean_TFN_aC1)/(mean_TFN_aC1-aC1_l))*alpha_aC1
aC1 = aC1_l + np.random.beta (alpha_aC1, beta_aC1)*(aC1_u - aC1_l)
for bC1 in bC1_l, bC1_m, bC1_u:
if bC1_l == bC1_m == bC1_u :
mean_TFN_bC1 = bC1_l
stdev_TFN_bC1=0
x_bC1 = 0
y_bC1 = 0
z_bC1 = 0
alpha_bC1 = 0
beta_bC1 = 0
bC1 = bC1_l
else:
mean_TFN_bC1 = (bC1_l + 4*bC1_m + bC1_u)/6.
stdev_TFN_bC1=(bC1_u - bC1_l)/6.
x_bC1 = (mean_TFN_bC1 - bC1_l)/(bC1_u - bC1_l)
y_bC1 = (mean_TFN_bC1 - bC1_l)*(bC1_u - mean_TFN_bC1)/(stdev_TFN_bC1**2)
z_bC1 = y_bC1 - 1
alpha_bC1 = x_bC1 * z_bC1
beta_bC1 = ((bC1_u-mean_TFN_bC1)/(mean_TFN_bC1-bC1_l))*alpha_bC1
bC1 = bC1_l + np.random.beta (alpha_bC1, beta_bC1)*(bC1_u - bC1_l)
for cC1 in cC1_l, cC1_m, cC1_u:
if cC1_l == cC1_m == cC1_u :
mean_TFN_cC1 = cC1_l
stdev_TFN_cC1=0
x_cC1 = 0
y_cC1 = 0
z_cC1 = 0
alpha_cC1 = 0
beta_cC1 = 0
cC1 = cC1_l
else:
mean_TFN_cC1 = (cC1_l + 4*cC1_m + cC1_u)/6.
stdev_TFN_cC1=(cC1_u - cC1_l)/6.
x_cC1 = (mean_TFN_cC1 - cC1_l)/(cC1_u - cC1_l)
y_cC1 = (mean_TFN_cC1 - cC1_l)*(cC1_u - mean_TFN_cC1)/(stdev_TFN_cC1**2)
z_cC1 = y_cC1 - 1
alpha_cC1 = x_cC1 * z_cC1
beta_cC1 = ((cC1_u-mean_TFN_cC1)/(mean_TFN_cC1-cC1_l))*alpha_cC1
cC1 = cC1_l + np.random.beta (alpha_cC1, beta_cC1)*(cC1_u - cC1_l)
C1 = aC1, bC1, cC1
....
....
for aC7 in aC7_l, aC7_m, aC7_u:
if aC7_l == aC7_m == aC7_u :
mean_TFN_aC7 = aC7_l
stdev_TFN_aC7=0
x_aC7 = 0
y_aC7 = 0
z_aC7 = 0
alpha_aC7 = 0
beta_aC7 = 0
aC7 = aC7_l
else:
mean_TFN_aC7 = (aC7_l + 4*aC7_m + aC7_u)/6.
stdev_TFN_aC7=(aC7_u - aC7_l)/6.
x_aC7 = (mean_TFN_aC7 - aC7_l)/(aC7_u - aC7_l)
y_aC7 = (mean_TFN_aC7 - aC7_l)*(aC7_u - mean_TFN_aC7)/(stdev_TFN_aC7**2)
z_aC7 = y_aC7 - 1
alpha_aC7 = x_aC7 * z_aC7
beta_aC7 = ((aC7_u-mean_TFN_aC7)/(mean_TFN_aC7-aC7_l))*alpha_aC7
aC7 = aC7_l + np.random.beta (alpha_aC7, beta_aC7)*(aC7_u - aC7_l)
for bC7 in bC7_l, bC7_m, bC7_u:
if bC7_l == bC7_m == bC7_u :
mean_TFN_bC7 = bC7_l
stdev_TFN_bC7=0
x_bC7 = 0
y_bC7 = 0
z_bC7 = 0
alpha_bC7 = 0
beta_bC7 = 0
bC7 = bC7_l
else:
mean_TFN_bC7 = (bC7_l + 4*bC7_m + bC7_u)/6.
stdev_TFN_bC7=(bC7_u - bC7_l)/6.
x_bC7 = (mean_TFN_bC7 - bC7_l)/(bC7_u - bC7_l)
y_bC7 = (mean_TFN_bC7 - bC7_l)*(bC7_u - mean_TFN_bC7)/(stdev_TFN_bC7**2)
z_bC7 = y_bC7 - 1
alpha_bC7 = x_bC7 * z_bC7
beta_bC7 = ((bC7_u-mean_TFN_bC7)/(mean_TFN_bC7-bC7_l))*alpha_bC7
bC7 = bC7_l + np.random.beta (alpha_bC7, beta_bC7)*(bC7_u - bC7_l)
for cC7 in cC7_l, cC7_m, cC7_u:
if cC7_l == cC7_m == cC7_u :
mean_TFN_cC7 = cC7_l
stdev_TFN_cC7=0
x_cC7 = 0
y_cC7 = 0
z_cC7 = 0
alpha_cC7 = 0
beta_cC7 = 0
cC7 = cC7_l
else:
mean_TFN_cC7 = (cC7_l + 4*cC7_m + cC7_u)/6.
stdev_TFN_cC7=(cC7_u - cC7_l)/6.
x_cC7 = (mean_TFN_cC7 - cC7_l)/(cC7_u - cC7_l)
y_cC7 = (mean_TFN_cC7 - cC7_l)*(cC7_u - mean_TFN_cC7)/(stdev_TFN_cC7**2)
z_cC7 = y_cC7 - 1
alpha_cC7 = x_cC7 * z_cC7
beta_cC7 = ((cC7_u-mean_TFN_cC7)/(mean_TFN_cC7-cC7_l))*alpha_cC7
cC7 = cC7_l + np.random.beta (alpha_cC7, beta_cC7)*(cC7_u - cC7_l)
C7 = aC7, bC7, cC7
# Normalised each number
Normalised_Defuzz_abc11 = Defuzz_abc11/SumColumn_1
Normalised_Defuzz_abc21 = Defuzz_abc21/SumColumn_1
Normalised_Defuzz_abc31 = Defuzz_abc31/SumColumn_1
Normalised_Defuzz_abc41 = Defuzz_abc41/SumColumn_1
Normalised_Defuzz_abc51 = Defuzz_abc51/SumColumn_1
Normalised_Defuzz_abc61 = Defuzz_abc61/SumColumn_1
Normalised_Defuzz_abc71 = Defuzz_abc71/SumColumn_1
# Normalised eigen vector
Normalised_EV_C1_row = np.mean ([Normalised_Defuzz_abc11, Normalised_Defuzz_abc12, Normalised_Defuzz_abc13, Normalised_Defuzz_abc14, Normalised_Defuzz_abc15, Normalised_Defuzz_abc16, Normalised_Defuzz_abc17])
Normalised_EV_C2_row = np.mean ([Normalised_Defuzz_abc21, Normalised_Defuzz_abc22, Normalised_Defuzz_abc23, Normalised_Defuzz_abc24, Normalised_Defuzz_abc25, Normalised_Defuzz_abc26, Normalised_Defuzz_abc27])
Normalised_EV_C3_row = np.mean ([Normalised_Defuzz_abc31, Normalised_Defuzz_abc32, Normalised_Defuzz_abc33, Normalised_Defuzz_abc34, Normalised_Defuzz_abc35, Normalised_Defuzz_abc36, Normalised_Defuzz_abc37])
Normalised_EV_C4_row = np.mean ([Normalised_Defuzz_abc41, Normalised_Defuzz_abc42, Normalised_Defuzz_abc43, Normalised_Defuzz_abc44, Normalised_Defuzz_abc45, Normalised_Defuzz_abc46, Normalised_Defuzz_abc47])
Normalised_EV_C5_row = np.mean ([Normalised_Defuzz_abc51, Normalised_Defuzz_abc52, Normalised_Defuzz_abc53, Normalised_Defuzz_abc54, Normalised_Defuzz_abc55, Normalised_Defuzz_abc56, Normalised_Defuzz_abc57])
Normalised_EV_C6_row = np.mean ([Normalised_Defuzz_abc61, Normalised_Defuzz_abc62, Normalised_Defuzz_abc63, Normalised_Defuzz_abc64, Normalised_Defuzz_abc65, Normalised_Defuzz_abc66, Normalised_Defuzz_abc67])
Normalised_EV_C7_row = np.mean ([Normalised_Defuzz_abc71, Normalised_Defuzz_abc72, Normalised_Defuzz_abc73, Normalised_Defuzz_abc74, Normalised_Defuzz_abc75, Normalised_Defuzz_abc76, Normalised_Defuzz_abc77])
# Lambda Max
LambdaMax_C1_row = ((Defuzz_abc11*Normalised_EV_C1_row) + (Defuzz_abc12*Normalised_EV_C2_row) + (Defuzz_abc13*Normalised_EV_C3_row) + (Defuzz_abc14*Normalised_EV_C4_row) + (Defuzz_abc15*Normalised_EV_C5_row) + (Defuzz_abc16*Normalised_EV_C6_row) + (Defuzz_abc17*Normalised_EV_C7_row))
LambdaMax_C2_row = ((Defuzz_abc21*Normalised_EV_C1_row) + (Defuzz_abc22*Normalised_EV_C2_row) + (Defuzz_abc23*Normalised_EV_C3_row) + (Defuzz_abc24*Normalised_EV_C4_row) + (Defuzz_abc25*Normalised_EV_C5_row) + (Defuzz_abc26*Normalised_EV_C6_row) + (Defuzz_abc27*Normalised_EV_C7_row))
LambdaMax_C3_row = ((Defuzz_abc31*Normalised_EV_C1_row) + (Defuzz_abc32*Normalised_EV_C2_row) + (Defuzz_abc33*Normalised_EV_C3_row) + (Defuzz_abc34*Normalised_EV_C4_row) + (Defuzz_abc35*Normalised_EV_C5_row) + (Defuzz_abc36*Normalised_EV_C6_row) + (Defuzz_abc37*Normalised_EV_C7_row))
LambdaMax_C4_row = ((Defuzz_abc41*Normalised_EV_C1_row) + (Defuzz_abc42*Normalised_EV_C2_row) + (Defuzz_abc43*Normalised_EV_C3_row) + (Defuzz_abc44*Normalised_EV_C4_row) + (Defuzz_abc45*Normalised_EV_C5_row) + (Defuzz_abc46*Normalised_EV_C6_row) + (Defuzz_abc47*Normalised_EV_C7_row))
LambdaMax_C5_row = ((Defuzz_abc51*Normalised_EV_C1_row) + (Defuzz_abc52*Normalised_EV_C2_row) + (Defuzz_abc53*Normalised_EV_C3_row) + (Defuzz_abc54*Normalised_EV_C4_row) + (Defuzz_abc55*Normalised_EV_C5_row) + (Defuzz_abc56*Normalised_EV_C6_row) + (Defuzz_abc57*Normalised_EV_C7_row))
LambdaMax_C6_row = ((Defuzz_abc61*Normalised_EV_C1_row) + (Defuzz_abc62*Normalised_EV_C2_row) + (Defuzz_abc63*Normalised_EV_C3_row) + (Defuzz_abc64*Normalised_EV_C4_row) + (Defuzz_abc65*Normalised_EV_C5_row) + (Defuzz_abc66*Normalised_EV_C6_row) + (Defuzz_abc67*Normalised_EV_C7_row))
LambdaMax_C7_row = ((Defuzz_abc71*Normalised_EV_C1_row) + (Defuzz_abc72*Normalised_EV_C2_row) + (Defuzz_abc73*Normalised_EV_C3_row) + (Defuzz_abc74*Normalised_EV_C4_row) + (Defuzz_abc75*Normalised_EV_C5_row) + (Defuzz_abc76*Normalised_EV_C6_row) + (Defuzz_abc77*Normalised_EV_C7_row))
SigmaLambdaMax_Criteria = LambdaMax_C1_row + LambdaMax_C2_row + LambdaMax_C3_row + LambdaMax_C4_row + LambdaMax_C5_row + LambdaMax_C6_row + LambdaMax_C7_row
# CI (Consistency index)
CI_Criteria = (SigmaLambdaMax_Criteria - n)/(n - 1)
# Consistency ratio (CR)
CR_Criteria = CI_Criteria/1.32
if CR_Criteria<0.1:
out.append([C1, C2, C3, C4, C5, C6, C7])
out_ = np.array(out)
np.split(out_, 1000)
Выход:
[array([[[ 7.43765179, 8.13324985, 9. ],
[ 1.43976775, 1.79923808, 2.75705364],
[ 1.03884285, 2.09168243, 2.7365122 ],
[ 4.72091356, 5.77347696, 6.91201262],
[ 4.95643637, 5.92541881, 6.98044354],
[ 1.20061286, 2.03949521, 3.37224486],
[ 4.99365134, 5.57395288, 6.55934046]],
[[ 7.03388201, 8.09052845, 9. ],
[ 1.14820751, 1.46403171, 2.61614513],
[ 1.45212553, 2.20342871, 3.02995726],
[ 4.88938879, 5.98671516, 6.94968631],
[ 4.94282521, 5.90376045, 6.85549042],
[ 1.32122987, 1.58344197, 2.59582883],
[ 4.93300843, 5.95128261, 6.9589285 ]],
...
[[ 7.13980001, 8.15115394, 9. ],
[ 1.09635947, 2.0895737 , 2.21398373],
[ 1.13092721, 1.87685383, 3.17487988],
[ 4.94821121, 5.9847158 , 6.89897122],
[ 4.90235029, 5.82901071, 6.93346623],
[ 1.15220439, 2.00236636, 2.96029439],
[ 4.98350366, 5.75874941, 6.54680561]]])]
Используя этот код, когда я запрашиваю C1, я получил только значение C1 в последнем массиве, который я не ожидал (только 1 данные). Когда я запрашиваю aC1, bC1, cC1 и т. Д., Я ожидаю получить aC1, bC1, cC1 в 5000 данных.
Любые советы и предложения будут с благодарностью.