pub fn complex_combine(
    m1: ComplexMatrix,
    m2: ComplexMatrix,
    m3: ComplexMatrix,
    m4: ComplexMatrix,
) -> ComplexMatrix {
    let l_r = m1.row;
    let l_c = m1.col;
    let c_l = m2.col;
    let r_l = m3.row;

    let r = l_r + r_l;
    let c = l_c + c_l;

    let mut m = cmatrix(vec![Complex::zero(); r * c], r, c, m1.shape);

    for idx_row in 0..r {
        for idx_col in 0..c {
            match (idx_row, idx_col) {
                (i, j) if (i < l_r) && (j < l_c) => {
                    m[(i, j)] = m1[(i, j)];
                }
                (i, j) if (i < l_r) && (j >= l_c) => {
                    m[(i, j)] = m2[(i, j - l_c)];
                }
                (i, j) if (i >= l_r) && (j < l_c) => {
                    m[(i, j)] = m3[(i - l_r, j)];
                }
                (i, j) if (i >= l_r) && (j >= l_c) => {
                    m[(i, j)] = m4[(i - l_r, j - l_c)];
                }
                _ => (),
            }
        }
    }
    m
}
Combine separated Complex Matrix to one Complex Matrix

# Examples
```rust
use peroxide::fuga::*;
use peroxide::complex::matrix::*;
use peroxide::traits::fp::FPMatrix;

fn main() {
let x1 = cmatrix(vec![C64::new(1f64, 1f64)], 1, 1, Row);
let x2 = cmatrix(vec![C64::new(2f64, 2f64)], 1, 1, Row);
let x3 = cmatrix(vec![C64::new(3f64, 3f64)], 1, 1, Row);
let x4 = cmatrix(vec![C64::new(4f64, 4f64)], 1, 1, Row);

let y = complex_combine(x1, x2, x3, x4);

let y_exp = cmatrix(vec![C64::new(1f64, 1f64),
C64::new(2f64, 2f64),
C64::new(3f64, 3f64),
C64::new(4f64, 4f64)],
2, 2, Row
);

assert_eq!(y, y_exp);
}
```
src/complex/matrix.rs