代码小白写的关系矩阵

最新推荐文章于 2024-05-02 19:49:42 发布
最新推荐文章于 2024-05-02 19:49:42 发布
阅读量425 收藏
点赞数 1
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54690747/article/details/118718423
版权
这篇博客介绍了C++中一个自定义的类`Matrix`，用于表示和操作矩阵，支持基本的初始化、添加元素、设置元素、显示、求和等操作。此外，还定义了一个`RelationSet`类来表示关系集合，并提供了关系矩阵的运算，如并集、自反闭包、对称闭包、传递闭包等。文章适用于离散数学和矩阵运算的学习。
摘要由CSDN通过智能技术生成 
#pragma once
#include <iostream>
#include <vector>
#include <stdarg.h>
#include <set>
#include <map>
#include <initializer_list>
#define endll "\n"
using namespace std;
class _Matrix
{
protected:
    int rows;
    int cols;
    vector<vector<int>> v;

public:
    _Matrix() : rows(0), cols(0) {}
    _Matrix(int rows, int cols) : rows(rows), cols(cols)
    {
        for (int i = 0; i < rows; ++i)
        {
            v.push_back(vector<int>(cols));
        }
    }
    virtual bool scanf_initalize()
    {
        int temp;
        for (int i = 0; i < rows; ++i)
        {
            vector<int> vv;
            for (int j = 0; j < cols; ++j)
            {
                scanf("%d", &temp);
                vv.push_back(temp);
            }
            v.at(i) = vv;
        }
        return true;
    }
    virtual bool add(int num, ...)
    {
        if (cols == 0)
        {
            cols = num;
        }
        else if (num != cols)
        {
            throw "The matrix needs to be a rectangle";
        }
        vector<int> vv(num);
        va_list ptr;
        int temp;
        va_start(ptr, num);
        for (int i = 0; i < num; ++i)
        {
            temp = va_arg(ptr, int);
            vv.at(i) = temp;
        }
        va_end(ptr);
        v.push_back(vv);
        ++rows;
        return true;
    }
    virtual bool set_matrix_element(int row, int cols, int val)
    {
        if (row <= rows && row >= 0 && cols <= this->rows && cols >= 0)
        {
            v.at(row - 1).at(cols - 1) = val;
            return true;
        }
        return false;
    }
    int get_rows() const
    {
        return rows;
    }
    int get_cols() const
    {
        return cols;
    }
    void display() const //??
    {
        for (int i = 0; i < rows; ++i)
        {
            for (int j = 0; j < cols; ++j)
            {
                cout << v[i][j] << " ";
            }
            cout << endll;
        }
    }
    void remove_clear()
    {
        v.clear();
        this->cols = 0;
        this->rows = 0;
    }
    int sum()
    {
        int s = 0;
        for (int i = 0; i < rows; ++i)
        {
            for (int j = 0; j < cols; ++j)
            {
                s += v.at(i).at(j);
            }
        }
        return s;
    }
    _Matrix inverse()
    {
        _Matrix m(cols, rows);
        for (int i = 0; i < rows; ++i)
        {
            for (int j = 0; j < cols; ++j)
            {
                m.v.at(j).at(i) = v.at(i).at(j);
            }
        }
        return m;
    }
    _Matrix& operator+=(const _Matrix& m)
    {
        if (m.cols == this->cols && m.rows == this->rows)
        {
            for (int i = 0; i < this->rows; ++i)
            {
                for (int j = 0; j < this->cols; ++j)
                {
                    this->v.at(i).at(j) += m.v.at(i).at(j);
                }
            }
        }
        else
        {
            throw "Different matrices for rows or columns are used";
        }
        return *this;
    }
    _Matrix& operator-=(const _Matrix& m)
    {
        if (m.cols == this->cols && m.rows == this->rows)
        {
            for (int i = 0; i < this->rows; ++i)
            {
                for (int j = 0; j < this->cols; ++j)
                {
                    this->v.at(i).at(j) -= m.v.at(i).at(j);
                }
            }
        }
        else
        {
            throw "Different matrices for rows or columns are used";
        }
        return *this;
    }
    _Matrix& operator*=(const _Matrix& m)
    {
        if (this->cols == m.rows)
        {
            _Matrix temp_m(*this);
            this->cols = m.cols;
            int element = 0;
            v.clear();
            for (int i = 0; i < temp_m.rows; ++i)
            {
                vector<int> temp_element;
                for (int k = 0; k < m.cols; ++k)
                {
                    for (int j = 0; j < m.rows; ++j)
                    {
                        element += temp_m.v.at(i).at(j) * m.v.at(j).at(k);
                    }
                    temp_element.push_back(element);
                    element = 0;
                }
                v.push_back(temp_element);
            }
            return *this;
        }
        else
        {
            throw "The number of rows and columns should be equal";
        }
    }
    _Matrix& operator*=(int m)
    {
        for (int i = 0; i < this->rows; ++i)
        {
            for (int j = 0; j < this->cols; ++j)
            {
                this->v.at(i).at(j) *= m;
            }
        }
        return *this;
    }
    friend _Matrix operator+(_Matrix a, _Matrix b)
    {
        return a += b;
    }
    friend _Matrix operator-(_Matrix a, _Matrix b)
    {
        return a -= b;
    }
    friend _Matrix operator*(_Matrix a, int b)
    {
        return (a *= b);
    }
    friend _Matrix operator*(int b, _Matrix a)
    {
        return a *= b;
    }
    friend _Matrix operator*(_Matrix a, _Matrix b)
    {
        return a *= b;
    }
    friend ostream& operator<<(ostream& os, const _Matrix& m)
    {
        m.display();
        return os;
    }
};
template <typename T>
class RelationSet : public set<pair<T, T>>
{
public:
    friend class Relation_matrix;
    RelationSet() {}
    RelationSet(set<pair<T, T>>& r) : set<pair<T, T>>(r) {}
    RelationSet(initializer_list<initializer_list<T>> il)
    {
        for (auto it = il.begin(); it != il.end(); ++it)
        {
            if (it->size() > 2)
                throw "Ordered couple needs two elements";
            auto itt = it->begin();
            int first_ = *itt;
            int second_ = *(++itt);
            this->emplace(first_, second_);
        }
    }
    void display() const
    {
        cout << "{";
        auto in_end = this->end();
        in_end--;
        for (auto it = this->begin(); it != in_end; ++it)
        {
            cout << "<" << it->first << "," << it->second << ">"
                << ",";
        }
        cout << "<" << in_end->first << "," << in_end->second << ">"
            << "}";
    }
    friend ostream& operator<<(ostream& os, const RelationSet& m)
    {
        m.display();
        return os;
    }
};
class Relation_matrix : public _Matrix
{
protected:
    bool isBitMatrix;
    bool equal_randc() const
    {
        return (rows == cols);
    }
    bool is_bit_matrix() const
    {
        return isBitMatrix;
    }
    void throw_exception() const
    {
        if (!equal_randc())
            throw "It's not a determinant";
        if (!is_bit_matrix())
            throw "It's not a binary matrix";
    }
    template<typename T>
    static void seach(T t, RelationSet<T>& r, set<T>& temp) {
        for (auto i = r.begin(); i != r.end(); ++i) {
            if (i->first == t && temp.find(i->second) == temp.end()) {
                temp.insert(i->second);
                seach(i->second, r, temp);
            }
        }
    }

public:
    Relation_matrix(int r_and_c) : _Matrix(r_and_c, r_and_c), isBitMatrix(true)
    {
    }
    Relation_matrix() : _Matrix(), isBitMatrix(true) {}
    template <typename T>
    Relation_matrix(set<T>& s, RelationSet<T>& r) : _Matrix(s.size(), s.size()), isBitMatrix(true)
    {
        for (auto it = r.begin(); it != r.end(); ++it)
        {
            if (s.find(it->first) == s.end() || s.find(it->second) == s.end())
                throw "The relation is not defined on the set";
        }
        map<T, int> m;
        int i = 0;
        for (auto it = s.begin(); it != s.end(); ++it)
        {
            m.emplace(*it, i);
            ++i;
        }
        for (auto it = r.begin(); it != r.end(); ++it)
        {
            v.at(m.find(it->first)->second).at(m.find(it->second)->second) = 1;
        }
    }
    bool scanf_initalize() override
    {
        int temp;
        for (int i = 0; i < rows; ++i)
        {
            vector<int> vv;
            for (int j = 0; j < cols; ++j)
            {
                scanf("%d", &temp);
                if (temp != 0 || temp != 1)
                {
                    isBitMatrix = false;
                }
                vv.push_back(temp);
            }
            v.at(i) = vv;
        }
        return true;
    }
    bool add(int num, ...) override
    {
        if (cols == 0)
        {
            cols = num;
        }
        else if (num != cols)
        {
            throw "The matrix needs to be a rectangle";
        }
        vector<int> vv(num);
        va_list ptr;
        int temp;
        va_start(ptr, num);
        for (int i = 0; i < num; ++i)
        {
            temp = va_arg(ptr, int);
            if (temp != 1 && temp != 0)
                isBitMatrix = false;
            vv.at(i) = temp;
        }
        va_end(ptr);
        v.push_back(vv);
        ++rows;
        return true;
    }
    bool set_matrix_element(int row, int cols, int val) override
    {
        if (row <= rows && row >= 0 && cols <= this->rows && cols >= 0 && (val == 1 || val == 0))
        {
            v.at(row - 1).at(cols - 1) = val;
            return true;
        }
        return false;
    }
    Relation_matrix& operator|=(const Relation_matrix& d)
    {
        this->throw_exception();
        d.throw_exception();
        for (int i = 0; i < rows; ++i)
        {
            for (int j = 0; j < d.cols; ++j)
            {
                if (v.at(i).at(j) | d.v.at(i).at(j))
                {
                    v.at(i).at(j) = 1;
                }
                else
                {
                    v.at(i).at(j) = 0;
                }
            }
        }
        return *this;
    }
    friend Relation_matrix operator|(Relation_matrix a, Relation_matrix b)
    {
        a |= b;
        return a;
    }
    bool is_reflexive() const
    {
        throw_exception();
        for (int i = 0; i < rows; ++i)
        {
            if (v.at(i).at(i) == 0)
                return false;
        }
        return true;
    }
    bool is_anti_reflexive() const
    {
        throw_exception();
        for (int i = 0; i < rows; ++i)
        {
            if (v.at(i).at(i) == 1)
                return false;
        }
        return true;
    }
    bool is_symmetric() const
    {
        throw_exception();
        for (int i = 0; i < rows - 1; ++i)
        {
            for (int j = i + 1; j < cols; ++j)
            {
                if (v.at(i).at(j) != v.at(j).at(i))
                {
                    return false;
                }
            }
        }
        return true;
    }
    bool is_anti_symmetric() const
    {
        throw_exception();
        for (int i = 0; i < rows - 1; ++i)
        {
            for (int j = i + 1; j < cols; ++j)
            {
                if (v.at(i).at(j) == 1 && v.at(j).at(i) == 1)
                {
                    return false;
                }
            }
        }
        return true;
    }
    bool is_transmit() const
    {
        throw_exception();
        for (int i = 0; i < rows; ++i)
        {
            for (int j = 0; j < cols; ++j)
            {
                for (int k = 0; k < cols; ++k)
                {
                    if (v.at(i).at(j) == 1 && v.at(j).at(k) == 1 && v.at(i).at(k) != 1)
                    {
                        return false;
                    }
                }
            }
        }
        return true;
    }
    bool is_equal() const
    {
        return is_reflexive() && is_symmetric() && is_transmit();
    }
    template <typename T>
    static set<set<T>> make_equal_class(set<T>& s, RelationSet<T>& r)
    {
        Relation_matrix temp_m(s, r);
        set<T> temp_ele; set<set<T>>val_;
        set<T>v;
        if (temp_m.is_equal())
        {
            for (auto it = s.begin(); it != s.end(); ++it) {
                if (v.find(*it) != v.end())continue;
                temp_ele.insert(*it);
                seach(*it, r, temp_ele);
                val_.insert(temp_ele);
                temp_ele.clear();
            }
        }
        return val_;
    }
    Relation_matrix reflexive_closure() const
    {
        throw_exception();
        if (this->is_reflexive())
        {
            return *this;
        }
        Relation_matrix temp(*this);
        for (int i = 0; i < rows; ++i)
        {
            temp.v.at(i).at(i) = 1;
        }
        return temp;
    }
    Relation_matrix symmetric_closure() const
    {
        throw_exception();
        if (this->is_symmetric())
        {
            return *this;
        }
        Relation_matrix temp(*this);
        for (int i = 0; i < rows; ++i)
        {
            for (int j = 0; j < cols; ++j)
            {
                if (i != j && v.at(i).at(j) == 1 && v.at(j).at(i) == 0)
                {
                    temp.v.at(j).at(i) = 1;
                }
            }
        }
        return temp;
    }
    Relation_matrix transmit_closure() const
    {
        throw_exception();
        if (this->is_transmit())
        {
            return *this;
        }
        Relation_matrix temp(*this);
        Relation_matrix temp3(*this);
        for (int i = 0; i < rows - 1; ++i)
        {
            temp *= *this;
            temp3 |= temp;
        }
        return temp3;
    }
    Relation_matrix warshall() const
    {
        throw_exception();
        if (this->is_transmit())
        {
            return *this;
        }
        Relation_matrix temp(*this);
        for (int i = 0; i < rows; ++i)
        {
            for (int j = 0; j < cols; ++j)
            {
                if (temp.v.at(j).at(i) == 1)
                {
                    for (int k = 0; k < rows; ++k)
                    {
                        if (temp.v.at(j).at(k) + temp.v.at(i).at(k))
                            temp.v.at(j).at(k) = 1;
                        else
                            temp.v.at(j).at(k) = 0;
                    }
                }
            }
        }
        return temp;
    }
    template <typename T>
    RelationSet<T> make_RelationSet(set<T>& s) const
    {
        RelationSet<T> r;
        map<T, int> m;
        int i = 0;
        for (auto it = s.begin(); it != s.end(); ++it)
        {
            m.emplace(i, *it);
            ++i;
        }
        for (int i = 0; i < this->rows; ++i)
        {
            for (int j = 0; j < this->rows; ++j)
            {
                if (v.at(i).at(j) == 1)
                {
                    r.emplace(m.find(i)->second, m.find(j)->second);
                }
            }
        }
        return r;
    }
};

分装的不好，应付一下离散数学还是可以的。（有些bug，懒得改了，重在能跑）。

情玖小羊
关注
关系映射矩阵源代码
07-14
关系映射矩阵生成源代码
矩阵代码
weixin_30611509的博客
01-29 821
var oDiv = document.getElementById("feifei");$(function () { var aSpan = $('.resizable'); for (var i = 0; i < aSpan.length; i++) { dragFn(aSpan.eq(i).get(0)); } $('.rotate-circle...
C++ 实现关系矩阵乘法运算
Karthus77的博客
05-03 797
注意是关系矩阵乘法，不是矩阵乘法 代码直接放上 重载了两个运算符，不是装逼，只是想练练手。。。 #include <iostream> using namespace std; class Matrix { public: Matrix(int n); void iniMatrix(); ~Matrix(); friend ostream & operator<< (ostream & os, const Matrix& R1); Matr.
【集合论】关系表示 ( 关系矩阵 | 关系矩阵示例 | 关系矩阵性质 | 关系矩阵运算 | 关系图 | 关系图示例 | 关系表示相关性质 )
热门推荐
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
10-03 4万+
一、关系矩阵 、 二、关系矩阵示例 、 三、关系矩阵性质 、 四、关系矩阵运算 、 五、关系图 、 六、关系图示例 、 七、关系表示相关性质 、
离散数学4_第5章关系与函数__关系矩阵
华工的专栏
03-13 3万+
关系矩阵的 定义 注意这里 mxn阶的矩阵， 是指m 行， n列的 矩阵
python灰度共生矩阵GLCM，带公式和代码
Daweixi的博客
09-05 1万+
灰度共生矩阵所代表的含义是图像的灰度值在空间的某个方向上的特点，但是如何衡量两个目标图像纹理之间的差异是不能直接使用灰度共生矩阵表示出来的，所以需要使用一个特定的模型去统计灰度共生矩阵的特性来描述纹理特性。例如Haralick HaralickHaralick曾提出了14种基于灰度共生矩阵计算出来的统计量：能量、熵、对比度、均匀性、相关性、方差、和平均、和方差、和熵、差方差、差平均、差熵、...
机器学习小白手推一元线性回归[附代码]
race_null的专栏
12-10 1285
由于经常做运维和编程工作，线性代数中线性回归的思路是机器学习的基本思路。为方便手工推算计算，我取表中标准体重的前5个数据：[10.05,12.54,14.65,16.64,18.98]，分别对应1岁到5岁年龄。而求解过程也比一元线性回归要复杂得多，这里就不做手工推算了，直接使用sklearn集成好的库，用代码体验一下。可上面的预测结果与真实数据存在误差，毕竟预测结果是方程算出的嘛，和真实值当然会不一样了。根据下表内容，预测指定年龄的儿童体重。
MATLAB实现混淆矩阵
qigeyonghuming_1的博客
07-31 2万+
参考博客1： https://blog.csdn.net/sherry_gp/article/details/50560003 感谢博主大大 sherry_gp 参考博客2：https://blog.csdn.net/stu_lavender/article/details/79615474 感谢博主大大： stu_lavender 参考博客3：https://www.csdn.net/gath...
2024年大数据最全数仓实践：总线矩阵设计_数仓总线矩阵(1)
最新发布
2401_84166567的博客
05-02 960
维度的划分具有行业共同性，比如电商行业通常涉及这些维度：买家、卖家、订单、广告、货运、支付等，制造业中：设备、产线、项目、物料、车型等，还有一些跨行业通用的维度，如城市、日期等。核心维度由数据管理责任人定义，在多个业务过程中使用，而不是被单一业务过程或部门定义，提供一致性维度，实现跨业务过程钻取的需求。因此实际设计过程中，我们通常把总线架构列表成矩阵的形式，其中列为一致性维度，行为不同的业务处理过程，即事实，在交叉点上打上标记表示该业务处理过程与该维度相关，这个矩阵也称为总线矩阵（Bus Matrix）。
排列组合（递推矩阵）
Zhengyangxinn的博客
07-19 2340
排列与组合有什么区别？ 排列与元素的顺序有关，组合与顺序无关。 如何递推出对应的排列组合呢？ ①组合 通过上面的组合公式可以得到下面的数据表格 n\m 0 1 2 3 4 5 6 … 0 0 0 0 0 0 0 0 … 1 1 0 0 0 0 0 0 … 2 1 2 0 0 0 0 0 … 3 1 3 6 0 0 0 0 … 4 1 4 12 24 0 0 0 … 5 1 5 20 60 120 0 0 … 6 1 6 30 20 360 720 0 … …
java矩阵关系运算源代码
04-26
这个是高级数学里面的关系的一章,利用java来实现了关系的运算
关联矩阵与邻接矩阵相互转化
05-10
实现关联矩阵与邻接矩阵相互转化的matlab代码 Correlation matrix and adjacency matrix to achieve mutual transformation of matlab code
C++矩阵关系远算
qq_63206582的博客
04-09 987
C++矩阵关系远算
【离散数学】九章：关系 - 关系的表示
m0_74195626的博客
05-01 7362
用集合表示关系、用矩阵表示关系：集合上的关系矩阵、确定关系合成的矩阵 用有向图表示关系
离散数学（6）——关系的表示和关系的性质
Allure_07的博客
03-26 7222
离散数学（6）——关系的表示和关系的性质 一、关系矩阵 A={a1,a2,…,an}，R⊆A×A R的关系矩阵 M( R )=(rij)n×n eg: A={a,b,c} R1={<a,a>,<a,b>,<b,a>,<b,c>} R2={<a,b>,<a,c>,<b,c>} 二、关系矩阵的性质 ...
【2012】建立二维矩阵
AWCXV
10-06 111
Time Limit: 3 second Memory Limit: 2 MB 一维数组有6个整数，数组元素分别为 7 4 8 9 1 5 要求建立一个如下数组（矩阵）： 7 4 8 9 1 5 4 8 9 1 5 7 8 9 1 5 7 4 9 1 5 7 4 8 1 5 7 4...
[关系图谱] 二.Gephi导入共线矩阵构建作者关系图谱
杨秀璋的专栏
12-17 1万+
本文主要讲解Gephi绘制作者间的关系图谱，该软件可以广泛应用于社交网络、知识图谱分析，推荐读者使用。这是非常基础的一篇文章，重点讲解Gephi使用方法，希望对大家有所帮助。
二元关系的矩阵和图表示
松子茶的专栏
08-05 1万+
两个事物之间的关系称之为二元关系。在数学上，二元关系指的是这样的一个集合S，它的所有元素都为二元有序对。它反映的是有序对中第一个元素组成的集合与第二个元素组成的集合之间的关系。举个例子，集合S={,} 就表示了中文集合{天秤座,狮子座}与英文集合{libra,leo}之间的对应关系。二元关系可以用集合表示，就像我们上面提到的。而除此之外，还可以用其他数学工具来描述它——矩阵和图。矩阵的基本元素是数
python实现利用networkx库将图形结构转换为邻接矩阵和特征矩阵代码
06-06
好的，以下是Python代码实现： ...其中，邻接矩阵表示了节点之间的连接关系，特征矩阵表示了节点的属性信息。这里采用了一个简单的特征矩阵，即单位矩阵。如果有更复杂的属性信息，可以将其转换为矩阵形式。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值