Function af_transpose

src/api/c/transpose.cpp:38–85

}

af_err af_transpose(af_array* out, af_array in, const bool conjugate) {
    try {
        const ArrayInfo& info = getInfo(in);
        af_dtype type         = info.getType();
        af::dim4 dims         = info.dims();

        if (dims.elements() == 0) { return af_retain_array(out, in); }

        if (dims[0] == 1 || dims[1] == 1) {
            af::dim4 outDims(dims[1], dims[0], dims[2], dims[3]);
            if (conjugate) {
                af_array temp = 0;
                AF_CHECK(af_conjg(&temp, in));
                AF_CHECK(af_moddims(out, temp, outDims.ndims(), outDims.get()));
                AF_CHECK(af_release_array(temp));
                return AF_SUCCESS;
            } else {
                // for a vector OR a batch of vectors
                // we can use modDims to transpose
                AF_CHECK(af_moddims(out, in, outDims.ndims(), outDims.get()));
                return AF_SUCCESS;
            }
        }

        af_array output;
        switch (type) {
            case f32: output = trs<float>(in, conjugate); break;
            case c32: output = trs<cfloat>(in, conjugate); break;
            case f64: output = trs<double>(in, conjugate); break;
            case c64: output = trs<cdouble>(in, conjugate); break;
            case b8: output = trs<char>(in, conjugate); break;
            case s32: output = trs<int>(in, conjugate); break;
            case u32: output = trs<uint>(in, conjugate); break;
            case s8: output = trs<schar>(in, conjugate); break;
            case u8: output = trs<uchar>(in, conjugate); break;
            case s64: output = trs<intl>(in, conjugate); break;
            case u64: output = trs<uintl>(in, conjugate); break;
            case s16: output = trs<short>(in, conjugate); break;
            case u16: output = trs<ushort>(in, conjugate); break;
            case f16: output = trs<half>(in, conjugate); break;
            default: TYPE_ERROR(1, type);
        }
        std::swap(*out, output);
    }
    CATCHALL;

    return AF_SUCCESS;
}

template<typename T>
static inline void transpose_inplace(af_array in, const bool conjugate) {