operators.h

数据结构学习的小例子

#ifndef OPER_H
#define OPER_H
#include <iostream>
#include <string>
#include <cstdlib>
#include "matrix.h"
namespace mylib{
	template<typename datatype,typename type>
	matrix<datatype> operator* (const datatype data,
		                        const matrix<type>& mat)
	{
		matrix<datatype> ret(mat.line_size(),mat.row_size());
		for(size_t i = 0;i < mat.line_size(); ++i)
			for(size_t j = 0;j < mat.row_size(); ++j)
				ret[i][j] = mat[i][j] * data;
 
		return matrix<datatype>(ret);
	}
	template<typename datatype,typename type>
	matrix<datatype> operator* (const matrix<type>& mat,
	                            const datatype data)
	{
		return matrix<datatype>(data * mat);
	}
	template<typename type>
	matrix<type> operator+ (const matrix<type>& lmat,
	                        const matrix<type>& rmat)
	{
		try{
			if((lmat.line_size() != rmat.line_size())
				||(lmat.row_size() != rmat.row_size()))
				throw std::string("非同维矩阵不能相加!");
		}
		catch(std::string& e)
		{
			std::cout << e << std::endl;
			std::exit(1);
		}
		matrix<type> ret(lmat.line_size(),lmat.row_size());
		for(size_t i = 0;i < lmat.line_size(); ++i)
			for(size_t j = 0;j < lmat.row_size(); ++j)
				ret[i][j] = lmat[i][j] + rmat[i][j];
 
		return matrix<type>(ret);
	}
	template<typename type>
	matrix<type> operator* (const matrix<type>& lmat,
	                        const matrix<type>& rmat)
	{
		try{
			if(lmat.row_size() != rmat.line_size())
				throw std::string("lmat.row_size() != rmat.line_size()!");
		}
		catch(std::string& e)
		{
			std::cout << e << std::endl;
			std ::exit(1);
		}
		matrix<type> ret(lmat.line_size(),rmat.row_size());
		for(size_t i = 0;i < ret.line_size(); ++i)
			for(size_t j = 0;j < ret.row_size(); ++j)
				for(size_t k = 0;k < lmat.row_size(); ++k)
   					ret[i][j] += lmat[i][k] * rmat[k][j];
 
		return matrix<type>(ret);
	}
	template<typename type>
	matrix<type> transpose(const matrix<type>& mat)
	{
		matrix<type> ret(mat.row_size(),mat.line_size());
		for(size_t i = 0;i < mat.line_size(); ++i)
			for(size_t j = 0;j < mat.row_size(); ++j)
				ret[j][i] = mat[i][j];
		return matrix<type>(ret);
	}
	template<typename type>
	std::istream& operator>> (std::istream& in,matrix<type>& mat)
	{
		for(size_t i = 0;i < mat.line_size();++i)
			for(size_t j = 0; j < mat.row_size(); ++j)
				in >> mat[i][j]  ;
		return in;
	}
	template<typename type>
	std::ostream& operator<< (std::ostream& out,matrix<type>& mat)
	{
		 for(size_t i = 0;i < mat.line_size();++i)
		 {
			 for(size_t j = 0; j < mat.row_size(); ++j)
				 out << mat[i][j] << " " ;
			 out << endl;
		 }
		 return out;
	}
}

#endif