初始化

有若干种方法可以声明和初始化矩阵和向量。

函数	动作
Assign	复制矩阵、向量或数组，并自动转换
CopyIndicatorBuffer	将指定数量中指定指标缓冲区的数据获取到向量
CopyRates	获取指定品种、周期、数量的历史序列，格式为 MqlRates 结构，并存储到矩阵或向量
CopyTicks	从 MqlTick 结构获取跳价，存储到矩阵或向量中
CopyTicksRange	从 MqlTick 结构获取跳价，以指定数据范围存储到矩阵或向量中
Eye	返回一个矩阵，对角线上为 1，其它地方为 0
Identity	创建指定大小的单位矩阵
Ones	创建并返回一个新矩阵，其中以 1 填充
Zeros	创建并返回一个新矩阵，填充零
Full	创建并返回新矩阵，并按给定值填充
Tri	构造一个矩阵，其中位于给定对角线为一，而其它地方为零
Init	初始化矩阵或向量
Fill	用指定值填充现有矩阵或向量

声明且未指定大小（没有为数据分配内存）：

  matrix         matrix_a;   // 双精度型矩阵

  matrix<double> matrix_a1;  // 声明双矩阵的另一种途径；可以在模板中使用

  matrixf        matrix_a2;  // 浮点型矩阵

  matrix<float>  matrix_a3;  // 浮点型矩阵

  vector         vector_a;   // 双精度向量

  vector<double> vector_a1;

  vectorf        vector_a2;  // 双精度向量

  vector<float>  vector_a3;

声明且指定大小（为数据分配内存，但未初始化）：

  matrix         matrix_a(128,128);           // 参数既可是常数

  matrix<double> matrix_a1(InpRows,InpCols);  // 亦或变量

  matrixf        matrix_a2(1,128);            // 水平向量的模拟

  matrix<float>  matrix_a3(InpRows,1);        // 垂直向量的模拟

  vector         vector_a(256);

  vector<double> vector_a1(InpSize);

  vectorf        vector_a2(SomeFunc());       // 函数 SomeFunc 返回一个 ulong 型的数字，用于设置向量大小

  vector<float>  vector_a3(InpSize+16);       // 表达式可以用作参数

声明且初始化（矩阵和向量大小由初始化序列确定）：

  matrix         matrix_a={{0.1,0.2,0.3},{0.4,0.5,0.6}};

  matrix<double> matrix_a1=matrix_a;                      // 必须是相同类型的矩阵

  matrixf        matrix_a2={{1,0,0},{0,1,0},{0,0,1}};

  matrix<float>  matrix_a3={{1,2},{3,4}};

  vector         vector_a={-5,-4,-3,-2,-1,0,1,2,3,4,5};

  vector<double> vector_a1={1,5,2.4,3.3};

  vectorf        vector_a2={0,1,2,3};

  vector<float>  vector_a3=vector_a2;                     // 必须是相同类型的向量

声明且初始化：

template<typename T>

void MatrixArange(matrix<T> &mat,T value=0.0,T step=1.0)

  {

   for(ulong i=0; i<mat.Rows(); i++)

     {

      for(ulong j=0; j<mat.Cols(); j++,value+=step)

         mat[i][j]=value;

     }

  }

template<typename T>

void VectorArange(vector<T> &vec,T value=0.0,T step=1.0)

  {

   for(ulong i=0; i<vec.Size(); i++,value+=step)

      vec[i]=value;

  }

...



  matrix  matrix_a(size_m,size_k,MatrixArange,-M_PI,0.1); // 首先创建一个大小 size_m x size_k 的未初始化矩阵，然后调用带有初始化时指定参数的 MatrixArange 函数

  matrixf matrix_a1(10,20,MatrixArange);                  // 创建矩阵后，调用带有默认参数的 MatrixArange 函数

  vector  vector_a(size,VectorArange,-10.0);              // 创建向量后，调用带有一个参数的 VectorArange 函数，而第二个参数采用默认值

  vectorf vector_a1(128,VectorArange);

请注意，矩阵或矢量大小可以更改，因为数据的内存始终是动态的。

静态方法

依据指定大小创建矩阵和向量的静态方法，并以某种方式初始化：

  matrix         matrix_a =matrix::Eye(4,5,1);

  matrix<double> matrix_a1=matrix::Full(3,4,M_PI);

  matrixf        matrix_a2=matrixf::Identity(5,5);

  matrixf<float> matrix_a3=matrixf::Ones(5,5);

  matrix         matrix_a4=matrix::Tri(4,5,-1);

  vector         vector_a =vector::Ones(256);

  vectorf        vector_a1=vector<float>::Zeros(16);

  vector<float>  vector_a2=vectorf::Full(128,float_value);

已创建矩阵和向量的初始化方法：

  matrix  matrix_a;

  matrix_a.Init(size_m,size_k,MatrixArange,-M_PI,0.1);

  matrixf matrix_a1(3,4);

  matrix_a1.Init(10,20,MatrixArange);

  vector  vector_a;

  vector_a.Init(128,VectorArange);

  vectorf vector_a1(10);

  vector_a1.Init(vector_size,VectorArange,start_value,step);



  matrix_a.Fill(double_value);

  vector_a1.Fill(FLT_MIN);

  matrix_a1.Identity();