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

最新推荐文章于 2023-01-10 08:22:53 发布
最新推荐文章于 2023-01-10 08:22:53 发布
阅读量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++编写的用于矩阵计算的类实用.pdf
11-15
用c++编写的用于矩阵计算的类实用.pdf
matlab 四维矩阵如何理解（脑电信号分析）
计算机小白
04-08 6251
结合脑电信号分析解决matlab中四维矩阵理解的问题
四维矩阵、翻转（包括镜像）、旋转、世界坐标和局部坐标
qq_38409301的博客
01-13 3087
齐次坐标理解：齐次坐标_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维度分析
多维（三维四维）矩阵向量运算-超强可视化
ZJJDJJ的博客
01-10 1万+
多维（三维四维）矩阵向量运算-超强可视化1、高维矩阵可视化一维二维三维四维2、高维矩阵运算 高维矩阵或者向量的运算，是一个困扰着我很久的问题；在NLP里面经常就会碰到三维，四维的向量运算，矩阵相乘时相当头痛，比如著名的Attention中Q、K、V相乘，实在想不出来四维的到底长什么样，又是怎么相乘的。于是特地写下此文章，记录下个人的学习路程，也希望帮到大家。 1、高维矩阵可视化 一维 首先一维的矩阵非常简单，比如[1,2,3,4]，可以用下图表示 二维 接着来看二维，可用以下代码生成一个二维矩阵，采用ke
Tensorflow矩阵运算（矩阵相乘，点乘，行/列累加）
Kenn7的博客
12-06 3万+
Tensorflow二维、三维、四维矩阵运算（矩阵相乘，点乘，行/列累加） 1. 矩阵相乘  根据矩阵相乘的匹配原则，左乘矩阵的列数要等于右乘矩阵的行数。 在多维（三维、四维）矩阵的相乘中，需要最后两维满足匹配原则。 可以将多维矩阵理解成：（矩阵排列，矩阵），即后两维为矩阵，前面的维度为矩阵的排列。 比如对于（2，2，4）来说，视为2个（2，4）矩阵。 对于（2，2，2，4）来说，视为...
如何数四维矩阵
weixin_45658098的博客
02-21 3095
如何数四维矩阵，如下是一个四位矩阵，形状为（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, -...
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 383
要构造一个四维的 cv::Mat，你可以使用 cv::Mat 类的构造函数，它有多个重载版本，可以接受不同的参数。 例如，如果你想要构造一个大小为 (2, 3, 4, 5) 的四维 cv::Mat，并且希望它的每个元素都是浮点数，你可以使用如下代码： cv::Mat mat(2, 3, 4, 5, CV_32F); 上面的代码中，第一个参数 2 表示第一个维度的大小，第二个参数 3 表示第二个维...
vector 赋值_C++使用vector创建三维、四维、五维数组等高维数组的方法
weixin_39867296的博客
12-11 3133
C++使用vector创建三维、四维、五维数组等高维数组的方法：实现功能为：创建三维数组a1[n][m][k]全部赋值为3创建四维数组a2[n][m][k][p]全部赋值为4创建五维数组a3[n][m][k][p][q]全部赋值为5并将数组里面的值进行显示。代码实现：#include#include#includeusing namespace std;void main() { ve...
c++ opencv库 Mat 使用（未完）
qq_41485193的博客
08-04 1244
Mat 使用 初级笔记
3D图形学中的矩阵变换及证明（一）
AhCola
05-21 2609
文章同时发布于: 王鹏飞的个人网站。 3D图形学中的矩阵变换 从这个月开始，我打算系统的去学习计算机图形学的知识了，一方面是因为兴趣，另一方面是之前自己也写过一些二维图形相关的程序，有一些数学的基础。图形学在软件开发中的地位很高，市面上所有的建模软件都与图形学相关，即使是photoshop这种设计软件也会涉及图形学的知识。而现在由于webgl的发展，未来图形软件在浏览器的比重也会越来越大。 废话不多说了，直接进入正题。本篇文章主要是为了证明图形学中的几种变换矩阵。首先要知道到学习图形学肯定要与向量、矩阵打交
用c++建立一个矩阵类Matrix，存储一个4*4的矩阵并能在矩阵中查找某数。
qq_36631131的博客
01-20 1万+
要求如下： （1）私有数据成员 int p[4][4]：存储一个4*4的矩阵的值。 int n：矩阵的行数。4 int x：存储根据查找要求在矩阵中要查找到的某数。 int row，col：存储该数所在的行、列值。 （2）公有成员函数 构造函数：初始化n的值为4，x、row、col为0。 void input(int a[][4])：将一个矩阵赋给该对象中的数组。 void fi
MATLAB中怎样初始化(创建)二维、三维、四维以及多维矩阵,各维度的索引顺序是怎样的？
热门推荐
昊虹AI笔记
05-24 3万+
目录1 在MATLAB中初始化二维矩阵2 在MATLAB中初始化三维矩阵3 在MATLAB中初始化四维矩阵4 在MATLAB中初始化N维矩阵 1 在MATLAB中初始化二维矩阵 在MATLAB中初始化一个二维矩阵是很容易的，我们既可以直接把矩阵的元素值写出，比如下面这样： A = [1 2 3 4;... 5 6 7 8;... 9 10 11 12]; 也可以直接用函数ones()、zeros()、rand()等函数初始化一个全1或全0或均匀随机分布等的矩阵，然后再对其中的元素进行
C/C++ 实战笔记1--数组
aaaabbbcde的博客
10-10 650
C/C++ 实战笔记1--数组1、一维数组1.1. 初始化、赋值1.2. 动态开辟内存空间2、二维数组2.1. 初始化、赋值2.2. 动态开辟内存空间3、三维数组3.1. 动态开辟内存空间4、四维数组4.1. 动态开辟内存空间 在实际项目的应用中，常用的数组包括一维、二维、三维和四维数组，其主要应用包括创建/动态创建、初始化/赋值、调用/引用等。 1、一维数组 1.1. 初始化、赋值 //数组长度为常量 _LENGTH float temp1[_LENGTH] = {0}; float temp2[_LEN
四维矩阵存储多张３维图片
qq_34789262的博客
08-01 2851
　　最近申请基金，想到一个ｉｄｅａ，将常见的三维图片训练集处理为四维模糊图片，用四维图片训练集训练模型，比较新模型和旧模型的准确率。 　　网上找了一大堆，有两个博客提出这个问题，下面的回复都没什么卵用。 　　这里实现一个简单的四维矩阵存储多张一维图片例子，供大家参考。 　　对于通道的定义，比如原图是ＲＧＢ３通道，一千张图片放到四维矩阵，通道数还是３。         之前给的代码太繁琐，这...
C++学习笔记04（数组）
m0_57096518的博客
11-04 269
4.3跳转语句 4.3.1break语句 作用：用于跳出选择结构或者循环结构 使用情形：switch语句中，循环语句中，嵌套内层循环 4.3.2continue语句 作用：在循环语句中，跳出本次循环余下未执行的语句，继续执行下一次循环 ...
高精度整数四维汇算（C++）
RE_FCJ的博客
05-08 111
#include<string> #include<iostream> #include<iosfwd> #include<cmath> #include<cstring> #include<stdlib.h> #include<stdio.h> #include<cstring> #define MAX_L 999 #define max(a,b) a&gt...
c++实现 齐次坐标 4*4矩阵 四元数 坐标变换
logic9169的博客
04-23 5665
四元数 四元数(quaternion)可以看作中学时学的复数的扩充，它有三个虚部。形式如下： 四元数(quaternion)可以看作中学时学的复数的扩充，它有三个虚部。形式如下： [公式] ，可以写成 [公式] 4*4变换矩阵 四元数到4*4矩阵 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

腾昵猫

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

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

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

打赏作者

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

抵扣说明：

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

余额充值