C++元编程——四维矩阵简单运算实现

最新推荐文章于 2024-07-25 09:47:19 发布
最新推荐文章于 2024-07-25 09:47:19 发布
阅读量1k 收藏
点赞数
分类专栏： 元编程学习实践 文章标签： c++ 矩阵 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dr_Jack/article/details/127944157
版权

基于原来的矩阵，进行了魔改，形成了四维矩阵的点积运算，效果拔群，对于矩阵的运算有效。老规矩，先上测试代码：

#include "mat.hpp"

int main(int argc, char** argv)
{
	mat<3, 1, mat<2, 2, double > > m3d{1,2,3};
	m3d.print();
	mat<1, 3, mat<2, 2, double> > m3d2{ {1,2,3,4},{2,3,4,5},{3,4,5,6} };
	m3d2.print();
	auto k = m3d.dot(m3d2);
	k.print();
	return 0;
}

四维矩阵是一个二维矩阵，其每个元素都是一个二维矩阵。点积运算规则和二维一致，只是每个元素的运算换做了矩阵对应元素的对乘，对加，仅此而已。但是这却完全体现出了C++元编程的牛X之处。如果是运行时，你就要重新定义一个类型，然后定义这个类型的加减乘除。但是元编程不用，如果推导合理，但是你必须把普通标量运算实现出矩阵版本。运行结果如下：

结果也是NICE的，正确算出了这两个四维矩阵的点积。下面是修改的代码。

base_function.hpp对原来的点积运算参数推导进行了细化：

#ifndef _BASE_FUNCTION_HPP_
#define _BASE_FUNCTION_HPP_

#include "base_logic.hpp"

template<typename func_t>
auto derivative(func_t&& f, const decltype(f(0))& v)
{
	constexpr double SMALL_VAL = 1e-11;
	return (f(v + SMALL_VAL) - f(v - SMALL_VAL)) / (2. * SMALL_VAL);
}

/* 点乘运算 */
template<int r1, int c1, int r2, int c2, int i1, int i2, int i3, typename vt = double>
inline vt n_dot(const mat<i1, i2, vt>& mt1, const mat<i2, i3, vt>& mt2)
{
	static_assert(c1 == r2, "[matrix dot error]\tleft matrix column number do not match right matrix's row number.");
	if constexpr (c1 != 0 || r2 != 0)
	{
		return mt1.get_val<r1, c1>() * mt2.get_val<r2, c2>() + n_dot<r1, c1 - 1, r2 - 1, c2>(mt1, mt2);
	}
	if constexpr (c1 == 0 && r2 == 0)
	{
		return mt1.get_val<r1, c1>() * mt2.get_val<r2, c2>();
	}
}

template<int r, int c>
class v_dot
{
public:
	template<int i1, int i2, int i3, typename vt = double>
	static vt cal(const mat<i1, i2, vt>& mt1, const mat<i2, i3, vt>& mt2)
	{
		return n_dot<r, mt1.c - 1, mt2.r - 1, c>(mt1, mt2);
	}
};

template<int row_num1, int col_num1, int row_num2, int col_num2, typename val_t = double>
mat<row_num1, col_num2, val_t> dot(const mat<row_num1, col_num1, val_t>& mt1, const mat<row_num2, col_num2, val_t>& mt2)
{

	using omatt = mat<row_num1, col_num2, val_t>;
	using imatt1 = mat<row_num1, col_num1, val_t>;
	using imatt2 = mat<row_num2, col_num2, val_t>;
	omatt mt_ret;
	col_loop<col_num2 - 1, v_dot>(mt_ret, mt1, mt2);
	return mt_ret;
}

/* 加法运算 */
template<int r, int c>
class v_add
{
public:
	template<typename imatt1, typename imatt2, typename vt = double>
	static vt cal(const imatt1& mt1, const imatt2& mt2)
	{
		return mt1.get_val<r, c>() + mt2.get_val<r, c>();
	}
};

template<int r, int c>
class n_add
{
public:
	template<typename imatt2, typename vt = double>
	static vt cal(const vt& mt1, const imatt2& mt2)
	{
		return mt1 + mt2.get_val<r, c>();
	}
};

template<int r, int c>
struct c_add
{
	template<int row_num, int col_num, typename vt>
	static vt cal(const mat<row_num, col_num, vt>& mt, const mat<row_num, 1, vt>& v)
	{
		return mt.get_val<r, c>() + v.get_val<r, 0>();
	}
};

template<int r, int c>
struct r_add
{
	template<int row_num, int col_num, typename vt>
	static vt cal(const mat<row_num, col_num, vt>& mt, const mat<1, col_num, vt>& v)
	{
		return mt.get_val<r, c>() + v.get_val<0, c>();
	}
};

template<int row_num, int col_num, typename val_t = double>
mat<row_num, col_num, val_t> operator+(const mat<row_num, col_num, val_t>& mt1, const mat<row_num, col_num, val_t>& mt2)
{
	using omatt = mat<row_num, col_num, val_t>;
	omatt mt_ret;
	col_loop<col_num - 1, v_add>(mt_ret, mt1, mt2);
	return mt_ret;
}

template<int row_num, int col_num, typename val_t = double>
mat<row_num, col_num, val_t> operator+(const val_t& v, const mat<row_num, col_num, val_t>& mt)
{
	using omatt = mat<row_num, col_num, val_t>;
	omatt mt_ret;
	col_loop<col_num - 1, n_add>(mt_ret, v, mt);
	return mt_ret;
}

template<int row_num, int col_num, typename val_t = double>
mat<row_num, col_num, val_t> operator+(const mat<row_num, col_num, val_t>& mt, const val_t& v)
{
	using omatt = mat<row_num, col_num, val_t>;
	omatt mt_ret;
	col_loop<col_num - 1, n_add>(mt_ret, v, mt);
	return mt_ret;
}

template<int row_num, int col_num, typename val_t_other, typename val_t = double>
mat<row_num, col_num, val_t> operator+(const mat<row_num, col_num, val_t>& mt, const val_t_other& v)
{
	return mt + static_cast<val_t>(v);
}

template<int row_num, int col_num, typename val_t_other, typename val_t = double>
mat<row_num, col_num, val_t> operator+(const val_t_other& v, const mat<row_num, col_num, val_t>& mt)
{
	return mt + static_cast<val_t>(v);
}

template<int row_num, int col_num, typename val_t = double>
void spread_add(mat<row_num, col_num, val_t>& mt_ret, const mat<row_num, col_num, val_t>& mt, const mat<row_num, 1, val_t>& v)
{
	col_loop<col_num - 1, c_add>(mt_ret, mt, v);
}

template<int row_num, int col_num, typename val_t = double>
void spread_add(mat<row_num, col_num, val_t>& mt_ret, const mat<row_num, col_num, val_t>& mt, const mat<1, col_num, val_t>& v)
{
	col_loop<col_num - 1, r_add>(mt_ret, mt, v);
}

template<int row_num, int col_num, typename val_t = double>
void spread_add(mat<row_num, col_num, val_t>& mt_ret, const mat<row_num, col_num, val_t>& mt, const mat<1, 1, val_t>& v)
{
	col_loop<col_num - 1, n_add>(mt_ret, v.get_val<0, 0>(), mt);
}

template<int row_num, int col_num, typename val_t = double>
void spread_add(mat<row_num, col_num, val_t>& mt_ret, const mat<row_num, 1, val_t>& v, const mat<row_num, col_num, val_t>& mt)
{
	col_loop<col_num - 1, c_add>(mt_ret, mt, v);
}

template<int row_num, int col_num, typename val_t = double>
void spread_add(mat<row_num, col_num, val_t>& mt_ret, const mat<1, col_num, val_t>& v, const mat<row_num, col_num, val_t>& mt)
{
	col_loop<col_num - 1, r_add>(mt_ret, mt, v);
}

template<int row_num, int col_num, typename val_t = double>
void spread_add(mat<row_num, col_num, val_t>& mt_ret, const mat<1, 1, val_t>& v, const mat<row_num, col_num, val_t>& mt)
{
	col_loop<col_num - 1, n_add>(mt_ret, v.get_val<0, 0>(), mt);
}

template<typename val_t = double>
void spread_add(mat<1, 1, val_t>& mt_ret, const mat<1, 1, val_t>& v, const mat<1, 1, val_t>& mt)
{
	col_loop<0, n_add>(mt_ret, v.get_val<0, 0>(), mt.get_val<0, 0>);
}

/* 减法运算 */
template<int r, int c>
class v_minus
{
public:
	template<typename imatt1, typename imatt2, typename vt = double>
	static vt cal(const imatt1& mt1, const imatt2& mt2)
	{
		return mt1.get_val<r, c>() - mt2.get_val<r, c>();
	}
};

template<int r, int c>
class n_minus
{
public:
	template<int mat_r, int mat_c, typename vt = double>
	static vt cal(const vt& v, const mat<mat_r, mat_c, vt>& mt2)
	{
		return v - mt2.get_val<r, c>();
	}

	template<int mat_r, int mat_c, typename vt = double>
	static vt cal(const mat<mat_r, mat_c, vt>& mt2, const vt& v)
	{
		return mt2.get_val<r, c>() - v;
	}
};

template<int row_num, int col_num, typename val_t = double>
mat<row_num, col_num, val_t> operator-(const mat<row_num, col_num, val_t>& mt1, const mat<row_num, col_num, val_t>& mt2)
{
	using omatt = mat<row_num, col_num, val_t>;
	omatt mt_ret;
	col_loop<col_num - 1, v_minus>(mt_ret, mt1, mt2);
	return mt_ret;
}

template<int row_num, int col_num, typename val_t = double>
mat<row_num, col_num, val_t> operator-(const val_t& v, const mat<row_num, col_num, val_t>& mt)
{
	using omatt = mat<row_num, col_num, val_t>;
	omatt mt_ret;
	col_loop<col_num - 1, n_minus>(mt_ret, v, mt);
	return mt_ret;
}

template<int row_num, int col_num, typename val_t = double>
mat<row_num, col_num, val_t> operator-(const mat<row_num, col_num, val_t>& mt, const val_t& v)
{
	using omatt = mat<row_num, col_num, val_t>;
	omatt mt_ret;
	col_loop<col_num - 1, n_minus>(mt_ret, mt, v);
	return mt_ret;
}

template<int row_num, int col_num, typename val_t_other, typename val_t = double>
mat<row_num, col_num, val_t> operator-(const mat<row_num, col_num, val_t>& mt, const val_t_other& v)
{
	return mt - static_cast<val_t>(v);
}

template<int row_num, int col_num, typename val_t_other, typename val_t = double>
mat<row_num, col_num, val_t> operator-(const val_t_other& v, const mat<row_num, col_num, val_t>& mt)
{
	return (static_cast<val_t>(v) - mt);
}

/* 乘法运算 */
template<int r, int c>
class n_mul
{
public:
	template<typename imatt2, typename vt = double>
	static vt cal(const vt& mt1, const imatt2& mt2)
	{
		return mt1 * mt2.get_val<r, c>();
	}
};

template<int r, int c>
class v_mul
{
public:
	template<typename imatt1, typename imatt2, typename vt = double>
	static vt cal(const imatt1& mt1, const imatt2& mt2)
	{
		return mt1.get_val<r, c>() * mt2.get_val<r, c>();
	}
};

template<int row_num, int col_num, typename val_t = double>
mat<row_num, col_num, val_t> operator*(const val_t& v, const mat<row_num, col_num, val_t>& mt)
{
	using omatt = mat<row_num, col_num, val_t>;
	omatt mt_ret;
	col_loop<col_num - 1, n_mul>(mt_ret, v, mt);
	return mt_ret;
}

template<int row_num, int col_num, typename val_t = double>
mat<row_num, col_num, val_t> operator*(const mat<row_num, col_num, val_t>& mt, const val_t& v)
{
	using omatt = mat<row_num, col_num, val_t>;
	omatt mt_ret;
	col_loop<col_num - 1, n_mul>(mt_ret, v, mt);
	return mt_ret;
}

template<int row_num, int col_num, typename val_t = double>
mat<row_num, col_num, val_t> operator*(const mat<row_num, col_num, val_t>& mt1, const mat<row_num, col_num, val_t>& mt2)
{
	using omatt = mat<row_num, col_num, val_t>;
	omatt mt_ret;
	col_loop<col_num - 1, v_mul>(mt_ret, mt1, mt2);
	return mt_ret;
}

/* 除法 */
template<int r, int c>
class n_div
{
public:
	template<int row_num, int col_num, typename vt = double>
	static vt cal(const mat<row_num, col_num, vt>& mt, const vt& v)
	{
		return mt.get_val<r, c>() / v;
	}

	template<int row_num, int col_num, typename vt = double>
	static vt cal(const vt& v, const mat<row_num, col_num, vt>& mt)
	{
		return v / mt.get_val<r, c>();
	}
};

template<int r, int c>
class v_div
{
public:
	template<int row_num, int col_num, typename vt = double>
	static vt cal(const mat<row_num, col_num, vt>& mt1, const mat<row_num, col_num, vt>& mt2)
	{
		return mt1.get_val<r, c>() / mt2.get_val<r, c>();
	}
};

template<int row_num, int col_num, typename val_t>
mat<row_num, col_num, val_t> operator/(const mat<row_num, col_num, val_t>& mt, const val_t& v)
{
	using omatt = mat<row_num, col_num, val_t>;
	omatt mt_ret;
	col_loop<col_num - 1, n_div>(mt_ret, mt, v);
	return mt_ret;
}

template<int row_num, int col_num, typename val_t>
mat<row_num, col_num, val_t> operator/(const val_t& v, const mat<row_num, col_num, val_t>& mt)
{
	using omatt = mat<row_num, col_num, val_t>;
	omatt mt_ret;
	col_loop<col_num - 1, n_div>(mt_ret, v, mt);
	return mt_ret;
}

template<int row_num, int col_num, typename vt>
mat<row_num, col_num, vt> operator/(const mat<row_num, col_num, vt>& mt1, const mat<row_num, col_num, vt>& mt2)
{
	using omatt = mat<row_num, col_num, vt>;
	omatt mt_ret;
	col_loop<col_num - 1, v_div>(mt_ret, mt1, mt2);
	return mt_ret;
}

template<int r, int c>
class n_sqrt
{
public:
	template<typename imatt, typename vt = double>
	static vt cal(const imatt& mt)
	{
		return sqrtl(mt.get_val<r, c>());
	}
};

template<int row_num, int col_num, typename val_t = double>
mat<row_num, col_num, val_t> sqrtm(const mat<row_num, col_num, val_t>& mt)
{
	using omatt = mat<row_num, col_num, val_t>;
	omatt mt_ret;
	col_loop<col_num - 1, n_sqrt>(mt_ret, mt);
	return mt_ret;
}

/* exp运算 */
template<int r, int c>
struct n_exp
{
	template<typename imatt>
	static typename imatt::type cal(const imatt& mt)
	{
		return exp(mt.get_val<r, c>());
	}
};

template<int row_num, int col_num, typename val_t = double>
mat<row_num, col_num, val_t> expm(const mat<row_num, col_num, val_t>& mt)
{
	using omatt = mat<row_num, col_num, val_t>;
	omatt mt_ret;
	col_loop<col_num - 1, n_exp>(mt_ret, mt);
	return mt_ret;
}

/* 卷积运算 */
template<int row_base, int col_base, int row_delta, int col_delta, typename imat_origin, typename imat_tpl>
inline auto col_loop_mul(const imat_origin& mt_origin, const imat_tpl& mt_tpl)
{
	if constexpr (col_delta != 0)
	{
		return mt_origin.get_val<row_base + row_delta, col_base + col_delta>() * mt_tpl.get_val<row_delta, col_delta>()
			+ col_loop_mul<row_base, col_base, row_delta, col_delta - 1, imat_origin, imat_tpl>(mt_origin, mt_tpl);
	}
	if constexpr (col_delta == 0)
	{
		return mt_origin.get_val<row_base + row_delta, col_base + col_delta>() * mt_tpl.get_val<row_delta, col_delta>();
	}
}

template<int row_base, int col_base, int row_delta, int col_delta, typename imat_origin, typename imat_tpl>
inline auto row_loop_add(const imat_origin& mt_origin, const imat_tpl& mt_tpl)
{
	if constexpr (row_delta != 0)
	{
		return col_loop_mul<row_base, col_base, row_delta, col_delta>(mt_origin, mt_tpl)
			+ col_loop_mul<row_base, col_base, row_delta - 1, col_delta>(mt_origin, mt_tpl);
	}
	if constexpr (row_delta == 0)
	{
		return col_loop_mul<row_base, col_base, row_delta, col_delta>(mt_origin, mt_tpl);
	}
}

template<int r, int c>
struct v_inner_conv
{
	template<typename imat_origin_t, typename imat_tpl_t, typename val_t = double>
	inline static auto cal(const imat_origin_t& mt_origin, const imat_tpl_t& mt_tpl)
	{
		return row_loop_add<r, c, imat_tpl_t::r - 1, imat_tpl_t::c - 1>(mt_origin, mt_tpl);
	}
};

constexpr int get_step_inner_size(int i_origin, int i_tpl, int i_step)
{
	return (i_origin - i_tpl) / i_step + 1;
}

constexpr int get_pad_size(int i_origin, int i_tpl, int i_step)
{
	return (((i_origin - i_tpl) / i_step) + (((i_origin - i_tpl) % i_step) == 0 ? 0 : 1)) * i_step - (i_origin - i_tpl);
}

constexpr int get_ceil_div(int i_origin, int i_tpl)
{
	return (i_origin / i_tpl + ((i_origin % i_tpl) == 0 ? 0 : 1));
}

template<int input_row, int intput_col, int tpl_row, int tpl_col, int row_step, int col_step>
struct pad_size_t
{
	static constexpr int top = get_pad_size(input_row, tpl_row, row_step) / 2;
	static constexpr int left = get_pad_size(intput_col, tpl_col, col_step) / 2;
	static constexpr int right = get_pad_size(intput_col, tpl_col, col_step) - left;
	static constexpr int bottom = get_pad_size(input_row, tpl_row, row_step) - top;
};

template<int row_step, int col_step, int row_num, int col_num, int tpl_row, int tpl_col, typename val_t>
inline mat<get_step_inner_size(row_num, tpl_row, row_step), get_step_inner_size(col_num, tpl_col, col_step), val_t>
inner_conv(const mat<row_num, col_num, val_t>& mt_origin, const mat<tpl_row, tpl_col, val_t>& mt_tpl)
{
	using ret_type = mat<get_step_inner_size(row_num, tpl_row, row_step), get_step_inner_size(col_num, tpl_col, col_step), val_t>;
	ret_type mt_ret;
	col_loop<ret_type::c - 1, v_inner_conv>(mt_ret, mt_origin, mt_tpl);
	return mt_ret;
}

template<typename mat_t, typename ...mat_ts>
struct st_one_col
{
	static constexpr int all_size = (mat_t::r * mat_t::c) + st_one_col<mat_ts...>::all_size;
};

template<typename mat_t>
struct st_one_col<mat_t>
{
	static constexpr int all_size = (mat_t::r * mat_t::c);
};

template<typename mat_t, typename ...mat_ts>
void concat_mat(typename mat_t::type* p, const mat_t& mt, const mat_ts... mts)
{
	constexpr int cpy_size = mat_t::r * mat_t::c;
	memcpy(p, mt.pval->p, cpy_size * sizeof(mat_t::type));
	if constexpr (0 != sizeof...(mat_ts))
		concat_mat(p + cpy_size, mts...);
}

template<typename mat_t, typename ...mat_ts>
mat<st_one_col<mat_t, mat_ts...>::all_size, 1> stretch_one_col(const mat_t& mt, const mat_ts&...mts)
{
	using ret_type = mat<st_one_col<mat_t, mat_ts...>::all_size, 1>;
	ret_type ret;
	concat_mat(ret.pval->p, mt, mts...);
	return ret;
}


template<typename mat_t, typename ...mat_ts>
void split_mat(typename mat_t::type* p, const mat_t& mt, const mat_ts... mts)
{
	constexpr int cpy_size = mat_t::r * mat_t::c;
	memcpy(mt.pval->p, p, cpy_size * sizeof(mat_t::type));
	if constexpr (0 != sizeof...(mat_ts))
		split_mat(p + cpy_size, mts...);
}

template<typename mat_t, typename ...mat_ts>
void split_one_mat(const mat_t& mt, const mat_ts&...mts)
{
	split_mat(mt.pval->p, mts...);
}

#endif

矩阵类型定义mat.hpp，增加了输出函数的运算符，用来打印结果：

#ifndef _MAT_HPP_
#define _MAT_HPP_
#include <climits>

#include <map>
#include <iostream>
#include <iomanip>
#ifdef USE_BOOST
#include <boost/pool/pool.hpp>
#endif

template<int i_size, typename val_t>
struct mat_m
{
#ifdef USE_BOOST
	static boost::pool<> s_pool;
#endif
	val_t* p;
	mat_m() :p(nullptr)
	{
		//p = (val_t*)malloc(sz * sizeof(val_t));
#ifdef USE_BOOST
		p = (val_t*)(s_pool.malloc());
		for (int i = 0; i < i_size; ++i)
		{
			p[i] = 0;
		}
#else
		//p = (val_t*)malloc(i_size * sizeof(val_t));
		p = new val_t[i_size];
#endif

	}
	~mat_m()
	{
		if (p)
		{
#ifdef USE_BOOST
			s_pool.free(p);
#else
			//free(p);
			delete[] p;
#endif
		}
	}
	val_t& get(const int& len_1d, const int& i_1d_idx, const int& i_2d_idx)
	{
		val_t& ret = p[i_2d_idx + len_1d * i_1d_idx];
		/*
		if (ret != 0.000 && abs(ret) < (DBL_MIN))
		{
			p[i_2d_idx + len_1d * i_1d_idx] = static_cast<val_t>(DBL_MIN * (ret < 0 ? -1. : 1.));
		}*/
		return ret;
	}

	val_t max_abs() const
	{
		double d = -1 * DBL_MAX;
		for (int i = 0; i < i_size; ++i)
		{
			d = d < abs(p[i]) ? abs(p[i]) : d;
		}
		return d;
	}

	val_t max() const
	{
		double d = -1 * DBL_MAX;
		for (int i = 0; i < i_size; ++i)
		{
			d = d < (p[i]) ? (p[i]) : d;
		}
		return d;
	}

	val_t sum() const
	{
		double d_sum = 0.;
		for (int i = 0; i < i_size; ++i)
		{
			d_sum += p[i];
		}
		return d_sum;
	}

	template<int len_1d, int i_1d_idx, int i_2d_idx>
	inline val_t& get_val()
	{
		static_assert((i_2d_idx + len_1d * i_1d_idx) < i_size, "ERROR:mat_m over flow！！！");
		return p[i_2d_idx + len_1d * i_1d_idx];
	}

	template<int len_1d, int i_1d_idx, int i_2d_idx>
	inline val_t get_val() const
	{
		return p[i_2d_idx + len_1d * i_1d_idx];
	}
};

#ifdef USE_BOOST
template<int i_size, typename val_t>
boost::pool<> mat_m<i_size, val_t>::s_pool = boost::pool<>(i_size * sizeof(val_t));
#endif

template<int row_num, int col_num, typename val_t = double>
struct mat
{

	//template<int row_num, int col_num, typename val_t = double>
	friend std::ostream& operator<<(std::ostream& cout, const mat<row_num, col_num, val_t>& mt)
	{
		std::cout << "[" ;
		for (int i = 0; i < row_num; ++i)
		{
			std::cout  << "[";
			for (int j = 0; j < col_num; ++j)
			{
				std::cout << (j != 0 ? "," : "") << mt.get(i, j);
			}
			std::cout << "]" ;
		}
		std::cout << "]" ;
		return std::cout;
	}

	using type = val_t;
	typedef val_t vt;
	static constexpr int r = row_num;
	static constexpr int c = col_num;
	using mat_m_t = mat_m<row_num* col_num, val_t>;
	std::shared_ptr<mat_m_t> pval;
	bool b_t;
	mat() :b_t(false)
	{
		pval = std::make_shared<mat_m_t>();
	}
	mat(const mat<row_num, col_num, val_t>& other) :pval(other.pval), b_t(other.b_t)
	{
	}
	mat(const val_t&& v) :b_t(false)
	{
		pval = std::make_shared<mat_m_t>();
		for (int i = 0; i < row_num; ++i)
		{
			for (int j = 0; j < col_num; ++j)
			{
				pval->get(col_num, i, j) = v;
			}
		}
	}
	mat(const std::initializer_list<val_t>& lst) :b_t(false)
	{
		pval = std::make_shared<mat_m_t>();
		auto itr = lst.begin();
		for (int i = 0; i < row_num; ++i)
		{
			for (int j = 0; j < col_num; ++j)
			{
				if (itr == lst.end())return;
				pval->get(col_num, i, j) = *itr;
				itr++;
			}
		}
	}

	val_t& get(const int& i_row, const int& i_col)
	{
		if (!b_t)
			return pval->get(col_num, i_row, i_col);
		else
			return pval->get(row_num, i_col, i_row);
	}

	val_t get(const int& i_row, const int& i_col) const
	{
		if (!b_t)
			return pval->get(col_num, i_row, i_col);
		else
			return pval->get(row_num, i_col, i_row);
	}

	template<int i_1d_idx, int i_2d_idx>
	inline val_t& get_val()
	{
		if (!b_t)
			return pval->get_val<col_num, i_1d_idx, i_2d_idx>();
		else
			return pval->get_val<row_num, i_2d_idx, i_1d_idx>();
	}

	template<int i_1d_idx, int i_2d_idx>
	inline val_t get_val() const
	{
		static_assert(i_1d_idx < row_num&& i_2d_idx < col_num, "ERROR: mat::get_val overflow!!!!!");
		if (!b_t)
			return pval->get_val<col_num, i_1d_idx, i_2d_idx>();
		else
			return pval->get_val<row_num, i_2d_idx, i_1d_idx>();
	}

	mat<col_num, row_num, val_t> t()
	{
		mat<col_num, row_num, val_t> ret;
		ret.pval = pval;
		ret.b_t = !b_t;
		return ret;
	}

	val_t max_abs() const
	{
		return pval->max_abs();
	}

	val_t max() const
	{
		return pval->max();
	}

	val_t sum() const
	{
		return pval->sum();
	}

	void print() const
	{
		std::cout << "[" << std::endl;
		for (int i = 0; i < row_num; ++i)
		{
			std::cout << std::setw(3) << "[";
			for (int j = 0; j < col_num; ++j)
			{
				std::cout << (j != 0 ? "," : "") << std::setw(10) << get(i, j);
			}
			std::cout << std::setw(3) << "]" << std::endl;
		}
		std::cout << "]" << std::endl;
	}

	template<int other_col_num>
	mat<row_num, other_col_num, val_t> dot(const mat<col_num, other_col_num, val_t>& mt) const
	{
		return ::dot(*this, mt);
	}

	mat<row_num, col_num, val_t> rot180() const
	{
		mat<row_num, col_num, val_t> ret;
		for (int r = 0; r < row_num; ++r)
		{
			for (int c = 0; c < col_num; ++c)
			{
				ret.get(r, c) = get(row_num - 1 - r, col_num - 1 - c);
			}
		}
		return ret;
	}

	template<int row_base, int col_base, int row_num_other, int col_num_other>
	void assign(const mat<row_num_other, col_num_other, val_t>& mt_other)
	{
		/* 这里不麻烦了，直接写成运行时 */
		for (int r = 0; r < row_num_other; ++r)
		{
			for (int c = 0; c < col_num_other; ++c)
			{
				if (r + row_base < 0 || c + col_base < 0)
				{
					continue;
				}
				if (r + row_base >= row_num || c + col_base >= col_num)
				{
					break;
				}
				get(r + row_base, c + col_base) = mt_other.get(r, c);
			}
		}
	}

	template<int top_pad, int left_pad, int right_pad, int bottom_pad>
	mat<row_num + top_pad + bottom_pad, col_num + left_pad + right_pad, val_t>
		pad() const
	{
		using mat_ret_t = mat<row_num + top_pad + bottom_pad, col_num + left_pad + right_pad, val_t>;
		mat_ret_t mt_ret;
		mt_ret.assign<top_pad, left_pad>(*this);
		return mt_ret;
	}

	template<int row_span, int col_span>
	mat<row_num + row_span * (row_num - 1), col_num + col_span * (col_num - 1)>
		span() const
	{
		using mat_ret_t = mat<row_num + row_span * (row_num - 1), col_num + col_span * (col_num - 1)>;
		mat_ret_t mt_ret;
		for (int r = 0; r < row_num; ++r)
		{
			for (int c = 0; c < col_num; ++c)
			{
				mt_ret.get(r * (row_span + 1), c * (col_span + 1)) = get(r, c);
			}
		}
		return mt_ret;
	}

	template<int row_base, int col_base, int row_len, int col_len>
	val_t region_max(int& i_row, int& i_col) const
	{
		static_assert(row_base < row_num&& col_base < col_num, "region_max overflow!!!");
		val_t d_max = -1. * DBL_MAX;
		for (int r = row_base; r < row_base + row_len && r < row_num; ++r)
		{
			for (int c = col_base; c < col_base + col_len && c < col_num; ++c)
			{
				if (d_max < get(r, c))
				{
					i_row = r, i_col = c;
					d_max = get(r, c);
				}
			}
		}
		return d_max;
	}

	mat<row_num* col_num, 1, val_t> one_col() const
	{
		mat<row_num* col_num, 1, val_t> ret;
		ret.pval = pval;
		return ret;
	}

	static void print_type()
	{
		printf("<matrix %d * %d>\r\n", row_num, col_num);
	}
};


#endif
腾昵猫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++实现简单矩阵函数包
英雄爱吃土豆片的博客
10-23 806
使用 python 实现深度学习时， python 中的 NumPy 库高效易用，令人惊艳。但因为刚入门 python ，过于精简的语法反而让我感到不适应，所以想着 C/C++ 是否也存在这样的矩阵处理库，问过度娘后，得到了肯定答案。不过还是总想着自己模仿着写一个矩阵工具，所以就有了这篇文章。 ps：如果真的想要使用 C++ 进行科学计算，还是得使用正儿八经的处理库。自己写的也就是写着练练手，什么也做不了。 Matrix 开发工具：Dev-C++ 5.11 使用方法： 直接包含头文件 Matrix.h 接口
在C++中实现矩阵运算
qq_44949768的博客
04-22 1992
在C++中实现矩阵运算
问题五十二：怎么用C++实现矩阵运算
图形跟班
01-15 7057
最近学习过程中用到矩阵，这里汇总一下用到的矩阵的各种运算。包括： 求转置矩阵（4*4）； 求矩阵的乘积（4*4_4*4） 求逆矩阵（3*3）； 53.1求矩阵的乘积（4*4_4*4） 我们程序中A、B都是4*4的矩阵。   C++代码如下：  bool matrix_4_4_multiply_4_4(const float matrix1[4
matlab 四维矩阵如何理解（脑电信号分析）
计算机小白
04-08 6299
结合脑电信号分析解决matlab中四维矩阵理解的问题
四维矩阵、翻转（包括镜像）、旋转、世界坐标和局部坐标
qq_38409301的博客
01-13 3103
齐次坐标理解：齐次坐标_mrdonghe的博客-CSDN博客_齐次坐标 通常矩阵是用4*4表示 其中 a11 a12 a13 通常用来表示物体的x坐标轴信息 a21 a22 a23 通常用来表示物体的y坐标轴信息 a31 a32 a33 通常用来表示物体的z坐标轴信息 a41 a42 a43通常用来表示物体的原点坐标位置 a14 a24 a34通常用来表示物体的平移部分 物体旋转的具体原理： 1.变化矩阵：首先获取物体的法向量，然后法向量乘以物体的世界系的矩阵坐标...
四维矩阵、四维数组
热门推荐
11-14 3万+
二维、三维、四维矩阵每个维度含义解释
Daisy4的博客
07-20 1万+
shape维度分析
如何数四维矩阵
weixin_45658098的博客
02-21 3098
如何数四维矩阵，如下是一个四位矩阵，形状为（4,3,2,5） tensor([[[[-0.3037, 0.5017, 0.2698, 0.7181, 0.7317], [ 0.2041, -2.1096, 2.0244, -2.0167, -0.4281]], [[ 0.0483, 0.0486, -0.9498, -0.1509, -0.9814], [-0.0850, -0.8587, 1.4044, 0.6037, -...
基于C++实现（控制台）应用二维矩阵完成矩阵运算【100010503】
01-28
详情介绍：...本课设主要完成计算两个矩阵的加法、计算两个矩阵的乘法、计算矩阵的转置、计算矩阵的对角线的和四个部分功能。根据功能分析，建立自制矩阵实验室系统的体系结构，将整个系统分解成五个模块。
C++ 实现全连接神经网络及矩阵头文件 及技术指导
04-22
总结，C++实现全连接神经网络涉及矩阵运算、神经网络架构、前向传播、反向传播、损失函数和优化算法等多个知识点。通过自定义头文件，可以构建模块化、高效的代码结构，适应不同的机器学习任务。
c++关于矩阵的运算
09-28
在C++编程语言中，矩阵运算是一个非常重要的主题，特别是在科学计算、图形处理等领域。本文将详细介绍如何使用C++进行基本的矩阵运算，包括矩阵的加法、减法、乘法、转置以及求逆等操作，并通过具体的代码实现来加深...
矩阵运算_C++_源码
10-01
在本文中，我们将深入探讨如何使用C++编程语言来实现矩阵运算，特别是矩阵的求逆。矩阵运算是线性代数中的基础操作，广泛应用于计算机图形学、机器学习、科学计算等多个领域。C++作为一门高效且功能强大的编程语言，...
基于QT开发的简单矩阵类，可进行基本操作与求逆运算
08-04
本项目是基于QT框架实现的一个简单的矩阵类，该类能够执行基本的矩阵运算，如加法、减法、乘法以及矩阵求逆，这对于许多科学计算和工程应用来说是非常实用的。 首先，让我们详细了解一下矩阵类的设计和实现。一个...
Tensorflow矩阵运算（矩阵相乘，点乘，行/列累加）
Kenn7的博客
12-06 3万+
Tensorflow二维、三维、四维矩阵运算（矩阵相乘，点乘，行/列累加） 1. 矩阵相乘  根据矩阵相乘的匹配原则，左乘矩阵的列数要等于右乘矩阵的行数。 在多维（三维、四维）矩阵的相乘中，需要最后两维满足匹配原则。 可以将多维矩阵理解成：（矩阵排列，矩阵），即后两维为矩阵，前面的维度为矩阵的排列。 比如对于（2，2，4）来说，视为2个（2，4）矩阵。 对于（2，2，2，4）来说，视为...
多维（三维四维）矩阵向量运算-超强可视化
ZJJDJJ的博客
01-10 1万+
多维（三维四维）矩阵向量运算-超强可视化1、高维矩阵可视化一维二维三维四维2、高维矩阵运算 高维矩阵或者向量的运算，是一个困扰着我很久的问题；在NLP里面经常就会碰到三维，四维的向量运算，矩阵相乘时相当头痛，比如著名的Attention中Q、K、V相乘，实在想不出来四维的到底长什么样，又是怎么相乘的。于是特地写下此文章，记录下个人的学习路程，也希望帮到大家。 1、高维矩阵可视化 一维 首先一维的矩阵非常简单，比如[1,2,3,4]，可以用下图表示 二维 接着来看二维，可用以下代码生成一个二维矩阵，采用ke
3D图形学中的矩阵变换及证明（一）
AhCola
05-21 2617
文章同时发布于: 王鹏飞的个人网站。 3D图形学中的矩阵变换 从这个月开始，我打算系统的去学习计算机图形学的知识了，一方面是因为兴趣，另一方面是之前自己也写过一些二维图形相关的程序，有一些数学的基础。图形学在软件开发中的地位很高，市面上所有的建模软件都与图形学相关，即使是photoshop这种设计软件也会涉及图形学的知识。而现在由于webgl的发展，未来图形软件在浏览器的比重也会越来越大。 废话不多说了，直接进入正题。本篇文章主要是为了证明图形学中的几种变换矩阵。首先要知道到学习图形学肯定要与向量、矩阵打交
Mat类创建二维、三维或四五维矩阵并访问以及opencv矩阵运算
SeventhBlue
04-07 1万+
#include <iostream> #include <opencv2/core/core.hpp> #include <opencv2/highgui/highgui.hpp> #include <opencv2/imgproc/imgproc.hpp> using namespace std; using namespace cv; i...
如何构造一个四维的cv::mat
weixin_35757191的博客
01-10 385
要构造一个四维的 cv::Mat，你可以使用 cv::Mat 类的构造函数，它有多个重载版本，可以接受不同的参数。 例如，如果你想要构造一个大小为 (2, 3, 4, 5) 的四维 cv::Mat，并且希望它的每个元素都是浮点数，你可以使用如下代码： cv::Mat mat(2, 3, 4, 5, CV_32F); 上面的代码中，第一个参数 2 表示第一个维度的大小，第二个参数 3 表示第二个维...
【C++】C++中的find方法介绍
最新发布
qq_35902025的博客
07-25 392
find 函数是 std::string 类中非常有用的成员函数之一，它提供了灵活的方式来查找子字符串或字符。使用 npos 可以检查查找操作是否成功。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

腾昵猫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值