简介

在C++11标准之前，一般是利用rand()函数产生一个均匀分布的，范围从0到系统相关的最大值之间的随机整数，然后再通过转换得到不同分布的随机数，这种方法比较麻烦，同时转换过程中会引入非随机性。

C++11标准中，定义了随机数引擎类和随机数分布类，通过随机数引擎和随机数分布的组合，可以产生各种分布的随机数。这些类包含在头文件random中，使用前需要先包含random头文件：

#include<random>

随机数产生

随机数引擎和随机数分布都是重载了调用运算符"()"的函数对象类，随机数引擎的调用运算符不接受参数，并且返回一个unsigned随机数，称为原始随机数。而随机数分布的调用运算符接受一个随机数引擎类作为参数，返回服从特定分布的随机数。

1 随机数引擎
一般采用default_random_engine类创建一个随机数引擎对象（default_random_engine的具体实现与不同的编译器有关）。创建随机数引擎的方式如下
default_random_engine e;

2 随机数分布
随机数服从的分布由随机数分布类决定，如

3 利用随机数分布和引擎产生随机数
以正态分布为例，下面的例子产生一个服从$N(0,10^2)$（即均值0，标准差10的正态分布）的随机数。

#include<iostream>
#include<random>
#include<ctime>
using namespace std;
int main(){
  //产生随机数引擎，采用time作为种子，以确保每次运行程序都会得到不同的结果
  static default_random_engine e(time(0));
  //产生正态分布对象
  static normal_distribution<double> n(0,10);
  double random_number=n(e);//把引擎作为参数，调用随机分布对象
  cout<<random_number<<endl;
  return 0
}

最好把引擎和分布都定义为static。

使用Eigen库和C++随机数机制，产生正态分布的随机矩阵

Eigen中只有产生均匀分布随机矩阵的Random()，没有其他分布类型的随机矩阵函数。

借助Eigen提供的unaryExpr函数，可以对矩阵的每一个元素进行同一个操作。unaryExpr接受一个函数对象作为参数，该函数对象定义了所要对元素进行的运算。因此，我们只需要定一个产生随机数的函数对象，将其作为参数传给unaryExpr，即可对矩阵每一个元素产生随机数。可以用lambda表达式作为函数对象，也可以定义一个函数，并用ptr_fun()函数将函数指针转成函数对象。下面给出这两种方式的实现。

1 采用lambda表达式

#include<iostream>
#include<random>
#include<Eigen/Eigen>
#include<ctime>
using namespace std;
using namespace Eigen;

int main(){
  static default_random_engine e(time(0));
  static normal_distribution<double> n(0,10);
  MatrixXd m=MatrixXd::Zero(10,10).unaryExpr([](double dummy){return n(e);});
  cout<<"Gaussian random matrix:\n"<<m<<endl;
  cout<<"Mean: "<<m.mean()<<endl;
  MatrixXd m2=(m.array()-m.mean())*(m.array()-m.mean());
  cout<<"std: "<<sqrt(m2.sum()/(m2.size()-1))<<endl;
}

2 采用ptr_fun将函数指针转成函数对象

#include<iostream>
#include<random>
#include<Eigen/Eigen>
#include<ctime>
using namespace std;
using namespace Eigen;

double generate_random(double dummy){
  static default_random_engine e(time(0));
  static normal_distribution<double> n(0,10);
  return n(e);
}

int main(){
  MatrixXd m=MatrixXd::Zero(10,10).unaryExpr(ptr_fun(generate_random));
  cout<<"Gaussian random matrix:\n"<<m<<endl;
  cout<<"Mean: "<<m.mean()<<endl;
  MatrixXd m2=(m.array()-m.mean())*(m.array()-m.mean());
  cout<<"std: "<<sqrt(m2.sum()/(m2.size()-1))<<endl;
}

3 采用原始的二重for循环
当然也可以遍历矩阵的每一个元素，并用随机数给每个元素赋值，这种做法简单暴力

 实现了矩阵的生成、乘法运算。

 1.完整代码如下：

#include <iostream>
#include <cstring>
#include <chrono>
#include <vector>
using namespace std;
struct Matrix
{
	vector<vector<int>> M;
	size_t Rows;
	size_t Columns;
	Matrix(size_t r = 0,size_t c=0,int rv = 1)
	{
		Rows = r;
		Columns = c;
		for (size_t i = 0; i < r; i++)
		{
			vector<int> t;
			for (size_t j = 0; j < c; j++)
			{	

				if (rv > 1)
				{
					t.push_back(rand() % rv);
				}
				t.push_back(rv);
			}
			M.push_back(t);
		}
	}

	bool isNull()
	{
		return Rows == 0 || Columns == 0;
	}

	void printMatrix(const char* msg = "")
	{
		if (strlen(msg)>0)
		{
			printf("%s\n", msg);
		}
		for (size_t i = 0; i < Rows; i++)
		{
			for (size_t j = 0; j < Columns; j++)
				printf("%d,",M[i][j]);
			printf("\n");
		}
	}
};
// A*B
Matrix mulMatrix(Matrix a, Matrix b)
{
	if (a.isNull() || b.isNull())
	{
		printf("空矩阵\n");
		// 此处直接返回一个空的Matrix，也就是0行0列的矩阵
		return	Matrix();
	}
	if (a.Columns != b.Rows)
	{
		printf("不符合乘法要求的矩阵");
		// 此处直接返回一个空的Matrix，也就是0行0列的矩阵
		return	Matrix();
	}

	//如果符合要求，构建一个结果矩阵
	Matrix c(a.Rows, b.Columns);

	for (size_t i = 0; i < a.Rows; i++)
	{
		for (size_t j = 0; j < b.Columns; j++)
		{
			//在进行默认构建时，所有矩阵中的数据全为1，所以此处需要进行置0
			c.M[i][j] = 0;
			for (size_t k = 0; k < a.Columns; k++)
			{
				c.M[i][j] += a.M[i][k] * b.M[k][j];
			}
		}
	}
	return c;
}

int main(int argc, char **argv)
{
	std::cout << "开始执行矩阵运算：(输入0退出程序)" << endl;
	while (true)
	{
		std::cout << "请输入矩阵的阶数：" << endl;

		int len = 0;

		cin >> len;

		cout << "您输入的矩阵阶数为：" << len << endl;

		if (len < 1)
		{
			cout << "无效的阶数：" << len << endl;
			return 0;
		}

		Matrix Ma(len, len, 10);
		//Ma.printMatrix("随机生成的方阵Ma如下：");

		Matrix Mb(len, 1, 10);
		//Mb.printMatrix("随机生成的列向量Mb如下：");

		auto t1 = chrono::steady_clock::now();
		Matrix Mc = mulMatrix(Ma, Mb);

		auto t2 = chrono::steady_clock::now();

		double timeSpan = chrono::duration<double, std::milli>(t2 - t1).count();

		printf("总用时为：%f ms", timeSpan);

		//Mc.printMatrix("----------Ma*Mb的结果如下：----------");
	}
	
	
	return 0;

}

2.后期的扩展方向：

1. 将结构体封装为一个类，
2. 编写其他的矩阵操作函数
3. 运算符的重构

在pytorch中,我们可以很轻易地生成

import torch
torch.randn(3, 32, 32)

这样就生成了一个(3, 32, 32)的矩阵,而OpenCV也提供了方法进行生成:

#include<iostream>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;
int main()
{
    Mat a(32, 32, CV_32FC3);
    // 实例化一个随机数发生器
    RNG rng;
    // 使用fill方法
    rng.fill(a, RNG::UNIFORM, 0.f, 1.f);
    // 输出结果
    cout << a << endl;
    cout << a.size << endl;

    return 0;
}

void fill( InputOutputArray mat, int distType, InputArray a, InputArray b, bool saturateRange=false );

InputOutputArray                    输入输出矩阵，最多支持4通道，超过4通道先用reshape()改变结构

int distType                             UNIFORM 或 NORMAL，表示均匀分布和高斯分布

InputArray a                           disType是UNIFORM,a表示为下界(闭区间)；disType是NORMAL,a均值

InputArray b                           disType是UNIFORM,b表示为上界(开区间)；disType是NORMAL,b标准差

bool saturateRange=false     
只针对均匀分布有效。当为真的时候，会先把产生随机数的范围变换到数据类型的范围，再产生随机数；
如果为假，会先产生随机数，再进行截断到数据类型的有效区间。请看以下fillM1和fillM2的例子并观察结果