精华内容
下载资源
问答
  • 关系的合成运算
    千次阅读
    2020-12-10 09:24:06

    离散数学 关系运算代码(c++)

    包含以下功能:
    1.求有限集上给定关系的自反闭包、对称闭包、传递闭包。
    2.求有限集上等价关系的数目。
    3.输入集合和等价关系,求对应的商集。
    4.判断是否为等价关系。

    Relation.h

    #ifndef RELATION_H_INCLUDED
    #define RELATION_H_INCLUDED
    #include<string.h>
    using namespace std;
    struct Relation
    {
        bool **Mat;  //存放关系矩矩阵
        string *Arr;  //存放元素集合
        int n;  //存放元素个数
    };
    void InitRelation(Relation &R,int n)  //初始化关系矩阵
    {
        R.n=n;
        R.Arr=new string[n];
        R.Mat=new bool *[n];
        for(int j=0;j<n;j++)
        {
           R.Mat[j]=new bool[n];
           for(int k=0;k<n;k++)
            R.Mat[j][k]=false;
        }
    }
    void Show(Relation R)  //输出关系矩阵
    {
        cout<<'{';
        for(int i=0;i<R.n-1;i++)
            cout<<R.Arr[i]<<", ";
        cout<<R.Arr[R.n-1]<<'}'<<endl;
        for(int i=0;i<R.n;i++)
        {
            for(int j=0;j<R.n;j++)
                cout<<R.Mat[i][j];
            cout<<endl;
        }
    }
    int Locate(Relation R,string str) //寻找目标元素在集合中的位置
    {
        for(int i=0;i<R.n;i++)
        {
            if(str==R.Arr[i])
                return i;
        }
        return -1;
    }
    void CreateRelation(Relation &R) //输入关系
    {
        string a,b;
        cout<<"请输入各元素"<<endl;
        for(int i=0;i<R.n;i++)
            cin>>R.Arr[i];
        cout<<"请给定各元素之间关系,以# #结束"<<endl;
        cin>>a>>b;
        while(a!="#"||b!="#")
        {
            int i,j;
            i=Locate(R,a);
            j=Locate(R,b);
            if(i<0||j<0)
                cout<<"元素不合法,请检查!"<<endl;
            else
                R.Mat[i][j]=true;
            cin>>a>>b;
        }
    
    }
    Relation ReflexiveClosure(Relation &R)   //求自反闭包
    {
        Relation S;
        InitRelation(S,R.n);
        for(int i=0;i<R.n;i++)
        {
            S.Arr[i]=R.Arr[i];
            for(int j=0;j<R.n;j++)
                S.Mat[i][j]=R.Mat[i][j];
        }
        for(int i=0;i<S.n;i++)
            S.Mat[i][i]=true;
        return S;
    }
    Relation SymmetricClosure(Relation &R)  //求对称闭包
    {
        Relation S;
        InitRelation(S,R.n);
        for(int i=0;i<R.n;i++)
        {
            S.Arr[i]=R.Arr[i];
            for(int j=0;j<R.n;j++)
                S.Mat[i][j]=R.Mat[i][j];
        }
        for(int i=0;i<S.n;i++)
        {
            for(int j=i;j<S.n;j++)
            {
                if(S.Mat[i][j]==true)
                    S.Mat[j][i]=true;
            }
        }
        return S;
    }
    Relation TransitiveClosure(Relation &R)  //求传递闭包
    {
        Relation S;
        InitRelation(S,R.n);
        for(int i=0;i<R.n;i++)
        {
            S.Arr[i]=R.Arr[i];
            for(int j=0;j<R.n;j++)
                S.Mat[i][j]=R.Mat[i][j];
        }
        for(int i=0;i<S.n;i++)
        {
            for(int j=0;j<S.n;j++)
            {
                if(S.Mat[i][j]==true)
                {
                    for(int k=0;k<S.n;k++)
                    {
                        if(S.Mat[j][k]==true)
                            S.Mat[i][k]=true;
                    }
                }
            }
        }
        return S;
    }
    int NumOfEquivalent(int n)  //求等价关系数
    {
        int a[n+1][n+1];
        int sum=0;
        for(int i=1;i<=n;i++)
        {
            a[1][i]=1;
            a[i][i]=1;
        }
        for(int i=2;i<=n;i++)
        {
            for(int j=i+1;j<=n;j++)
                a[i][j]=a[i-1][j-1]+i*a[i][j-1];
        }
       for(int i=1;i<=n;i++)
        sum+=a[i][n];
        return sum;
    }
    bool isReflexive(Relation R)  //验证自反性
    {
        for(int i=0;i<R.n;i++)
        {
            if(R.Mat[i][i]!=true)
                return  false;
        }
        return true;
    }
    bool isSymmetric(Relation R)  //验证对称性
    {
        for(int i=0;i<R.n;i++)
        {
            for(int j=i+1;i<R.n;j++)
            {
                if(R.Mat[i][j]!=R.Mat[j][i])
                return false;
            }
        }
        return true;
    }
    bool isTreansitive(Relation R)  //验证传递性
    {
        for(int i=0;i<R.n;i++)
        {
            for(int j=0;j<R.n;j++)
            {
                if(R.Mat[i][j]==1)
                {
                    for(int k=0;k<R.n;k++)
                    {
                        if((R.Mat[j][k]==1&&R.Mat[i][k]==1)==false)
                            return false;
                    }
                }
            }
        }
        return true;
    }
    
    void QuotientSet(Relation R)  //根据集合与关系求商集
    {
        bool visited[R.n];
        for(int i=0;i<R.n;i++)
            visited[i]=false;
        if(isReflexive(R)==false&&isSymmetric(R)==false&&isTreansitive(R)==false)
        {
            cout<<"您输入的不是等价关系!"<<endl;
            return;
        }
        else
        {
            cout<<"商集为: "<<"{";
            for(int i=0;i<R.n;i++)
            {
                if(visited[i]==false)
                {
                    visited[i]=true;
                cout<<"{";
                cout<<R.Arr[i];
                for(int j=0;j<R.n;j++)
                {
                    if(R.Mat[i][j]==1&&visited[j]==false)
                    {
                        visited[j]=true;
                        cout<<","<<R.Arr[j];
                    }
                }
                cout<<"}";
                }
            }
            cout<<"}";
        }
    }
    #endif // RELATION_H_INCLUDED
    
    

    Main.cpp

    #include <iostream>
    #include "Relation.h"
    using namespace std;
    
    int main()
    {
        Relation A;
        cout<<"请输入元素个数"<<endl;
        int n;
        cin>>n;
        InitRelation(A,n);
        cout<<"该集合有"<<NumOfEquivalent(n)<<"种等价关系"<<endl;
        CreateRelation(A);
        Show(A);
        Show(TransitiveClosure(A));
        Show(ReflexiveClosure(A));
        Show(SymmetricClosure(A));
        QuotientSet(A);
    }
    
    
    更多相关内容
  • 模糊关系合成运算的Matlab实现

    千次阅读 2020-03-23 21:03:55
    那么首先要编程的就是如何算模糊矩阵乘法,也叫模糊矩阵合成运算,算法是“先取小后取大”。用max()函数,min()函数就能搞定,最后再根据矩阵运算规则。于是有 function [R]=fuzzymm(A,B) %模糊矩阵合成运算(模糊...

    最近课程学到模糊数学,里面有关于模糊关系合成运算传递闭包的概念,十分不好理解,本来想手算几个例子来理解的,结果算到一半就烦了还十分容易算错,于是我就打算用matlab编写一个。

    这里就不讲什么是模糊关系合成运算了。百度上能搜到的我这里就不赘述了,网上也有很多关于传递闭包的解释,都比较通俗易懂。我看到教材求传递闭包的方法就是模糊矩阵反复自乘,当结果t(.R)不改变的时候即为传递闭包的值。

    那么首先要编程的就是如何算模糊关系合成运算,也有人称为模糊矩阵乘积,算法是“先取小后取大”。用max()函数,min()函数就能搞定,最后再根据矩阵运算规则。于是有

    function [R]=fuzzymm(A,B)
    %模糊矩阵合成运算的Matlab实现
    %运算规则,先"取小后取大"
    %输入必须为二阶矩阵A为m行n列, B为n行p列;
    [m,n]=size(A);[q,p]=size(B);%获得输入矩阵的维度信息
    if n~=q
        disp('第一个矩阵的列数和第二个矩阵的行数不相同!');
    else
        R=zeros(m,p);%初始化矩阵
    for k =1:m    
        for j=1:p
            temp=[];
            for i =1:n
                Min = min(A(k,i),B(i,j)); %求出第i对的最小值
                temp=[temp Min]; %将求出的最小值加入的数组中
            end
            R(k,j)=max(temp);
        end
    end
    end
    end
    

    我们来测试一下

    clc
    clear all;
    A=[0.3 0.7 0.2;1,0,0.4;0,0.5,1;0.6,0.7,0.8];
    B=[0.1,0.9;0.9,0.1;0.6,0.4];
    [R]=fuzzymm(A,B);
    disp(R)
    

    得到的结果

        0.7000    0.3000
        0.4000    0.9000
        0.6000    0.4000
        0.7000    0.6000
    

    结果正确!
    那么求传递闭包的只需将传入的矩阵设为相同就可以了!
    那么模糊相似矩阵的传递闭包怎么求呢,只需要反复调用函数,当结果不改变时,即为该模糊相似矩阵的传递闭包。
    例如:
    [1 0.1 0.8 0.5 0.3;
    0.1 1 0.1 0.2 0.4;
    0.8 0.1 1 0.3 0.1;
    0.5 0.2 0.3 1 0.6;
    0.3 0.4 0.1 0.6 1]

    clc
    clear all
    R=[1 0.1 0.8 0.5 0.3;0.1 1 0.1 0.2 0.4;0.8 0.1 1 0.3 0.1;0.5 0.2 0.3 1 0.6;0.3 0.4 0.1 0.6 1];
    [tR]=fuzzymm(R,R)
    

    于是有
    如图
    再次相乘
    如图
    再次相乘,发现结果不改变
    如图
    故求得传递闭包

    展开全文
  • 揭示了直觉模糊关系的自反性、对称性及传递性,证明了直觉模糊关系合成运算的结合律定理.把Atanassov算子对于直觉模糊关系性质的影响,即对于自反性、对称性、逆对称性、完全逆对称性及传递性等性质的影响,归纳为该...
  • 一、逆运算示例 、 二、合成运算示例 ( 逆序合成 ) 、 三、限制运算示例 、 四、像运算示例 、





    一、逆运算示例



    A = { a , b , c , d } A = \{ a, b, c, d \} A={a,b,c,d}

    B = { a , b , < c , d > } B = \{ a, b, <c, d> \} B={a,b,<c,d>}

    C = { < a , b > , < c , d > } C = \{ <a, b> , <c, d> \} C={<a,b>,<c,d>}

    求上述集合的逆运算


    求逆运算只能针对于 有序对 进行 , 如果没有有序对 , 就没有关系运算的概念 ;


    A A A 集合中没有有序对 , 因此没有关系运算的概念 , 对其求逆运算 , 结果是空集合 ;

    A − 1 = ∅ A^{-1} = \varnothing A1=


    B B B 集合中 有 有序对 < c , d > <c, d> <c,d> , 其逆运算就是求所有有序对的逆 ;

    B − 1 = { < d , c > } B^{-1} = \{ <d, c> \} B1={<d,c>}


    C C C 集合中 有 有序对 < a , b > , < c , d > <a,b> , <c, d> <a,b>,<c,d> , 其逆运算就是求所有有序对的逆 ;

    C − 1 = { < b , a > , < d , c > } C^{-1} = \{ <b,a> , <d, c> \} C1={<b,a>,<d,c>}





    二、合成运算示例 ( 逆序合成 )



    B = { a , b , < c , d > } B = \{ a, b , <c,d> \} B={a,b,<c,d>}

    R = { < a , b > , < c , d > } R = \{ <a,b> , <c,d> \} R={<a,b>,<c,d>}

    G = { < b , e > , < d , c > } G = \{ <b, e> , <d, c> \} G={<b,e>,<d,c>}


    求以下的合成运算结果 , 这里的 合成 指的是 逆序合成


    B o R − 1 B o R^{-1} BoR1

    R − 1 = { < b , a > , < d , c > } R^{-1} = \{ <b,a> , <d,c> \} R1={<b,a>,<d,c>}

    B o R − 1 = { < c , d > } o { < b , a > , < d , c > } = { < d , d > } B o R^{-1} = \{ <c, d> \} o \{ <b,a> , <d,c> \} = \{ <d, d> \} BoR1={<c,d>}o{<b,a>,<d,c>}={<d,d>}

    合成 默认是 逆序合成


    G o B G o B GoB

    G o B = { < b , e > , < d , c > } o { < c , d > } = { < c , c > } G o B = \{<b,e>, <d, c>\} o \{ <c,d> \} = \{ <c,c> \} GoB={<b,e>,<d,c>}o{<c,d>}={<c,c>}


    G o R G o R GoR

    G o R = { < b , e > , < d , c > } o { < a , b > , < c , d > } = { < a , e > , < c , c > } G o R =\{<b,e>, <d, c>\} o \{ <a,b> , <c,d> \} = \{ <a,e>, <c,c> \} GoR={<b,e>,<d,c>}o{<a,b>,<c,d>}={<a,e>,<c,c>}


    R o G R o G RoG

    R o G = { < a , b > , < c , d > } o { < b , e > , < d , c > } = { < d , d > } R o G =\{ <a,b> , <c,d> \} o \{<b,e>, <d, c>\} = \{ <d,d> \} RoG={<a,b>,<c,d>}o{<b,e>,<d,c>}={<d,d>}





    三、限制运算示例



    F = { < a , b > , < a , { a } > , < { a } , { a , { a } } > } F = \{ <a,b> , <a, \{a\}> , <\{a\} , \{a, \{a\}\}> \} F={<a,b>,<a,{a}>,<{a},{a,{a}}>}


    参考 : 【集合论】二元关系 ( 定义域 | 值域 | 域 | 逆运算 | 逆序合成运算 | 限制 | 像 | 单根 | 单值 | 合成运算的性质 ) 五、关系的限制


    1. 求 F ↾ { a } F \upharpoonright \{a\} F{a}

    F F F 集合中的有序对 , 第一个元素是 { a } \{a\} {a} 集合中的元素的有序对 , 这些有序对组成的集合就是 F F F 集合 在 { a } \{a\} {a} 集合上的限制 ;

    F ↾ { a } = { < a , b > , < a , { a } > } F \upharpoonright \{a\} = \{ <a,b> , <a, \{a\}> \} F{a}={<a,b>,<a,{a}>}


    2. 求 F ↾ { { a } } F \upharpoonright \{\{a\}\} F{{a}}

    F F F 集合中的有序对 , 第一个元素是 { { a } } \{\{a\}\} {{a}} 集合中的元素的有序对 , { { a } } \{\{a\}\} {{a}} 集合中的元素是 { a } \{a\} {a} , 这些有序对组成的集合就是 F F F 集合 在 { { a } } \{\{a\}\} {{a}} 集合上的限制 ;

    F ↾ { { a } } = { < { a , { a } } > } F \upharpoonright \{\{a\}\} = \{ <\{a, \{a\}\}> \} F{{a}}={<{a,{a}}>}


    3. 求 F ↾ { a , { a } } F \upharpoonright \{a, \{a\}\} F{a,{a}}

    F F F 集合中的有序对 , 第一个元素是 { a , { a } } \{a, \{a\}\} {a,{a}} 集合中的元素 的有序对 , 这些有序对组成的集合就是 F F F 集合 在 { a , { a } } \{a, \{a\}\} {a,{a}} 集合上的限制 ;

    F ↾ { a , { a } } = { < a , b > , < a , { a } > , < { a } , { a , { a } } > } F \upharpoonright \{a, \{a\}\} = \{ <a,b> , <a, \{a\}> , <\{a\} , \{a, \{a\}\}> \} F{a,{a}}={<a,b>,<a,{a}>,<{a},{a,{a}}>}


    4. 求 F − 1 ↾ { { a } } F^{-1} \upharpoonright \{\{a\}\} F1{{a}}

    F − 1 = { < b , a > , < { a } , a > , < { a , { a } } , { a } > } F^{-1} = \{ <b, a> , <\{a\}, a> , <\{a, \{a\}\}, \{a\} > \} F1={<b,a>,<{a},a>,<{a,{a}},{a}>}

    F − 1 F^{-1} F1 集合中的有序对 , 第一个元素是 { { a } } \{\{a\}\} {{a}} 集合中的元素 的有序对 , 这些有序对组成的集合就是 F − 1 F^{-1} F1 集合 在 { { a } } \{\{a\}\} {{a}} 集合上的限制 ;

    F − 1 ↾ { { a } } = { < { a } , a > } F^{-1} \upharpoonright \{\{a\}\} = \{ <\{a\}, a> \} F1{{a}}={<{a},a>}





    四、像运算示例



    F = { < a , b > , < a , { a } > , < { a } , { a , { a } } > } F = \{ <a, b> , <a, \{ a \}> , <\{ a \} , \{ a, \{a\} \}> \} F={<a,b>,<a,{a}>,<{a},{a,{a}}>}


    参考 : 【集合论】二元关系 ( 定义域 | 值域 | 域 | 逆运算 | 逆序合成运算 | 限制 | 像 | 单根 | 单值 | 合成运算的性质 ) 六、关系的象

    F F F 集合在 A A A 集合的像 , 是 F F F 集合在 A A A 集合上限制的 值域 ;


    1. F [ { a } ] F[\{a\}] F[{a}]

    F F F 集合在 { a } \{a\} {a} 集合上的像 , 是 F F F 集合在 { a } \{a\} {a} 集合上的限制的值域 , F F F 集合在 { a } \{a\} {a} 集合上的限制是 { < a , b > , < a , { a } > } \{ <a, b> , <a, \{ a \}> \} {<a,b>,<a,{a}>} , 对应的 F F F 集合在 { a } \{a\} {a} 集合上的像是 { b , { a } } \{ b, \{a\} \} {b,{a}}

    F [ { a } ] = { b , { a } } F[\{a\}] = \{ b, \{a\} \} F[{a}]={b,{a}}


    2. F [ { a , { a } } ] F[\{a, \{a\}\}] F[{a,{a}}]

    F F F 集合在 { a , { a } } \{a, \{a\}\} {a,{a}} 集合上的像 , 是 F F F 集合在 { a , { a } } \{a, \{a\}\} {a,{a}} 集合上的限制的值域 , F F F 集合在 { a , { a } } \{a, \{a\}\} {a,{a}} 集合上的限制是 { < a , b > , < a , { a } > , < { a } , { a , { a } } > } \{ <a, b> , <a, \{ a \}> , <\{ a \} , \{ a, \{a\} \}> \} {<a,b>,<a,{a}>,<{a},{a,{a}}>} , 对应的 F F F 集合在 { a , { a } } \{a, \{a\}\} {a,{a}} 集合上的像是 { b , { a } , { a , { a } } \{ b, \{a\} , \{ a, \{a\} \} {b,{a},{a,{a}}

    F [ { a , { a } } ] = { b , { a } , { a , { a } } F[\{a, \{a\}\}] = \{ b, \{a\} , \{ a, \{a\} \} F[{a,{a}}]={b,{a},{a,{a}}


    3. F − 1 [ { a } ] F^{-1}[\{a\}] F1[{a}]

    F − 1 = { < b , a > , < { a } , a > , < { a , { a } } , { a } > } F^{-1} = \{ <b, a> , <\{a\}, a> , <\{a, \{a\}\}, \{a\} > \} F1={<b,a>,<{a},a>,<{a,{a}},{a}>}

    F − 1 F^{-1} F1 集合在 { a } \{a\} {a} 集合上的像 , 是 F − 1 F^{-1} F1 集合在 { a } \{a\} {a} 集合上的限制的值域 , F − 1 F^{-1} F1 集合在 { a } \{a\} {a} 集合上的限制是 ∅ \varnothing , 对应的 F − 1 F^{-1} F1 集合在 { a } \{a\} {a} 集合上的像是 ∅ \varnothing

    F − 1 [ { a } ] = ∅ F^{-1}[\{a\}] = \varnothing F1[{a}]=


    4. F − 1 [ { { a } } ] F^{-1}[\{ \{a\} \}] F1[{{a}}]

    F − 1 = { < b , a > , < { a } , a > , < { a , { a } } , { a } > } F^{-1} = \{ <b, a> , <\{a\}, a> , <\{a, \{a\}\}, \{a\} > \} F1={<b,a>,<{a},a>,<{a,{a}},{a}>}

    F − 1 F^{-1} F1 集合在 { { a } } \{ \{a\} \} {{a}} 集合上的像 , 是 F − 1 F^{-1} F1 集合在 { { a } } \{ \{a\} \} {{a}} 集合上的限制的值域 , F − 1 F^{-1} F1 集合在 { { a } } \{ \{a\} \} {{a}} 集合上的限制是 < { a } , a > <\{a\}, a> <{a},a> , 对应的 F − 1 F^{-1} F1 集合在 { { a } } \{ \{a\} \} {{a}} 集合上的像是 { a } \{a\} {a}

    F − 1 [ { { a } } ] = { a } F^{-1}[\{ \{a\} \}] = \{a\} F1[{{a}}]={a}

    展开全文
  • 4.2 关系运算 1.关系的集合运算 上一章提到了,关系本身也是一种集合,所以其可以进行集合的基本运算。 2.关系的逆运算 ...3.关系合成运算 写一大堆也不好理解,简单说就是: 先R后S(将R最后一...

    4.2 关系运算

    1.关系的集合运算
    上一节提到了,关系本身也是一种集合,所以其可以进行集合的基本运算。
    1
    2.关系的逆运算
    2

    例:
    3
    解:
    在这里插入图片描述
    在这里插入图片描述
    可见这两个矩阵互为转置矩阵。
    由上述例题我们可以总结出以下几个性质:
    在这里插入图片描述
    对于逆关系我们还有如下性质:
    在这里插入图片描述
    还记得我们之前说的命题演算法吗?这里我们用命题演算法来证明第二条性质:
    在这里插入图片描述

    3.关系的合成运算
    在这里插入图片描述
    写一大堆也不好理解,简单说就是:
    先R后S(将R最后一项与S的第一项进行合并)

    例:
    在这里插入图片描述
    关系的合成运算是符合结合律的,下面我们还用命题演算来证明:
    在这里插入图片描述
    关系运算的分配律比较特殊,请看:
    在这里插入图片描述
    由此可见:合成运算对于并运算是可分配的,但对交运算分配以后得到的是不等式(一个包含关系)

    这是因为,我们把他拆开最前面是存在量词 ∃ \exists ,之前我们也提到了,存在量词把并运算 ∧ \wedge 展开后得到的是一个包含关系。

    说严谨一点就要用到我们之前讲到的量词分配律。
    如下:
    在这里插入图片描述
    合成运算有如下性质:
    在这里插入图片描述
    在这里插入图片描述

    既然是合成运算那么就不止两个关系来合成:
    在这里插入图片描述
    以下是其一些性质:
    在这里插入图片描述
    例:
    在这里插入图片描述
    由此可见:
    在这里插入图片描述
    下边我们来用关系矩阵的乘法来求合成运算的结果
    例:
    在这里插入图片描述
    因为R的列数不等于S的行数,所以这里我们将 M R M_R MR矩阵进行了扩展。
    接下来我们将他们的关系矩阵进行乘法操作:
    在这里插入图片描述
    注意:这里的行序号是1,2,3。列序号是1,2,3,5。

    综上可知:
    S ∘ \circ R = {(1,5) , (2,5), (3,2)}

    练习1:
    在这里插入图片描述
    在这里插入图片描述
    正确答案: A

    解析:
    对于 S − 1 S^{-1} S1,我们只需把(x,y)变成(y,x)即可。不需要把里面的关系再换位置,否则相当于没转换。

    练习2:
    设A = {a,b,c,d} , R为A上的关系,R={(a,a),(a,b),(b,d),(c,d)}, R 2 R^2 R2为()?
    在这里插入图片描述

    展开全文
  • Vague关系及其扩展合成运算,赵法信,马宗民,Vague关系作为模糊关系的一种推广,具有比模糊关系更强大的模糊信息表达能力。基于Vague集理论,系统研究了Vague关系及其合成运算。引
  • 模糊关系与模糊矩阵及其运算
  • 一、关系的定义域、值域、域 、 二、关系的定义域、值域、域 示例 、 三、关系的逆运算 、 四、关系的逆序合成运算 、 五、关系的限制 、 六、关系的象 、 七、单根 、 八、单值
  • 一、关系运算 、 二、关系运算示例 、 三、关系运算性质
  • 下载 实验3 关系运算设计 一实验目的 熟悉笛卡儿积关系复合运算关系的自反闭包对称闭包和传递闭包的概念并编程设计求其运算 二实验内容 1.由用户输入两个集合A和B计算A与B的笛卡尔积提示根据笛卡儿积的定义只需将...
  • 提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录前言一、代码1.合成运算2. 并运算3. 交运算4. 补运算(易实现,可以不存为函数)二、函数...%功能:模糊关系合成运算 % [m1,n1]=size(.
  • 笛卡尔积运算: function[D]=cartesian_product(A,B) [m1,n1]=size(A); [m2,n2]=size(B); if m1m21 C=A’; for i=1:n1 for j=1:n2 if C(i,1)<B(1,j) D(i,j)= C(i,1); else D(i,j)= B(1,j); end end end else ...
  • 离散数学之矩阵关系运算

    千次阅读 2022-04-07 22:43:08
    矩阵关系运算前提: (1)第一个矩阵的列数等于第二个矩阵的行数。 (2)两个矩阵的元素均是0或1。 例如:A关系运算B得到C 原理:C11=(A11∧B11)∨(A12∧B21) C12=(A11∧B12)∨(A12∧B22)...... 就是把矩阵乘法...
  • 集合论—关系运算和性质

    千次阅读 2019-06-18 23:19:15
    关系是一个有序对集合或空集合,关系之间做运算以后依然是关系关系的定义域(domR\text{dom} RdomR),值域(ranR\text{ran} RranR)和域(fldR\text{fld} RfldR) domR={x∣∃y(&lt;x,y&gt;∈R)}\text{dom} ...
  • Alpha通道及合成运算

    千次阅读 2019-05-19 22:23:26
    转载:... 前言 在看《VTK图形图像开发进阶》的时候,第七章中提到了Alpha合成技术,不明白是什么,所以。。。。 Alpha通道是一个8位的灰度通道,该通道用256级灰...
  • 【实验目的】掌握二元关系在计算机上的表示方法,并掌握如果判定关系的性质。 【实验内容】 编程判断一个二元关系是否为等价关系,如果是,求其商集。 等价关系:集合A上的二元关系R同时具有自反性、对称性和传递性...
  • 本文探讨了U上的Fuzzy关系R与其逆关系R一,的合成运算,且得到了几个类似于自反关系的性质,并把(RoR-1)为U上甘称的和弱自反的Fuzzy关系的结论,推广为甘自然数n,(RoR-1)n仍然是U上对称的和弱自反的Fuzzy关系
  • 一、关系矩阵 、 二、关系矩阵示例 、 三、关系矩阵性质 、 四、关系矩阵运算 、 五、关系图 、 六、关系图示例 、 七、关系表示相关性质 、
  • 一、闭包求法 、 二、求闭包示例 ( 关系图角度 ) 、 三、求闭包示例 ( 关系矩阵角度 ) 、 四、闭包运算关系性质 、 五、闭包复合运算
  • 1、模糊矩阵 例3.6 设有一组同学X,X={张三,李四,...如果将他们的成绩转化为隶属度,则构成一个x×y上的一个模糊关系R,见下表。 该矩阵称作模糊矩阵,其中各个元素必须在[0,1]闭环区间上取值。...
  • 我尝试着编程实现了课本上集合与关系的相关内容,如集合的逆运算,复合运算,集合上关系的性质判断与闭包运算等,基本判断方法均为定义法。 代码如下: #include<iostream> #include<vector> #...
  • 由格运算的性质导出grey关系合成运算的表示,依照模糊化算子和判决化算子的定义得出对应的grey算子。讨论有关算子的基本性质并举例说明其应用。通过对grey语义的语言值上一组运算的数学描述,旨在提高信息系统对灰...
  • 1. 函数的复合 2. 函数的复合不满足交换律 3. 函数的复合满足结合律 4. 函数复合的保守性 5. 函数的逆
  • 一、常见的关系的性质 、 二、关系的性质示例 、 三、关系运算性质 、
  • 关系运算 & 等价关系和划分 关系运算 关系合成 (1).设R1R_1R1​是A到B的关系,R2R_2R2​是B到C的关系,从A到C的合成关系记为R1R2R_1R_2R1​R2​定义为R1R2={<a,c>∣a∈A∧c∈C∧∃b(b∈B∧<a,b...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,988
精华内容 10,795
关键字:

关系的合成运算

友情链接: Flarum.zip