怎样循环使用topsis法

回答：TOPSIS法通常是一种比较理想解决方案的方法，它可以通过将数据与理想解决方案进行比较，从而寻求最佳解决方案。它的循环使用方法包括：1）确定指标和属性；2）计算理想解决方案的指标值；3）计算当前指标值的可行解决方案；4）比较可行解决方案与理想解决方案的指标值；5）确定最优解决方案；6）根据最优解决方案更新指标和属性；7）重复上述步骤，直到最优解决方案不再改变。

相关问题

用嵌套for循环解topsis法，用两个属性六个方案的例题举例

好的，假设我们有以下两个属性和六个方案的数据：

| 方案 | 属性1 | 属性2 |
| ---- | ---- | ---- |
| A | 5 | 4 |
| B | 3 | 5 |
| C | 4 | 4 |
| D | 2 | 3 |
| E | 1 | 2 |
| F | 4 | 2 |

接下来，我们将使用 Python 编写嵌套 for 循环来实现 TOPSIS 方法。

首先，我们需要计算每个方案的加权属性值。假设我们已经有了属性权重向量 W = [0.6, 0.4]。我们可以使用以下代码计算加权属性值：

data = [
    [5, 4],
    [3, 5],
    [4, 4],
    [2, 3],
    [1, 2],
    [4, 2]
]

W = [0.6, 0.4]

weighted_data = []
for i in range(len(data)):
    weighted_values = []
    for j in range(len(data[i])):
        weighted_values.append(data[i][j] * W[j])
    weighted_data.append(weighted_values)

print(weighted_data)

这将输出以下加权属性值矩阵：

[[3.0, 1.6], [1.8, 2.0], [2.4, 1.6], [1.2, 1.2], [0.6, 0.8], [2.4, 0.8]]

接下来，我们需要计算正理想解和负理想解。为了计算正理想解，我们需要找到每个属性的最大值。为了计算负理想解，我们需要找到每个属性的最小值。我们可以使用以下代码来实现：

max_values = []
min_values = []

for j in range(len(weighted_data[0])):
    column_values = [row[j] for row in weighted_data]
    max_values.append(max(column_values))
    min_values.append(min(column_values))

print(max_values)
print(min_values)

这将输出以下最大值和最小值：

[3.0, 2.0]
[0.6, 0.8]

接下来，我们需要计算每个方案到正理想解和负理想解的欧几里得距离。我们可以使用以下代码来计算：

def euclidean_distance(x, y):
    return ((x[0] - y[0])**2 + (x[1] - y[1])**2)**0.5

ideal_solutions = [max_values, min_values]

distances = []
for i in range(len(weighted_data)):
    ideal_distances = []
    for ideal_solution in ideal_solutions:
        ideal_distances.append(euclidean_distance(weighted_data[i], ideal_solution))
    distances.append(ideal_distances)

print(distances)

这将输出以下到正理想解和负理想解的距离：

[[0.6928203230275509, 1.215521786297726], [1.0594192100630734, 0.9486832980505138], [0.848528137423857, 1.0430818622278332], [1.4518275238721992, 1.4866068747318506], [2.122065907891869, 2.0420577856662066], [1.7898278523641797, 1.5811388300841898]]

最后，我们需要计算每个方案的 TOPSIS 得分。我们可以使用以下代码来计算得分：

positive_distances = [d[0] for d in distances]
negative_distances = [d[1] for d in distances]

performance_scores = []
for i in range(len(positive_distances)):
    score = negative_distances[i] / (positive_distances[i] + negative_distances[i])
    performance_scores.append(score)

print(performance_scores)

这将输出以下得分：

[0.6372921774800655, 0.44304943385144934, 0.5515050173615486, 0.7219317456955007, 0.6581859574038774, 0.4691462298597368]

因此，在此示例中，方案 D 获得了最高的 TOPSIS 得分，因为它在到负理想解的距离上得分最低，同时在到正理想解的距离上得分相对较高。

用嵌套for循环解topsis法 计算有两个属性六个方案的例题Matlab语言

假设有两个属性 A 和 B，六个方案 S1-S6，它们的属性值如下：

| | A | B |
|----|----|----|
| S1 | 3 | 7 |
| S2 | 4 | 6 |
| S3 | 9 | 4 |
| S4 | 2 | 8 |
| S5 | 8 | 3 |
| S6 | 5 | 5 |

步骤1：标准化矩阵

首先需要对矩阵进行标准化处理，使得每个属性的权重为1，即每个属性的平均值为1。标准化后的矩阵如下：

A = [3 4 9 2 8 5];
B = [7 6 4 8 3 5];

% 计算归一化矩阵
A_norm = A ./ sqrt(sum(A.^2));
B_norm = B ./ sqrt(sum(B.^2));

% 计算加权归一化矩阵
w1 = 0.6;
w2 = 0.4;
A_w = A_norm * w1;
B_w = B_norm * w2;

% 组合成加权归一化矩阵
X = [A_w; B_w];

步骤2：计算正向和负向理想解

接下来需要计算正向和负向理想解，可以用下面的代码实现：

% 计算正向理想解
max_A_w = max(A_w);
max_B_w = max(B_w);
ideal_pos = [max_A_w; max_B_w];

% 计算负向理想解
min_A_w = min(A_w);
min_B_w = min(B_w);
ideal_neg = [min_A_w; min_B_w];

步骤3：计算每个方案到正向理想解和负向理想解的距离

通过欧几里得距离计算每个方案到正向理想解和负向理想解的距离：

% 计算每个方案到正向和负向理想解的距离
pos_dist = sqrt(sum((X - ideal_pos).^2));
neg_dist = sqrt(sum((X - ideal_neg).^2));

步骤4：计算综合得分

最后需要计算每个方案的综合得分，综合得分越高，说明该方案越优。综合得分的计算公式为：

$$score_i=\frac{neg\_dist_i}{pos\_dist_i+neg\_dist_i}$$

% 计算综合得分
score = neg_dist ./ (pos_dist + neg_dist);

完整代码如下：

% 假设有两个属性A和B，六个方案S1-S6
A = [3 4 9 2 8 5];
B = [7 6 4 8 3 5];

% 计算归一化矩阵
A_norm = A ./ sqrt(sum(A.^2));
B_norm = B ./ sqrt(sum(B.^2));

% 计算加权归一化矩阵
w1 = 0.6;
w2 = 0.4;
A_w = A_norm * w1;
B_w = B_norm * w2;

% 组合成加权归一化矩阵
X = [A_w; B_w];

% 计算正向理想解
max_A_w = max(A_w);
max_B_w = max(B_w);
ideal_pos = [max_A_w; max_B_w];

% 计算负向理想解
min_A_w = min(A_w);
min_B_w = min(B_w);
ideal_neg = [min_A_w; min_B_w];

% 计算每个方案到正向和负向理想解的距离
pos_dist = sqrt(sum((X - ideal_pos).^2));
neg_dist = sqrt(sum((X - ideal_neg).^2));

% 计算综合得分
score = neg_dist ./ (pos_dist + neg_dist);