在程式設計中我們經常會合並某個矩陣，通常我們會使用迴圈來實現，然而迴圈有時候會降低程式執行的效率，

所以利用ArrayFire中的向量的平坦模式，我們可以利用空間來換取時間。主要的思路是：

　　1.我們將m*n的矩陣展開成一個1*(m*n)或者(m*n)*1的向量；

　　2.同理我們將p*q的矩陣展開成一個1*(p*q)或者(p*q)*1的向量；

　　3.我們再次定義一個向量x=((p*q):(m*n))或x=((m*n):(p*q))將上述兩個向量合併到一起；

　　4.現在我得到了一個一維的目標向量，現在我們要將這個目標向量拆開成a*b的目標矩陣，具體的做法是

再次定義一個f(a*b)的目標矩陣，將x向量的賦值給目標矩陣就可以實現了。

　　這樣我們就不用使用迴圈來實現了，利用向量化的思路實現了空間換取時間。

程式碼如下：

#include "cuda_runtime.h"
#include "device_launch_parameters.h"

#include <stdio.h>
#include<arrayfire.h>
#include<iostream>


using namespace af;

int main(void) {

    float h_a[] = { 0,1,2,3,4,5 };
    float h_b[] = { 1,4,5,7 };
    
 
float h_c[] = { 6,7,8,9,10,11 };
    float h_d[] = { 2,4,6,8,10,12,14,16,18 };
    float dt = 1.0f;

    array d_b(3, 2, h_a); //'
    array d_d(2, 2, h_b);
    array d_c(2, 3, h_c); //'
    array d_a(3, 3, h_d);
    array d_R;

    



    //merge array_1
    array d_f = af::join(0, af::flat((d_a)), af::flat((d_b)));
    
 
float *yptr = d_f.device<float>();

    array d1_order(3, 5, yptr);
    //d_order = transpose(d_order);

    //merge array_2
    array d_g = af::join(0, af::flat((d_c)), af::flat((d_d)));
    float *gptr = d_g.device<float>();

    array d2_order(2, 5, gptr);

    //merge array_3
    array d_k = af::join(0, af::flat(transpose(d1_order)), af::flat(transpose(d2_order)));
    float *kptr = d_k.device<float>();

    array d_order(5, 5, kptr);
    d_order = transpose(d_order);

    af_print(d1_order);
    af_print(d2_order);
    af_print((d_order));

    
    

    return 0;
}

在vs2017上執行如下：