行向量与列向量库源码

最新推荐文章于 2024-10-09 10:07:13 发布
最新推荐文章于 2024-10-09 10:07:13 发布
阅读量82 收藏
点赞数
文章标签： c++ java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chentingmu/article/details/130455010
版权
这是一个C++实现的复数矩阵类库，包括CRowVector和CColVector类表示行向量和列向量，以及COMPMAT类表示矩阵。类中包含矩阵的基本操作如赋值、加减法和乘法，还包括矩阵的共轭转置和求逆。代码中使用了高斯-约当消去法进行矩阵求逆。
摘要由CSDN通过智能技术生成

#ifndef COMPMAT_H_
#define COMPMAT_H_
#include <iostream>
#include"mystring.h"
#include "compclass.h"
class CRowVector
{
    //行向量定义
public:
    COMP *data;
    int n;
    int order;//序号
    int needdelete;//能否删除
    char name[20];//名称，方便调试
    void show();

    CRowVector(int m)
    {    
        n=m;
        strlet(name,"");
        needdelete=1;
        data=new COMP[n];
        int i;
        for(i=0;i<n;i++) 
        {            
            (data+i)->rmz=0;
            (data+i)->imz=0;
        }
    }
    ~CRowVector()
    {
        if(needdelete) delete[] data;
        else needdelete=1;
    }
};

void CRowVector::show()
{
    int i;
    cout<<name<<endl;
    for(i=0;i<n;i++)
    {
        cout<<(data+i)->rmz<<"+i"<<(data+i)->imz<<"\t";
    }
    cout<<endl;
}

class CColVector
{//列向量定义
public:
    COMP *data;
    int n;
    int order;//序号
    int needdelete;//能否删除
    char name[20];//名称，方便调试
    void show();

    CColVector(int m)
    {    
        n=m;
        strlet(name,"");
        needdelete=1;
        data=new COMP[n];
        int i;
        for(i=0;i<n;i++) 
        {            
            (data+i)->rmz=0;
            (data+i)->imz=0;
        }    
        
    }
    ~CColVector()
    {
        if(needdelete) delete[] data;
        else needdelete=1;
    }
};
void CColVector::show()
{
    int i;
    cout<<name<<endl;
    for(i=0;i<n;i++)
    {
        cout<<(data+i)->rmz<<"+i"<<(data+i)->imz<<"\n";
    }
    cout<<endl;
}


int COMPMATTotal=0;
//构造矩阵类MATRIX_H
class COMPMAT
{    
public:
    COMP *data;
    int row;
    int col;
    int size;
    int order;//序号
    int needdelete;//能否删除
    char name[20];//名称，方便调试
    void show();
public:
    COMPMAT(int,int);
    COMPMAT(int ,int ,char*);
    ~COMPMAT();
    const COMPMAT &operator=(const COMPMAT &);//赋值
    COMPMAT operator+(COMPMAT &);//矩阵元素相加
    COMPMAT operator-(COMPMAT &);//矩阵元素相减
    COMPMAT operator*(COMPMAT &);
    COMPMAT gonge( );
    COMPMAT inverse(double );
    
};

COMPMAT::COMPMAT(int r,int c){
    
    row=r;
    col=c;
    size=row*col;
    strlet(name,"");
    order=COMPMATTotal++;
    needdelete=1;
    data=new COMP[size];
    int i,j;
    for(i=0;i<row;i++)
    {    for(j=0;j<col;j++)
        {
            (data+i*col+j)->rmz=0;
            (data+i*col+j)->imz=0;
        }
    }
}
COMPMAT::COMPMAT(int r,int c,char*str)
{
    
    row=r;
    col=c;
    size=row*col;    
    order=COMPMATTotal++;
    needdelete=1;
    strlet(name,str);
    data=new COMP[size];
    int i,j;
    for(i=0;i<row;i++)
    {    for(j=0;j<col;j++)
        {
            (data+i*col+j)->rmz=0;
            (data+i*col+j)->imz=0;
        }
    }
}
COMPMAT::~COMPMAT()
{    
    if(needdelete) delete[]  data;
    else needdelete=1;
    //cout<<"\n以下是第("<<order<< ")个矩阵("<<name<<")调用析构"<<"\t[内存地址为：("<<this<<")] \n";
}
void COMPMAT::show()
{
    int i,j;
    cout.precision(6);//控制小数精度
    cout<<"\n以下是第("<<order<< ")个矩阵 "<<name<<"  [内存地址为："<<this<<"]\n";
    for(i=0;i<this->row;i++)
    {    for(j=0;j<this->col;j++)
        {
            cout<<(this->data+i*this->col+j)->rmz<<"+i"<<(this->data+i*this->col+j)->imz<<"\t";
        }
    cout<<"\n";
    }
}

const COMPMAT &COMPMAT::operator=(const COMPMAT &mat)
{
    if(&mat!=this)//检查早否自我赋值
    {
        delete [] data; //回收内存空间
        row=mat.row;
        col=mat.col;
        size=mat.size; //指定对象大小
        data=new COMP[size]; //为对象拷贝分配内存空间
        for(int i=0;i<row;i++)
            for(int j=0;j<col;j++)
                data[i*col+j]=mat.data[i*col+j]; //把矩阵元素拷贝到矩阵中
    }
    return *this;
}

COMPMAT  COMPMAT::operator+(COMPMAT &mat)//矩阵元素相加
{
    int i=0,j=0;
    COMPMAT temp(row,col);temp.needdelete=0;
    for(i=0;i<row;i++)
        for(j=0;j<col;j++)
            temp.data[i*col+j]=data[i*col+j]+mat.data[i*col+j];
    return temp;
}
COMPMAT  COMPMAT::operator-(COMPMAT &mat)//矩阵元素相减
{
    int i=0,j=0;
    COMPMAT temp(row,col);temp.needdelete=0;
    for(i=0;i<row;i++)
        for(j=0;j<col;j++)
            temp.data[i*col+j]=data[i*col+j]-mat.data[i*col+j];
    return temp;

}
    /* 需要调用复数运算的算法*/

/*======================================================
//函数名：cmat_mul
//功能描述：两个复矩阵相乘
//输入参数：a(左矩阵) b(右矩阵)  c(结果矩阵)
            m(左矩阵行数) p(左矩阵列数) n(右矩阵列数)
//返回值：运行成功则返回1,失败则返回0
=========================================================*/
//int COMPMAT::c_matmul(COMPMAT &a, COMPMAT &b, COMPMAT &c)
COMPMAT COMPMAT:: operator*(COMPMAT &b)
{
    int i,j,k;
    COMP tmp1, tmp2;
    COMPMAT c(row,b.col);c.needdelete=0;
    for(i=0; i<row; i++)                  /* 循环遍历矩阵c中的每个元素*/
        for(j=0; j<b.col; j++)
        {
            tmp1.rmz = 0.0;            /* 初值先存入复临时变量中*/
            tmp1.imz = 0.0;

            for(k=0; k<col; k++)            /* 循环累加*/
            {                
                //c_comp_product(&a[i*m+k], &b[k*m+j], &tmp2);
                tmp2=*(data+i*row+k)**(b.data+k*row+j);
               // c_comp_plus(&tmp1,&tmp2,&tmp1);
                tmp1=tmp1-tmp2;
            }
            (c.data+i*b.col+j)->rmz = tmp1.rmz;        /* 将计算的结果存入矩阵c中*/
            (c.data+i*b.col+j)->imz = tmp1.imz;
        }
    return(c);
}

/*======================================================
// 函数名：c_minv
// 功能描述：用高斯－约当消去法进行复矩阵原地求逆
// 输入参数：mat 待求逆的矩阵，求解成功后存放逆矩阵
//           n 矩阵阶数
//           eps 精度要求，小于eps的值，认为是0。
// 返回值：整型。运行成功则返回1,失败则返回0
=========================================================*/
COMPMAT COMPMAT:: inverse(double eps)
{
    int *is,*js,i,j,k,l,v;
    COMP c_tmp;
    double tmp,d;
    is =new int[row];    /* 为行交换记录分配空间并检测是否成功*/
    js =new int[row];      /* 为列交换记录分配空间并检测是否成功*/
    if(row!=col) return *this;
    for(k=0; k<row; k++)
      {
        d = 0.0;
        for(i=k; i<row; i++)             /* 此循环用于选取主元*/
        for(j=k; j<row; j++)
          {
            l = i*row + j;
            tmp = (data+l)->rmz*(data+l)->rmz + (data+l)->imz*(data+l)->imz;  /* 求元素的模*/
            if(tmp>d)
            {
                d = tmp;
                is[k] = i;
                js[k] = j;
            }
          }
        if(d < eps)                    /* 判断主元是否过小*/
          {
            free(is);                  /* 若主元过小则退出程序*/
            free(js);
            cout<<("Matrix inverse failed.\n");
            return(*this);
          }

        if(is[k]!=k)                   /* 判断是否需要行交换*/
          for (j=0; j<=row-1; j++)       /* 进行行交换*/
            {
              l = k*row+ j;
              v = is[k]*row + j;
              tmp = (data+l)->rmz;
              (data+l)->rmz = (data+v)->rmz;
              (data+v)->rmz = tmp;
              tmp = (data+l)->imz;
              (data+l)->imz = (data+v)->imz;
              (data+v)->imz = tmp;
            }
        if(js[k]!=k)                   /* 判断是否需要列交换*/
          for (i=0; i<=row-1; i++)       /* 进行列交换*/
            {
              l = i*row + k;
              v = i*row +js[k];
              tmp = (data+l)->rmz;
              (data+l)->rmz = (data+v)->rmz;
              (data+v)->rmz = tmp;
              tmp = (data+l)->imz;
              (data+l)->imz =(data+v)->imz;
              (data+v)->imz = tmp;
            }
        l = k*row + k;                   /* 归一化计算的第一步*/
        (data+l)->rmz =(data+l)->rmz/d;
        (data+l)->imz = -(data+l)->imz/d;

        for(j=0; j<=row-1; j++)          /* 归一化计算的第二步，需要使用复数的乘法*/
          if(j!=k)
            {
              v = k*row + j;
              *(data+v)=*(data+v)**(data+l);
              //c_comp_product(&mat[v], &mat[l], &mat[v]);
            }

        for(i=0; i<=row-1; i++)          /* 消元计算的第一步*/
          if(i!=k)
            {
              for (j=0; j<=row-1; j++)
                if (j!=k)
                  {
                    //c_comp_product(&mat[k*n+j], &mat[i*n+k], &c_tmp);
                    c_tmp=*(data+k*row+j)**(data+i*row+k);
                    (data+i*row+j)->rmz = (data+i*row+j)->rmz - c_tmp.rmz;
                    (data+i*row+j)->imz = (data+i*row+j)->imz - c_tmp.imz;
                  }
            }

        for(i=0; i<=row-1; i++)          /* 消元计算的第二步*/
          if(i!=k)
            {
              v = i*row + k;
              //c_comp_product(&mat[l], &mat[v], &mat[v]);
              *(data+v)=*(data+l)**(data+v);
              (data+v)->rmz = -(data+v)->rmz;
              (data+v)->imz = -(data+v)->imz;
            }
      }

    for(k=row-1; k>=0; k--)             /* 依照行交换和列交换的历史进行结果恢复*/
      {
        if(js[k]!=k)                  /* 判断是否需要恢复*/
          for(j=0; j<=row-1; j++)       /* 按列交换的历史进行行交换*/
            {
              l = k*row + j;
              v=js[k]*row + j;
              tmp = (data+l)->rmz;
              (data+l)->rmz = (data+v)->rmz;
              (data+v)->rmz = tmp;
              tmp = (data+l)->imz;
              (data+l)->imz = (data+v)->imz;
              (data+v)->imz = tmp;
            }

        if(is[k]!=k)
          for(i=0; i<=row-1; i++)        /* 按行交换的历史进行列交换*/
            {
              l = i*row + k;
              v = i*row + is[k];
              tmp =(data+l)->rmz;
              (data+l)->rmz = (data+v)->rmz;
              (data+v)->rmz = tmp;
              tmp = (data+l)->imz;
              (data+l)->imz = (data+v)->imz;
              (data+v)->imz = tmp;
            }
      }

    free(is);                          /* 释放分配的空间*/
    free(js);
    return(*this);                         /* 求解成功，返回1*/
}

COMPMAT COMPMAT::gonge( )
{
    COMPMAT c(row,col);c.needdelete=0;
    int i,j;
    for (i=0;i<row;i++)
        for (j=0;j<col;j++)
        {
            (c.data+i*col+j)->rmz=(this->data+i*col+j)->rmz;
            (c.data+i*col+j)->imz=-(this->data+i*col+j)->imz;
        }
        return c;
}

#endif

稻田统计
关注
Matlab 绘制 - 点和向量：向量加减的方法和源码
山云的专栏
07-24 6223
一些博客就是转了Matlab的中文说明，可是他那个说明，他自己都说了不是很对。本文从实践出发，详细介绍Matlab对坐标空间的点和向量的绘制方法。
【LLM】向量知识库
weixin_42914989的博客
04-23 1522
在此列出一些公开的embeedding_model,Langchain原生支持加载embeedding_model,动手能力强的小伙伴可以根据文档动手实现一个embeedding api.文本嵌入模型 text-embedding-model本节了解了什么是向量、向量的生成、向量的存储和向量的应用，同时对比了向量数据库和常见非向量数据库的区别。动手设计了一个加载text2vec-large-chinese embedding model的api接口，并且将生成的向量录入到向量数据库中。
python将一列数据转换成向量_python读取csv和txt数据转换成向量的实例
weixin_39843215的博客
11-29 2230
python读取csv和txt数据转换成向量的实例最近写程序需要从文件中读取数据，并把读取的数据转换成向量。查阅资料之后找到了读取csv文件和txt文件两种方式，下面结合自己的实验过程，做简要记录，供大家参考：1、读取csv文件的数据import csvfiltpath = "data_test.csv"with open(filtpath,'r') as csvfile:reader = csv...
MATLAB源码：矩阵特征值与特征向量计算教程
weixin_36282234的博客
09-26 1009
本文还有配套的精品资源，点击获取 简介：特征值和特征向量是线性代数中的关键概念，广泛应用于机器学习、图像处理等领域。MATLAB软件通过其内置的 eig 函数提供了方便的计算方法。本文档包含MATLAB源代码，演示了如何计算矩阵的特征值和特征向量，以及它们在各种实际问题中的应用。通过学习这些源代码，读者可以加深对特征值和特征向量计算的理解，并将这些知识应用于数...
Apache Doris 向量化设计与实现
过往记忆大数据
02-27 2563
导读：向量化技术带来极致的CPU效率的同时，也已经成为了软件开发的趋势，而数据库的向量化不仅仅是 CPU 指令的向量化，还是一个巨大的性能优化工程。本文从CPU向量化原理出发，通过Cach...
基于LangChain+LLM的本地知识库问答：从企业单文档问答到批量文档问答
热门推荐
结构之法 算法之道
07-05 10万+
本文则侧重讲解 1 什么是LangChain及langchain的整体组成架构 2 解读langchain-ChatGLM项目的关键源码，不只是把它当做一个工具使用，因为对工具的原理更了解，则对工具的使用更顺畅 3 langchain-ChatGLM项目的升级版langchain-chatchat
向量与矩阵计算的C语言代码
weixin_42248256的博客
10-21 3451
1.初始化定义 typedef double ElemType; typedef ElemType* Vector; typedef ElemType** Matrix; typedef ElemType*** MatrixStack; #define ZERO_MATRIX 0 #define ONES_MATRIX 1 #define UNIT_MATRIX 2 2.向量操作 2.1向量初始化 /* brief：创建向量 ** param：长度 ** output：Vector */ Vector
fasttext源码解析
manmanxiaowugun的博客
06-23 2265
转载自知乎 作者：张晓辉 链接：https://zhuanlan.zhihu.com/p/64960839 https://zhuanlan.zhihu.com/p/65687490 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 最近花了一些时间通读了fb的fasttext的源码。远离了c++好长一段时间，猛地一看c++，太亲切了。简单的说，f...
PieCloudVector：大模型时代下向量数据库的设计与应用
OpenPie的博客
07-31 992
随着 RAG 技术的不断成熟，其核心组件向量数据库也受到越来越多的关注，成为大模型的必备应用。本文将探讨向量数据库在大模型场景下的应用趋势，并结合用户案例，详细介绍拓数派向量数据库 PieCloudVector 的架构设计与技术实现。
支持向量机—SMO算法源码分析（1）
lilong117194的博客
10-15 3225
支持向量机的理论支持在此不细说，可以参考李航的《统计学习》，还有西瓜书。简化版SMO算法处理小规模数据集SMO算法是一种启发式算法。此简化版首先在数据集上遍历每一个alpha，然后在剩下的alpha集合中随机选择另一个alpha，从而建立alpha对。# -*- coding: utf-8 -*- from numpy import * from time import sleep # SMO算法的
易语言源码易语言向量法计算文本相似度源码.rar
02-19
每一行代表一段文本，每一列代表一个词汇，矩阵中的每个元素表示对应词汇在文本中的频率。 3. **TF-IDF转换**：如果采用TF-IDF模型，需要计算每个词汇的TF-IDF值，并替换词频矩阵中的相应元素。TF是词频，IDF是逆...
基于使用支持向量机(SVM)来构建垃圾邮件分类器matlab-源码
10-16
每个样本对应矩阵中的一行，每个特征对应一列。对于SVM，我们可以选择线性或非线性的特征映射，例如多项式或高斯核函数。 3. **训练SVM模型**：使用MATLAB的`svmtrain`函数，传入特征矩阵和对应的类别标签（0表示非...
支持向量机非线性回归通用MATLAB源码.pdf
09-14
【支持向量机非线性回归通用MATLAB源码】是一种使用MATLAB编程实现的支持向量机（Support Vector Machine, SVM）进行非线性回归的方法。SVM是一种强大的机器学习模型，尤其适用于分类和回归任务。它通过构建一个最大...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1208
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1718
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
大话C++：第15篇 友元
最新发布
whccf的博客
10-09 744
友元（Friend）是C++中的一个特殊概念，它允许一个类或函数访问另一个类的私有和保护成员。友元可以是一个函数，也可以是一个类。
windows C++-创建数据流代理(三)
苏洛的博客
10-08 286
控制流指的是程序中操作的执行顺序。 控制流是通过使用条件语句、循环等控制结构调节的。 此外，数据流指的是一种编程模型，在这种模型中，只有当所有需要的数据都可用时，才会进行计算。 数据流编程模型与消息传递这一概念相关，其中程序的独立组件通过发送消息相互通信。 异步代理同时支持控制流和数据流编程模型。 尽管控制流模型适用于许多情况，但数据流模型也适用于其他一些情况，例如，当代理接收数据并执行基于该数据的有效负载的操作时。
【C++力扣】917.仅仅反转字母|387.字符串中第一个唯一字符|415.字符串相加
白乐天_ξ( ✿＞◡❛)的博客
10-06 631
本文写的是力扣三道题的解答：917、387、415题，都是与string字符串有关的！
C++ | Leetcode C++题解之第463题岛屿的周长
Ddddddd_158的博客
10-08 455
C++ | Leetcode C++题解之第463题岛屿的周长
MATLAB向量与矩阵运算详解及源码分享
向量是具有方向的一维数组，可以是行向量也可以是列向量。在MATLAB中，向量可以通过直接赋值或使用冒号操作符（:）生成等差数列向量。例如，创建一个行向量可以写作 `v = [1, 2, 3]`，而创建一个列向量则可以写作 `v...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值