zoukankan      html  css  js  c++  java
  • Matrix

    //transpote转置矩阵
    #include "Stdio.h"
    #include "memory.h"
    template<typename T>
    void TypePrint(T v);
     
    template<typename T,int M,int N>
    class Matrix
    {
    public:
        Matrix(void){
     
            data = new T[M*N];
     
        };
        ~Matrix(void){};
     
        int getVIndex()
        {
            return M;
        }
        int getHIndex()
        {
            return N;
        }
     
        T getxy(int x, int y)
        {
            return data[x*N+y];
        }
     
        void setxy(int x, int y,T f)
        {
            data[x*N + y] = f;
        }
     
        void setdata(T*datap,int size)
        {
            memcpy(data,datap,size);
        }
     
        Matrix<T,N,M> transpote()
        {
            Matrix<T,N,M> m;
            for(int i = 0; i < M; i++)
            {
                for(int j = 0; j < N; j++)
                {
                    m.setxy(j,i,getxy(i,j));
                }
            }
            return m;
     
        }
     
        Matrix<T,M,N> operator+(Matrix<T,M,N> &adv)
        {
            Matrix<T,N,M> m;
            for(int i = 0; i < M; i++)
            {
                for(int j = 0; j < N; j++)
                {
                    m.setxy(getxy(i,j)+adv.getxy(i,j));
                }
            }
            return m;
        }
     
        Matrix<T,M,N> operator-(Matrix<T,M,N> &adv)
        {
            Matrix<T,N,M> m;
            for(int i = 0; i < M; i++)
            {
                for(int j = 0; j < N; j++)
                {
                    m.setxy(getxy(i,j)-adv.getxy(i,j));
                }
            }
            return m;
        }
     
        bool operator==(Matrix<T,M,N> &adv)
        {
            Matrix<T,N,M> m;
            for(int i = 0; i < M; i++)
            {
                for(int j = 0; j < N; j++)
                {
                    if(getxy(i,j)!=adv.getxy(i,j))return false;
                }
            }
            return true;
        }
     
        bool operator!=(Matrix<T,M,N> &adv)
        {
            Matrix<T,N,M> m;
            for(int i = 0; i < M; i++)
            {
                for(int j = 0; j < N; j++)
                {
                    if(getxy(i,j)!=adv.getxy(i,j))return true;
                }
            }
            return false;
        }
     
        void print()
        {
            printf(" ");
            for(int i = 0; i < M; i++)
            {
                for(int j = 0; j < N; j++)
                {
                    TypePrint(getxy(i,j));
                    printf(", ");
                }
                printf(" ");
            }
        }
     
    private:
     
        T *data;
     
    };
     
    template<typename T,int M,int N,int P>
    Matrix<T,M,P> operator*(Matrix<T,M,N> &x, Matrix<T,N,P> &y)
    {
        Matrix<T,M,P> m;
     
        for(int i = 0; i < M; i++)
        {
            for(int j = 0; j < P; j++)
            {
                T v = 0;
     
                for(int k = 0; k < N; k++)
                {
                    v += (x.getxy(i,k)*y.getxy(k,j));
                }
     
                m.setxy(i,j,v);
     
            }
        }
     
        return m;
    }
     
    template<typename T,int M,int N>
    Matrix<T,M,N> operator*(Matrix<T,M,N> &x, T y)
    {
        Matrix<T,M,N> m;
     
        for(int i = 0; i < M; i++)
        {
            for(int j = 0; j < N; j++)
            {
                m.setxy(i,j,m.getxy(i,j)*y);
            }
        }
     
        return m;
    }
     
    template<typename T,int M,int N>
    Matrix<T,M,N> operator*(T y,Matrix<T,M,N> &x)
    {
        return x*y;
    }
     
     
     
     
    template<>
    void TypePrint(float v)
    {
        printf("%f",v);
    }
     
     
    template<>
    void TypePrint(int v)
    {
        printf("%d",v);
    }
     
    #define type float
     
     
     
    int d1[] =
    {
        1,2,
        2,3,
        3,0
    };
     
    int d2[] =
    {
        2,-3,0,
        0,1,-2,
        -4,5,10
    };
     
     
     
    int main()
    {
        Matrix<int,3,2> s;
     
        s.setdata(d1,sizeof(d1));
     
        Matrix<int,3,3> s1;
         
        s1.setdata(d2,sizeof(d2));
         
        Matrix<int,3,2> s2 = s1*s;
         
        Matrix<int,2,3> s3 = s2.transpote();//转置了
         
        s.print();
        s1.print();
        s2.print();
        s3.print();
        return 0;
    }
  • 相关阅读:
    2
    spring jdbcTemplate 基本使用
    Day38-数据库入门学习
    DAY37-Python入门学习-进程池与线程池、协程、gevent模块
    Python入门学习-DAY36-GIL全局解释器锁、死锁现象与递归锁、信号量、Event事件、线程queue
    Python入门学习-DAY35-线程
    Python入门学习-DAY34-开启进程的两种方法、join方法、进程之间内存空间互相隔离、进程对象其他相关的属性或方法、僵尸进程与孤儿进程、守护进程、互斥锁
    Python入门学习-DAY33-基于UDP的套接字、socketserver模块、进程简单介绍
    Python入门学习-DAY32-链接循环与通信循环,粘包问题,远程控制,文件上传与下载
    Python入门学习-DAY31-三次握手原理与四次挥手,socket
  • 原文地址:https://www.cnblogs.com/zhoug2020/p/7803888.html
Copyright © 2011-2022 走看看