Java代码实现IOWA算子(2020.12.9)

jing_zhong

已于 2023-03-08 14:38:04 修改

阅读量2.5k

点赞数 6

分类专栏： Java后台开发与数据库实践经验 Python与深度学习实践经验文章标签： java idea 算法 python

于 2020-12-09 22:40:03 首次发布

本文链接：https://blog.csdn.net/jing_zhong/article/details/110926774

版权

Python与深度学习实践经验同时被 2 个专栏收录

13 篇文章

订阅专栏

Java后台开发与数据库实践经验

7 篇文章

订阅专栏

本文介绍IOWA算子的基本概念及其实现方法，包括有序加权平均算子OWA和诱导有序加权平均算子IOWA，并提供Java与Python两种语言的实现代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、IOWA简介

        定义1：设 $f_W:R^{m}→R$ 为 $m$ 元函数， $W=(w_1,w_2,...,w_m)^{T}$ 是与 $f_W$ 有关的加权向量，满足 $\sum_{i=1}^{m}w_i=1,w_i≥0，i=1,2,..,m,$ 若 $f_W(a_1,a_2,...,a_m)=\sum_{i=1}^{m}w_ib_i,$ 其中， $b_i$ 是 $a_1,a_2,...,a_m$ 中按从大到小的顺序排列的第 $i$ 个大的数，则称函数 $f_W$ 是 $m$ 维有序加权平均算子，简记为OWA算子。
        例如，设 $w_1=0.3,w_2=0.4,w_3=0.2,w_4=0.1,$ 则按定义1得
                     $f_W(2,4,1,5)=5×0.3+4×0.4+2×0.2+1×0.1=3.6$
        定义2：设 $v_1,a_1>,<v_2,a_2>,...,<v_m,a_m>$ 为 $m$ 个二维数组，令
$f_W(<v_1,a_1>,<v_2,a_2>,...,<v_m,a_m>)=\sum_{i=1}^{m}w_ia_{v-index(i)}$
        则称函数 $f_W$ 是由 $v_1,v_2,...,v_m$ 所产生的 $m$ 维诱导有序加权平均算子，简记为IOWA算子， $v_i$ 称为 $a_i$ 的诱导值。其中 $v - in d e x (i)$ 是 $v_1,v_2,...,v_m$ 中按从大到小的顺序排列的第 $i$ 个大的数的下标， $W=(w_1,w_2,...,w_m)^T$ 是OWA的加权向量，满足 $\sum_{i=1}^{m}w_i=1,w_i≥0，i=1,2,..,m。$
         定义2表明IOWA算子是对又导致 $v_1,v_2,...,v_m$ 按从大到小的顺序排序后所对应的 $a_1,a_2,...,a_m$ 中的数进行有序加权平均， $w_i$ 与数 $a_i$ 的大小和位置无关，而是与其诱导值所在的位置有关。
        例如，设 $< 3, 4 >, < 1, 2 >, < 5, 1 >, < 7, 0 >$ 为4个二维数组，OWA的加权向量为 $w_1=0.3,w2=0.4,w_3=0.2,w_4=0.1,$ 则
$f_W=(<3,4>,<1,2>,<5,1>,<7,0>)=0×0.3+1×0.4+4×0.2+2×0.1=1.4$

2、编程软件IDEA，编程语言Java

Java类OWA有owa和iowa两个私有成员函数，分别对应OWA算子和IOWA算子。

public class OWA
{
    private double owa(double[] w,double[] a)//有序加权平均算子OWA
    {
        int length = a.length;
        String fwstring = "fw(";
        for(int i=0;i<length;i++)
        {
            if(i==length -1) fwstring +=(a[i]+")=");
            else fwstring +=(a[i]+",");
        }
        for(int i=0;i<length;i++)//首先将数组a从大到小排列
        {
            for(int j=i+1;j<length;j++)
            {
                if(a[j]>a[i])
                {
                    a[j] +=a[i];
                    a[i]=a[j]-a[i];
                    a[j]=a[j]-a[i];
                }
            }
        }
        double fw=0;
        if(length == w.length)//判断w、a两个数组长度是否相同
        {
            for(int i=0;i<length;i++)
                fw +=w[i]*a[i];
            for(int i=0;i<length;i++)
            {
                if(i == length-1) fwstring += w[i]+"*"+a[i]+"=";
                else fwstring += w[i]+"*"+a[i]+"+";
            }
            fwstring += fw;
        }
        System.out.println(fwstring);
        return fw;
    }
    private double iowa(double[] w,double[] v,double[] a)//诱导有序加权平均算子IOWA
    {
        int length = a.length;
        String fwstring = "fw(";
        int[] v_index = new int[length];
        for(int i=0;i<length;i++)
            v_index[i]=i;//初始化索引数组
        if(v.length == length)
        {
            for(int i=0;i<length;i++)
            {
                if(i==length -1) fwstring += "("+v[i]+","+a[i]+"))=";
                else fwstring += "("+v[i]+","+a[i]+"),";
            }
            for(int i=0;i<length;i++)//首先将数组v从大到小排列,为了给v_index按照v从大到小寻找对应索引
            {
                for(int j=i+1;j<length;j++)
                {
                    if(v[j]>v[i])
                    {
                        v[j] +=v[i];
                        v[i]=v[j]-v[i];
                        v[j]=v[j]-v[i];
                        v_index[j] +=v_index[i];
                        v_index[i]=v_index[j]-v_index[i];
                        v_index[j]=v_index[j]-v_index[i];
                    }
                }
            }
        }
        double fw=0;
        if(length == w.length)//判断a、w两个数组长度是否相同
        {
            for(int i=0;i<length;i++)
                fw +=w[i]*a[v_index[i]];
            for(int i=0;i<length;i++)
            {
                if(i == length-1) fwstring += w[i]+"*"+a[v_index[i]]+"=";
                else fwstring += w[i]+"*"+a[v_index[i]]+"+";
            }
            fwstring += fw;
        }
        System.out.println(fwstring);
        return fw;
    }
    public static void main(String[] args)
    {
        double[] W={0.3,0.4,0.2,0.1},A={2,4,1,5},V={3,1,5,7},A1={4,2,1,0};
        OWA o = new OWA();
        System.out.println("有序加权平均算子计算结果："+o.owa(W,A));
        System.out.println("迭代有序加权平均算子计算结果："+o.iowa(W,V,A1));
    }
}

3、Java代码运行结果（OWA和IOWA）

在这里插入图片描述

4、编程软件IDLE，编程语言Python

Python类IOWA有owa和iowa两个私有成员函数，分别对应OWA算子和IOWA算子。

# coding=utf8

class IOWA:

    def __init__(self):
        self.data = []

    def owa(self,w,a):
        length = len(a);
        fwstring = 'fw('
        for i in range(0,length):
            if i == (length -1):
                fwstring += str(a[i]) + ')='
            else:
                fwstring += str(a[i]) + ','
        for i in range(0,length):
            for j in range(i+1,length):
                if a[j] > a[i]:
                    a[j] += a[i]
                    a[i] = a[j] - a[i]
                    a[j] = a[j]- a[i]
        fw = 0
        if length == len(w):
            for i in range(0,length):
                fw += w[i] * a[i]
            for i in range(0,length):
                if i == (length - 1):
                    fwstring += str(w[i]) + '*' + str(a[i]) + '='
                else:
                    fwstring += str(w[i]) + '*' + str(a[i]) + '+'
            fwstring += str(fw)
        print(fwstring)
        return fw

    def iowa(self,w,v,a):
        length = len(a)
        fwstring = 'fw('
        v_index = list(range(0,length))
        if(len(v) == length):
            for i in range(0,length):
                if i == (length - 1):
                    fwstring += '(' + str(v[i]) + ',' + str(a[i]) +'))='
                else:
                    fwstring += '(' + str(v[i]) + ',' + str(a[i]) + '),'
            for i in range(0,length):
                for j in range(i+1,length):
                    if v[j] > v[i]:
                        v[j] += v[i];
                        v[i] = v[j] - v[i]
                        v[j] = v[j] - v[i]
                        v_index[j] += v_index[i]
                        v_index[i] = v_index[j] - v_index[i]
                        v_index[j] = v_index[j] - v_index[i]
            fw = 0
            if length == len(w):
                for i in range(0,length):
                    fw += w[i] * a[v_index[i]]
                for i in range(0,length):
                    if i == (length -1):
                        fwstring += str(w[i]) + '*' + str(a[v_index[i]]) + '='
                    else:
                        fwstring += str(w[i]) + '*' + str(a[v_index[i]]) + '+'
                fwstring += str(fw)
            print(fwstring)
            return fw

if __name__ == "__main__" :
    W=[0.3,0.4,0.2,0.1]
    A=[2,4,1,5]
    V=[3,1,5,7]
    A1=[4,2,1,0]
    o = IOWA()
    print('有序加权平均算子计算结果：'+ str(o.owa(W,A)))
    print('迭代有序加权平均算子计算结果：' + str(o.iowa(W,V,A1)))