矩阵.hpp

浏览该文件的文档.

//
//  矩阵.hpp
//  多线程
//
//  Created by 赵明明 on 2023/6/15.
//
 
#ifndef 矩阵__hpp
#define 矩阵__hpp
#define NDEBUG
#include <stdio.h>
#include <iostream>
#include <sstream>
#include <stdarg.h>
#include <iomanip>
using namespace std;
struct 矩阵python{
    float * data;
    int w;
    int h;
};
 
class 矩阵{
public:
    float Inf=3.4*pow(10,38);
    int N;
    int w;
    int h;
    float max=3.4*pow(10,38);
    float min=3.4*pow(10,38);
    float * data;
public:
    矩阵(矩阵python * 结构体){
            w=结构体->w;
            h=结构体->h;
            N=w*h;
            data=结构体->data;
        }
    
    矩阵(int _h,int _w,float value){
        N=_w*_h;
        w=_w;
        h=_h;
        data = new float[N];
        //memset(data,value,sizeof(float)*N);
        for(int i=0;i<N;i++){
            data[i]=value;
        }
    }
    
    矩阵(int _h,int _w,矩阵 value){
        N=_w*_h;
        w=_w;
        h=_h;
        data = new float[N];
        //memset(data,value,sizeof(float)*N);
        for(int i=0;i<N;i++){
            data[i]=value[i];
        }
    }
    
    矩阵(int _h,int _w,float * init_data,bool COPYARRAY){
        N=_w*_h;
        w=_w;
        h=_h;
        if(COPYARRAY==1){
            data = new float[N];
            
            //memset(data,value,sizeof(float)*N);
            for(int i=0;i<N;i++){
                data[i]=init_data[i];
            }
        }
        else{
            data=init_data;
        }
    }
    
    矩阵(int n,float value){
        N=n;
        w=n;
        h=1;
        data = new float[N];
        //memset(data,value,sizeof(float)*N);
        for(int i=0;i<N;i++){
            data[i]=value;
        }
    }
    
    矩阵(矩阵& 阵){
        N=阵.N;
        w=阵.w;
        h=阵.h;
        data=new float[N];
        for(int i=0;i<N;i++){
            data[i]=阵[i];
        }
    }
    
    void  取整(void){
        for(int i=0;i<N;i++){
            data[i]=(int)data[i];
        }
    }
    
    void 精度(int n=5){
        for(int i=0;i<N;i++){
            float f = data[i];
            float t1 = f-(int)f;
            t1=round(t1*pow(10,n));
            t1/=pow(10,n);
            data[i]=t1+(int)f;
        }
    }
    
    矩阵* 点积(矩阵& 矩阵1){
        矩阵 积=operator*(矩阵1);
        return 积.和(1);
    }
    
    矩阵* 单位化(void){
        矩阵* 单位=new 矩阵(h,w,(float)0);
        矩阵 积 = operator*(*this);
        矩阵* 和值=积.和(1);
        //矩阵* 指数值=和值->指数(0.5);
        for(int i=0;i<h;i++){
            stringstream ss;
            ss<<i<<",:";
            矩阵* 行=operator[](ss.str());
            float norm= pow((*和值)[i],0.5);
            矩阵 长=矩阵(1,w,norm);
            矩阵 行果=(*行)/长;
            //cout<<行果;
            for(int j=0;j<w;j++){
                单位->data[i*w+j]=(行果)[j];
            }
        }
        return 单位;
    }
    
    矩阵* 和(void){
        矩阵* 和=new 矩阵(1,1,(float)0);
        for(int i=0;i<N;i++){
            (*和)[0]+=data[i];
        }
        return 和;
    }
    
    矩阵* 和(int dim){
        矩阵* 和=NULL;
        if(dim==0){
            和=new 矩阵(1,w,(float)0);
            for(int i=0;i<h;i++){
                for(int j=0;j<w;j++){
                    (*和)[j]+=data[i*w+j];
                }
            }
        }
        else if(dim==1){
            和=new 矩阵(h,1,(float)0);
            for(int i=0;i<h;i++){
                for(int j=0;j<w;j++){
                    (*和)[i]+=data[i*w+j];
                }
            }
            
        }else{
            cout<<"仅支持对 0 或者 1 维的和操作";
        }
        return 和;
    }
       
    矩阵* minmax(void){
        矩阵* minmax=new 矩阵(1,2,(float)0);
        矩阵* 排序=new 矩阵(h,w,data,1);
        std::sort(排序->data,排序->data+N);// 对矩阵中的所有元素求最大，最小
        (*minmax)[1]=排序->data[N-1];//最大值
        (*minmax)[0]=排序->data[0]; //最小值
        return minmax;
    }
    
    矩阵* minmax(int dim){
        矩阵* minmax=NULL;
        if(dim==0){
            minmax=new 矩阵(2,w,(float)0);
            for(int i=0;i<w;i++){
                stringstream ss;
                ss<<":,"<<i;
                矩阵* 排序=(*this)[ss.str()];
                std::sort(排序->data,排序->data+排序->N);
                minmax->data[w+i]=排序->data[排序->N-1];//最大值
                minmax->data[i]=排序->data[0];//最小值
            }
        }
        else if(dim==1){
            minmax=new 矩阵(2,h,(float)0);
            for(int i=0;i<h;i++){
                stringstream ss;
                ss<<i<<",:";
                矩阵* 排序=(*this)[ss.str()];
                std::sort(排序->data,排序->data+排序->N);
                minmax->data[w+i]=排序->data[排序->N-1];
                minmax->data[i]=排序->data[0];
            }
           
        }else{
            cout<<"维度只能是 0 或者 1";
        }
        return minmax;
    }
    矩阵* arange(int start,int end){
        int L=end-start;
        矩阵* 行=NULL;
        行=new 矩阵(1,L,(float)0);
        for(int i=0;i<L;i++){
            行->data[i]=start+i;
        }
        return 行;
    }
    
    矩阵** meshgrid(矩阵* 行x, 矩阵* 行y,矩阵** 坐标阵){
        //矩阵* 坐标阵[]={NULL,NULL};
        坐标阵[0]=new 矩阵(1,行x->w,行x->data,1);
        坐标阵[1]=new 矩阵(行y->w,1,行y->data,1);
        矩阵* 行y转置=new 矩阵(行y->w,行y->h,行y->data,1);
        for(int i=1;i<行y->w;i++){
            坐标阵[0]=this->r_(坐标阵[0],行x);
        }
        for(int i=1;i<行x->w;i++){
            
            坐标阵[1]=this->c_(坐标阵[1],行y转置);
        }
        
        return 坐标阵;
    }
    
    float& operator[](int i){
        if(i>N || i<-N){
            cout<<"下标超出范围了"<<endl;
        }
        if(i<0){
            i=N+i;
        }
        return data[i];
    }
    
    int str2int(string ij){
        
        int int_ij=0;
        unsigned long L=ij.length();
        for(int i=0;i<L;i++){
            int tmp=ij[i]-'0';
            int_ij+=tmp*pow(10,L-i-1);
        }
        return int_ij;
    }
    
    void test_str2int(void){
        string teststr="1234";
        cout<<teststr<<"="<<str2int(teststr)<<endl;
        teststr="1000";
        cout<<teststr<<"="<<str2int(teststr)<<endl;
        
    }
    
    矩阵* c_(矩阵* 矩阵1,矩阵* 矩阵2){
        // 按列合并
        assert(矩阵1->h==矩阵2->h);
        矩阵* 矩阵3=new 矩阵(矩阵1->h,矩阵1->w+矩阵2->w,-2);
        for(int i=0;i<矩阵1->h;i++){
            for(int j=0;j<矩阵1->w;j++){
                矩阵3->data[i*矩阵3->w+j]=矩阵1->data[i*矩阵1->w+j];
            }
        }
        for(int i=0;i<矩阵2->h;i++){
            for(int j=0;j<矩阵2->w;j++){
                矩阵3->data[i*矩阵3->w+j+矩阵1->w]=矩阵2->data[i*矩阵2->w+j];
            }
        }
        return 矩阵3;
    }
    
    矩阵* r_(矩阵* 矩阵1,矩阵* 矩阵2){
        // 按列合并
        assert(矩阵1->w==矩阵2->w);
        矩阵* 矩阵3=new 矩阵(矩阵1->h+矩阵2->h,矩阵1->w,-2);
        for(int i=0;i<矩阵1->h;i++){
            for(int j=0;j<矩阵1->w;j++){
                矩阵3->data[i*矩阵3->w+j]=矩阵1->data[i*矩阵1->w+j];
            }
        }
        for(int i=0;i<矩阵2->h;i++){
            for(int j=0;j<矩阵2->w;j++){
                矩阵3->data[(i+矩阵1->h)*矩阵3->w+j]=矩阵2->data[i*矩阵2->w+j];
            }
        }
        return 矩阵3;
    }
    
    矩阵 operator+(矩阵& 矩阵1){
        assert(this->w==矩阵1.w);
        assert(this->h==矩阵1.h);
        矩阵* 果=new 矩阵(h,w,(float)0);
        for(int i=0;i<w;i++){
            for(int j=0;j<h;j++){
                果->data[j*w+i]=data[j*w+i]+矩阵1.data[j*w+i];
            }
        }
        return *(果);
    }
    
    template <typename T>
    矩阵 operator+(T value){
        矩阵* 矩阵1=new 矩阵(h,w,value);
        return operator+(*(矩阵1));
    }
    
    矩阵 operator-(矩阵& 矩阵1){
        assert(this->w==矩阵1.w);
        assert(this->h==矩阵1.h);
        矩阵* 果=new 矩阵(h,w,(float)0);
        for(int i=0;i<w;i++){
            for(int j=0;j<h;j++){
                果->data[j*w+i]=data[j*w+i]-矩阵1.data[j*w+i];
            }
        }
        return *(果);
    }
    
    template <typename T>
    矩阵 operator-(T value){
        矩阵* 矩阵1=new 矩阵(h,w,value);
        return operator-(*(矩阵1));
    }
    
    矩阵 operator*(矩阵& 矩阵1){
        assert(this->w==矩阵1.w);
        assert(this->h==矩阵1.h);
        矩阵* 果=new 矩阵(h,w,(float)0);
        for(int i=0;i<w;i++){
            for(int j=0;j<h;j++){
                果->data[j*w+i]=data[j*w+i]*矩阵1.data[j*w+i];
            }
        }
        return *(果);
    }
    
    template <typename T>
    矩阵 operator*(T value){
        矩阵* 矩阵1=new 矩阵(h,w,value);
        return operator*(*(矩阵1));
    }
    矩阵 operator/(矩阵& 矩阵1){
        assert(this->w==矩阵1.w);
        assert(this->h==矩阵1.h);
        矩阵* 果=new 矩阵(h,w,(float)0);
        for(int i=0;i<w;i++){
            for(int j=0;j<h;j++){
                果->data[j*w+i]=data[j*w+i]/矩阵1.data[j*w+i];
            }
        }
        return *(果);
    }
    
    template <typename T>
    矩阵 operator/(T value){
        矩阵* 矩阵1=new 矩阵(h,w,value);
        return operator/(*(矩阵1));
    }
    
    矩阵 operator>=(矩阵& 矩阵1){
        assert(this->w==矩阵1.w);
        assert(this->h==矩阵1.h);
        矩阵* 果=new 矩阵(h,w,(float)0);
        for(int i=0;i<w;i++){
            for(int j=0;j<h;j++){
                果->data[j*w+i]=0;
                if(data[j*w+i]>=矩阵1.data[j*w+i]){
                    果->data[j*w+i]=1;
                }
            }
        }
        return *(果);
    }
    
    template <typename T>
    矩阵 operator>=(T value){
        矩阵* 矩阵1=new 矩阵(h,w,value);
        return operator>=(*(矩阵1));
    }
    
    矩阵 operator==(矩阵& 矩阵1){
        assert(this->w==矩阵1.w);
        assert(this->h==矩阵1.h);
        矩阵* 果=new 矩阵(h,w,(float)0);
        for(int i=0;i<w;i++){
            for(int j=0;j<h;j++){
                果->data[j*w+i]=0;
                if(data[j*w+i]==矩阵1.data[j*w+i]){
                    果->data[j*w+i]=1;
                    
                }
            }
        }
        return *(果);
    }
    
    template <typename T>
    矩阵 operator==(T value){
        矩阵* 矩阵1=new 矩阵(h,w,value);
        return operator==(*(矩阵1));
    }
    
    矩阵* 转置(void){
        矩阵 原矩阵 =矩阵(*this);
        N=N;
        w=原矩阵.h;
        h=原矩阵.w;
        //data=new float[N];
        for(int i=0;i<w;i++){
            for(int j=0;j<h;j++){
                data[j*w+i]=原矩阵.取(i,j);
            }
        }
        return this;
    }
    矩阵* T(void){
        return 转置();
    }
    矩阵* 行(int i){
        stringstream ss;
        ss<<i<<",:";
        return operator[](ss.str());
    }
    矩阵* 行(int i,int j){
        stringstream ss;
        ss<<i<<":"<<j<<",:";
        return operator[](ss.str());
    }
    
    矩阵* 列(int i){
        stringstream ss;
        ss<<":,"<<i;
        return operator[](ss.str());
    }
    矩阵* 列(int i,int j){
        stringstream ss;
        ss<<":,"<<i<<":"<<j;
        return operator[](ss.str());
    }
    矩阵* 行们(int count,...){
        矩阵* 多行矩阵=NULL;
        va_list v;
        va_start(v,count);
        //cout<<"参数个数为:"<<count<<endl;
        for(int i=0;i<count;i++){
            int value=va_arg(v,int);
            行(value);
            if(!多行矩阵){
                多行矩阵=行(value);
            }else{
                多行矩阵=r_(多行矩阵,行(value));
            }
        }
        va_end(v);
        return 多行矩阵;
    }
    矩阵* 列们(int count,...){
        矩阵* 多列矩阵=NULL;
        va_list v;
        va_start(v,count);
        //cout<<"参数个数为:"<<count<<endl;
        for(int i=0;i<count;i++){
            int value=va_arg(v,int);
            行(value);
            if(!多列矩阵){
                多列矩阵=列(value);
            }else{
                多列矩阵=c_(多列矩阵,列(value));
            }
        }
        va_end(v);
        return 多列矩阵;
    }
    
    矩阵* operator[](string ij){
        unsigned long dou_i=ij.find(",",0);
        unsigned long dimention_i=ij.find(":",0);
        unsigned long dimention_ri=ij.rfind(":",ij.length());
        // 如果有多个:,就需要返回多行或者多列
        矩阵* 子矩阵=NULL;
        矩阵* 维=NULL;
        if(dimention_i<dimention_ri){
            // 0:2，:   or :,1:2
            if(dou_i-dimention_i==1){
                // :,1:2
                int 始列=str2int(ij.substr(dou_i+1,dimention_ri-dou_i-1));
                int 终列=str2int(ij.substr(dimention_ri+1,ij.length()-1-dimention_ri));
                for(int i=始列;i<终列;i++){
                    stringstream ss;
                    ss<<":,"<<i;
                    if(i==始列){
                        子矩阵=operator[](ss.str());
                    }
                    if(i>始列){
                        子矩阵=c_(子矩阵,operator[](ss.str()));
                    }
                }
                //两列合并
                return 子矩阵;
            }
            if(dou_i-dimention_i>1){
                //0:100,:
                int 始行=str2int(ij.substr(0,dimention_i));
                int 终行=str2int(ij.substr(dimention_i+1,dou_i-dimention_i-1));
                for(int i=始行;i<终行;i++){
                    stringstream ss;
                    ss<<i<<",:";
                    if(i==始行){
                        子矩阵=operator[](ss.str());
                    }
                    if(i>始行){
                        子矩阵=r_(子矩阵,operator[](ss.str()));
                    }
                }
                //两行合并
                return 子矩阵;
            }
        }
        
        unsigned long L=ij.length()-1;
        //cout<<"dou_i,dimention_i,length="<<dou_i<<","<<dimention_i<<","<<L<<endl;
        // 如果是取某列
        if(dimention_i<dou_i && dimention_i>=0){// [":,0"]
            //int j=ij[2]-'0';
            int j = str2int(ij.substr(dou_i+1,L-dou_i));
            //cout<<"第"<<j<<"列"<<endl;
            维= (new 矩阵(h,1,(float)0));
            for(int i=0;i<h;i++){
                维->data[i]=data[i*w+j];
            }
            return 维;
        }
        // 取某行
        if(dimention_i>dou_i && dimention_i<=L){//["1,:"]
            维= new 矩阵(1,w,(float)0);
            //int i=ij[0]-'0';
            int i = str2int(ij.substr(0,dou_i));
            for( int j=0;j<w;j++ ){
                维->data[j]=data[i*w+j];
            }
            return 维;
        }
        int i= str2int(ij.substr(0,dou_i));
        int j= str2int(ij.substr(dou_i+1,L-dou_i));
        //cout<<"i="<<i<<" j="<<j<<endl;
        
        维= (new 矩阵(1,1));
        维->data[0]=取(i,j);
        //cout<<(*维);
        return 维;
    }
    //friend ostream& operator<<(ostream &out,矩阵& m);
    friend ostream& operator<<(ostream &out,矩阵& m){
        cout<<"[";
        for(int i=0;i<m.h;i++){
            cout<<"[";
            for(int j=0;j<m.w;j++){
                //cout<<fixed<<setprecision(5)<<m.data[i*m.w+j];
                cout<<m.data[i*m.w+j];
                if(j<m.w-1){cout<<",";}
 
            }
            cout<<"]";
            if(i<m.h-1){cout<<","<<endl;}
        }
        cout<<"]"<<endl;
        return out;
    }
    
    ~矩阵(void){
        if(data!=NULL){
            delete []data;
            
        }
    }
    
    float& 取(int i, int j){
        int n=i*w+j;
        return operator[](n);
    }
    
    
    
};
#endif /* ___hpp */