/** @file  psMatrix.c
 *
 *  @brief Provides functions for linear algebra operations on psImages and psVectors.
 *
 *  Functions are provided to:
 *      Transpose a psImage
 *      Compute LUD
 *      Solve LUD
 *      Matrix inversion
 *      Calculate determinant
 *      Matrix addition
 *      Matrix subtraction
 *      Matrix multiplication
 *      Calculate Eigenvectors
 *      Convert matrix to vector
 *      Convert vector to matrix
 *
 *  These functions treat psImages as if they were matrices, therefore there is no psMatrix.
 *
 *  @author Ross Harman, MHPCC
 *  @author Robert DeSonia, MHPCC
 *
 *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
 *  @date $Date: 2005-03-22 21:52:49 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
 */

/******************************************************************************/
/*  INCLUDE FILES                                                             */
/******************************************************************************/
#include <string.h>
#include <gsl/gsl_matrix.h>
#include <gsl/gsl_linalg.h>
#include <gsl/gsl_permutation.h>
#include <gsl/gsl_eigen.h>

#include "psMemory.h"
#include "psError.h"
#include "psImage.h"
#include "psVector.h"
#include "psMatrix.h"
#include "psConstants.h"
#include "psDataManipErrors.h"


/*****************************************************************************/
/* DEFINE STATEMENTS                                                         */
/*****************************************************************************/

/** Preprocessor macro to generate error for image dimensionality not set to PS_DIMEN_IMAGE */
#define PS_CHECK_DIMEN_AND_TYPE(NAME, PS_DIMEN, CLEANUP)                                             \
if (NAME->type.dimen != PS_DIMEN) {                                                                 \
    psError(PS_ERR_BAD_PARAMETER_TYPE, true,                                                        \
            "Invalid operation. %s has incorrect dimensionality %d.", #NAME, PS_DIMEN);             \
    CLEANUP;                                                                                  \
} else if(NAME->type.type!=PS_TYPE_F64 && NAME->type.type!=PS_TYPE_F32) {                           \
    psError(PS_ERR_BAD_PARAMETER_TYPE, true,                                                        \
            "Invalid operation. %s not PS_TYPE_F64.", #NAME);                                       \
    CLEANUP;                                                                                  \
}

/** Preprocessor macro to check that input is not equal to output */
#define PS_CHECK_POINTERS(NAME1, NAME2, CLEANUP)                                                     \
if (NAME1 == NAME2) {                                                                               \
    psError(PS_ERR_BAD_PARAMETER_VALUE, true,                                                       \
            "Invalid operation: Pointer to %s is same as %s.", #NAME1, #NAME2);                     \
    CLEANUP;                                                                                  \
}

/** Preprocessor macro to check that an image is square */
#define PS_CHECK_SQUARE(NAME, CLEANUP)                                                               \
if (NAME->numCols != NAME->numRows) {                                                               \
    psError(PS_ERR_BAD_PARAMETER_SIZE, true, "Invalid operation: %s not square array.", #NAME);     \
    CLEANUP;                                                                                  \
}

/** Preprocessor macro to initalize a GSL matrix. */
#define PS_GSL_MATRIX_INITIALIZE(LHS_NAME, RHS_NAME)                                                \
LHS_NAME.size1 = numRows;                                                                           \
LHS_NAME.size2 = numCols;                                                                           \
LHS_NAME.tda   = numCols;                                                                           \
LHS_NAME.data  = RHS_NAME;


/*****************************************************************************/
/* FILE STATIC FUNCTIONS                                                     */
/*****************************************************************************/

static void  psVectorToGslVector(gsl_vector *outGslVector, const psVector *inVector);
static void gslVectorToPsVector(psVector *outVector, gsl_vector *inGslVector);
static void  psImageToGslMatrix(gsl_matrix *outGslMatrix, const psImage *inImage);
static void gslMatrixToPsImage(psImage *outImage, gsl_matrix *inGslMatrix);

/** Static function to copy psF32 or psF64 vector data to a GSL vector */
static void  psVectorToGslVector(gsl_vector *outGslVector, const psVector *inVector)
{
    psU32 i = 0;
    psU32 n = 0;


    n = inVector->n;
    for(i=0; i<n; i++) {
        if(inVector->type.type == PS_TYPE_F32) {
            outGslVector->data[i] = (psF64)inVector->data.F32[i];
        } else {
            outGslVector->data[i] = inVector->data.F64[i];
        }
    }
}

/** Static function to copy GSL vector data to a psF32 or psF64 vector */
static void gslVectorToPsVector(psVector *outVector, gsl_vector *inGslVector)
{
    psU32 i = 0;
    psU32 n = 0;


    n = outVector->n;
    for(i=0; i<n; i++) {
        if(outVector->type.type == PS_TYPE_F32) {
            outVector->data.F32[i] = (psF32)inGslVector->data[i];
        } else {
            outVector->data.F64[i] = inGslVector->data[i];
        }
    }
}

/** Static function to copy psF32 or psF64 image data to a GSL matrix */
static void  psImageToGslMatrix(gsl_matrix *outGslMatrix, const psImage *inImage)
{
    psU32 i = 0;
    psU32 j = 0;
    psU32 numRows = 0;
    psU32 numCols = 0;


    numRows = inImage->numRows;
    numCols = inImage->numCols;
    for(i=0; i<numRows; i++) {
        for(j=0; j<numCols; j++) {
            if(inImage->type.type == PS_TYPE_F32) {
                outGslMatrix->data[i*numCols+j] = (psF64)inImage->data.F32[i][j];
            } else {
                outGslMatrix->data[i*numCols+j] = inImage->data.F64[i][j];
            }
        }
    }
}

/** Static function to copy GSL matrix data to a psF32 or psF64 image */
static void gslMatrixToPsImage(psImage *outImage, gsl_matrix *inGslMatrix)
{
    psU32 i = 0;
    psU32 j = 0;
    psU32 numRows = 0;
    psU32 numCols = 0;


    numRows = outImage->numRows;
    numCols = outImage->numCols;
    for(i=0; i<numRows; i++) {
        for(j=0; j<numCols; j++) {
            if(outImage->type.type == PS_TYPE_F32) {
                outImage->data.F32[i][j] = (psF32)inGslMatrix->data[i*numCols+j];
            } else {
                outImage->data.F64[i][j] = inGslMatrix->data[i*numCols+j];
            }
        }
    }
}


/*****************************************************************************/
/* FUNCTION IMPLEMENTATION - PUBLIC                                          */
/*****************************************************************************/

psImage* psMatrixLUD(psImage* outImage, psVector** outPerm, psImage* inImage)
{
    psS32 signum = 0;
    psS32 numRows = 0;
    psS32 numCols = 0;
    gsl_matrix *lu = NULL;
    gsl_permutation perm;


    #define psMatrixLUD_EXIT {psFree(outImage); return NULL;}

    // Error checks
    PS_IMAGE_CHECK_NULL_GENERAL(inImage, psMatrixLUD_EXIT);
    PS_CHECK_POINTERS(inImage, outImage, psMatrixLUD_EXIT);
    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, psMatrixLUD_EXIT);
    PS_PTR_CHECK_NULL_GENERAL(outPerm, psMatrixLUD_EXIT);

    outImage = psImageRecycle(outImage, inImage->numCols, inImage->numRows, inImage->type.type);

    PS_CHECK_SQUARE(inImage, psMatrixLUD_EXIT);
    PS_CHECK_SQUARE(outImage, psMatrixLUD_EXIT);

    // Initialize data
    numRows = inImage->numRows;
    numCols = inImage->numCols;

    // Initialize GSL data
    perm.size = numCols;
    if (sizeof(size_t) == 4) {
        *outPerm = psVectorRecycle(*outPerm, numCols, PS_TYPE_S32);
    } else if (sizeof(size_t) == 8) {
        *outPerm = psVectorRecycle(*outPerm, numCols, PS_TYPE_S64);
    } else {
        psError(PS_ERR_UNKNOWN, true,
                "Failed to allocate the permutation vector; "
                "could not determine the cooresponding data type.");
        psMatrixLUD_EXIT;
    }

    (*outPerm)->n = numCols;
    perm.data = (psPtr)((*outPerm)->data.U8);
    lu = gsl_matrix_alloc(numRows, numCols);

    // Copy psImage data into GSL matrix data
    psImageToGslMatrix(lu, inImage);

    // Calculate LU decomposition
    gsl_linalg_LU_decomp(lu, &perm, &signum);

    // Copy GSL matrix data to psImage data
    gslMatrixToPsImage(outImage, lu);

    // Free GSL data
    gsl_matrix_free(lu);

    return outImage;
}

psVector* psMatrixLUSolve(psVector* outVector, const psImage* inImage, const psVector* inVector,
                          const psVector* inPerm)
{
    psS32 numRows = 0;
    psS32 numCols = 0;
    gsl_matrix *lu;
    gsl_permutation perm;
    gsl_vector *b = NULL;
    gsl_vector *x = NULL;

    #define LUSOLVE_CLEANUP {psFree(outVector); return NULL;}

    // Error checks
    PS_IMAGE_CHECK_NULL_GENERAL(inImage, LUSOLVE_CLEANUP);
    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, LUSOLVE_CLEANUP);
    PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, LUSOLVE_CLEANUP);
    PS_VECTOR_CHECK_NULL_GENERAL(inVector, LUSOLVE_CLEANUP);
    PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_VECTOR, LUSOLVE_CLEANUP);
    PS_VECTOR_CHECK_NULL_GENERAL(inPerm, LUSOLVE_CLEANUP);

    outVector = psVectorRecycle(outVector, inImage->numRows, inImage->type.type);

    PS_CHECK_POINTERS(outVector, inVector, LUSOLVE_CLEANUP);
    PS_CHECK_POINTERS(inVector, inPerm, LUSOLVE_CLEANUP);
    PS_CHECK_POINTERS(outVector, inPerm, LUSOLVE_CLEANUP);

    // Initialize data
    numRows = inImage->numRows;
    numCols = inImage->numCols;

    // Initialize GSL data
    lu = gsl_matrix_alloc(numRows, numCols);
    psImageToGslMatrix(lu, inImage);
    b = gsl_vector_alloc(inVector->n);
    psVectorToGslVector(b, inVector);
    x = gsl_vector_alloc(inVector->n);

    outVector->n = numCols;
    perm.size = inPerm->n;
    perm.data = (psPtr)(inPerm->data.U8);

    // Solve for {x} in equation: {b} = [A]{x}
    gsl_linalg_LU_solve(lu, &perm, b, x);

    // Copy GSL vector data to psVector data
    gslVectorToPsVector(outVector, x);

    // Free GSL data
    gsl_vector_free(b);
    gsl_vector_free(x);
    gsl_matrix_free(lu);

    return outVector;
}

psImage* psMatrixInvert(psImage* outImage, const psImage* inImage, psF32 *det)
{
    psS32 signum = 0;
    psS32 numRows = 0;
    psS32 numCols = 0;
    gsl_matrix *inv = NULL;
    gsl_matrix *lu = NULL;
    gsl_permutation *perm = NULL;

    #define INVERT_CLEANUP { psFree(outImage); return NULL; }
    // Error checks
    PS_PTR_CHECK_NULL_GENERAL(det, INVERT_CLEANUP);
    PS_IMAGE_CHECK_NULL_GENERAL(inImage, INVERT_CLEANUP);
    PS_CHECK_POINTERS(inImage, outImage, INVERT_CLEANUP);
    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, INVERT_CLEANUP);
    PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, INVERT_CLEANUP);

    outImage = psImageRecycle(outImage, inImage->numCols, inImage->numRows, inImage->type.type);

    PS_CHECK_SQUARE(inImage, INVERT_CLEANUP);
    PS_CHECK_SQUARE(outImage, INVERT_CLEANUP);

    // Initialize data
    numRows = inImage->numRows;
    numCols = inImage->numCols;

    // Initialize GSL data
    perm = gsl_permutation_alloc(numRows);
    lu = gsl_matrix_alloc(numRows, numCols);
    inv = gsl_matrix_alloc(numRows, numCols);
    psImageToGslMatrix(lu, inImage);

    // Invert data and calculate determinant
    gsl_linalg_LU_decomp(lu, perm, &signum);
    gsl_linalg_LU_invert(lu, perm, inv);
    *det = (float)gsl_linalg_LU_det(lu, signum);

    // Copy GSL matrix data to psImage data
    gslMatrixToPsImage(outImage, inv);

    // Free GSL structs
    gsl_permutation_free(perm);
    gsl_matrix_free(lu);
    gsl_matrix_free(inv);

    return outImage;
}

psF32 *psMatrixDeterminant(const psImage* inImage)
{
    psS32 signum = 0;
    psS32 numRows = 0;
    psS32 numCols = 0;
    psF32 *det = NULL;
    gsl_matrix *lu = NULL;
    gsl_permutation *perm = NULL;

    #define DETERMINANT_EXIT { return NULL; }
    // Error checks
    PS_IMAGE_CHECK_NULL_GENERAL(inImage, DETERMINANT_EXIT);
    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, DETERMINANT_EXIT);
    PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, DETERMINANT_EXIT);
    PS_CHECK_SQUARE(inImage, DETERMINANT_EXIT);

    // Initialize data
    numRows = inImage->numRows;
    numCols = inImage->numCols;

    // Allocate GSL structs
    perm = gsl_permutation_alloc(numRows);
    lu = gsl_matrix_alloc(numRows, numCols);
    psImageToGslMatrix(lu, inImage);

    // Calculate determinant
    det = (psF32*)psAlloc(sizeof(psF32));
    gsl_linalg_LU_decomp(lu, perm, &signum);
    *det = (psF32)gsl_linalg_LU_det(lu, signum);

    // Free GSL structs
    gsl_permutation_free(perm);
    gsl_matrix_free(lu);

    return det;
}

psImage* psMatrixMultiply(psImage* outImage, psImage* inImage1, psImage* inImage2)
{
    psS32 numRows = 0;
    psS32 numCols = 0;
    gsl_matrix *m1 = NULL;
    gsl_matrix *m2 = NULL;
    gsl_matrix *m3 = NULL;

    #define MULTIPLY_CLEANUP { psFree(outImage); return NULL; }

    // Error checks
    PS_IMAGE_CHECK_NULL_GENERAL(inImage1, MULTIPLY_CLEANUP);
    PS_IMAGE_CHECK_NULL_GENERAL(inImage2, MULTIPLY_CLEANUP);
    PS_IMAGE_CHECK_EMPTY_GENERAL(inImage1, MULTIPLY_CLEANUP);
    PS_IMAGE_CHECK_EMPTY_GENERAL(inImage2, MULTIPLY_CLEANUP);
    PS_CHECK_DIMEN_AND_TYPE(inImage1, PS_DIMEN_IMAGE, MULTIPLY_CLEANUP);
    PS_CHECK_DIMEN_AND_TYPE(inImage2, PS_DIMEN_IMAGE, MULTIPLY_CLEANUP);
    PS_CHECK_POINTERS(inImage1, outImage, MULTIPLY_CLEANUP);
    PS_CHECK_POINTERS(inImage1, inImage2, MULTIPLY_CLEANUP);

    outImage = psImageRecycle(outImage, inImage2->numCols, inImage2->numRows, inImage2->type.type);

    PS_CHECK_SQUARE(inImage1, MULTIPLY_CLEANUP);
    PS_CHECK_SQUARE(inImage2, MULTIPLY_CLEANUP);
    PS_CHECK_SQUARE(outImage, MULTIPLY_CLEANUP);

    // Initialize data
    numRows = inImage1->numRows;
    numCols = inImage1->numCols;

    // Initialize GSL data
    m1 = gsl_matrix_alloc(numRows, numCols);
    psImageToGslMatrix(m1, inImage1);
    m2 = gsl_matrix_alloc(numRows, numCols);
    psImageToGslMatrix(m2, inImage2);
    m3 = gsl_matrix_alloc(numRows, numCols);
    psImageToGslMatrix(m3, outImage);

    // Perform multiplication
    gsl_linalg_matmult(m1, m2, m3);

    // Copy GSL matrix data to psImage data
    gslMatrixToPsImage(outImage, m3);

    // Free GSL structs
    gsl_matrix_free(m1);
    gsl_matrix_free(m2);
    gsl_matrix_free(m3);

    return outImage;
}

psImage* psMatrixTranspose(psImage* outImage, const psImage* inImage)
{
    psU32 i = 0;
    psU32 j = 0;
    psS32 numRowsIn = 0;
    psS32 numColsIn = 0;
    psS32 numRowsOut = 0;
    psS32 numColsOut = 0;

    #define TRANSPOSE_CLEANUP { psFree(outImage); return NULL; }
    // Error checks
    PS_IMAGE_CHECK_NULL_GENERAL(inImage, TRANSPOSE_CLEANUP);
    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, TRANSPOSE_CLEANUP);
    PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, TRANSPOSE_CLEANUP);
    PS_CHECK_POINTERS(inImage, outImage, TRANSPOSE_CLEANUP);

    outImage = psImageRecycle(outImage, inImage->numCols, inImage->numRows, inImage->type.type);

    // Initialize data
    numRowsIn = inImage->numRows;
    numColsIn = inImage->numCols;
    numRowsOut = outImage->numRows;
    numColsOut = outImage->numCols;

    if(numRowsIn!=numColsOut && numRowsOut!=numColsIn) {
        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMatrix_TRANSPOSE_MISMATCH);
        TRANSPOSE_CLEANUP;
    }

    if(outImage->type.type == PS_TYPE_F32) {
        for(i=0; i<numRowsOut; i++) {
            for(j=0; j<numColsOut; j++) {
                outImage->data.F32[i][j] = inImage->data.F32[j][i];
            }
        }
    } else {
        for(i=0; i<numRowsOut; i++) {
            for(j=0; j<numColsOut; j++) {
                outImage->data.F64[i][j] = inImage->data.F64[j][i];
            }
        }
    }

    return outImage;
}

psImage* psMatrixEigenvectors(psImage* outImage, psImage* inImage)
{
    psS32 numRows = 0;
    psS32 numCols = 0;
    gsl_vector *eVals = NULL;
    gsl_eigen_symmv_workspace *w = NULL;
    gsl_matrix *out = NULL;
    gsl_matrix *in = NULL;

    #define EIGENVECTORS_CLEANUP { psFree(outImage); return NULL; }
    // Error checks
    PS_IMAGE_CHECK_NULL_GENERAL(inImage, EIGENVECTORS_CLEANUP);
    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, EIGENVECTORS_CLEANUP);
    PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, EIGENVECTORS_CLEANUP);
    PS_CHECK_POINTERS(inImage, outImage, EIGENVECTORS_CLEANUP);

    outImage = psImageRecycle(outImage, inImage->numCols, inImage->numRows, inImage->type.type);

    // Initialize data
    numRows = inImage->numRows;
    numCols = inImage->numCols;

    in = gsl_matrix_alloc(numRows, numCols);
    psImageToGslMatrix(in, inImage);
    out = gsl_matrix_alloc(numRows, numCols);

    // Allocate GSL structs
    eVals = gsl_vector_alloc(numRows);
    w = gsl_eigen_symmv_alloc(numRows);

    // Non-square matrices not allowed
    PS_CHECK_SQUARE(inImage, EIGENVECTORS_CLEANUP);
    PS_CHECK_SQUARE(outImage, EIGENVECTORS_CLEANUP);

    // Calculate Eigenvalues and Eigenvectors...Eigenvalues not currently used
    gsl_eigen_symmv(in, eVals, out, w);

    // Copy GSL matrix data to psImage data
    gslMatrixToPsImage(outImage, out);

    // Free GSL structs
    gsl_matrix_free(in);
    gsl_matrix_free(out);
    gsl_eigen_symmv_free(w);
    gsl_vector_free(eVals);

    return outImage;
}

psVector* psMatrixToVector(psVector* outVector, const psImage* inImage)
{
    psS32 size = 0;

    #define psMatrixToVector_EXIT {psFree(outVector); return NULL;}

    // Error checks
    PS_IMAGE_CHECK_NULL_GENERAL(inImage, psMatrixToVector_EXIT);
    PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, psMatrixToVector_EXIT);
    PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, psMatrixToVector_EXIT);

    if (inImage->numRows == 1) {
        // Create transposed row vector
        outVector = psVectorRecycle(outVector, inImage->numCols, inImage->type.type);
        outVector->type.dimen = PS_DIMEN_TRANSV;
    } else if (inImage->numCols == 1) {
        // Create non-transposed column vector
        outVector = psVectorRecycle(outVector, inImage->numRows, inImage->type.type);
    } else {
        psError(PS_ERR_BAD_PARAMETER_SIZE, true,
                "Image does not have dim with 1 col or 1 row: (%d x %d).",
                inImage->numRows, inImage->numCols);
        psMatrixToVector_EXIT;
    }

    // More checks
    if (outVector->type.dimen == PS_DIMEN_VECTOR) {
        PS_CHECK_DIMEN_AND_TYPE(outVector, PS_DIMEN_VECTOR, psMatrixToVector_EXIT);

        if (outVector->n == 0) {
            outVector->n = inImage->numRows;
        }

        if (outVector->n != inImage->numRows) {
            psError(PS_ERR_BAD_PARAMETER_SIZE, true,
                    "Image and vector sizes differ: (%d vs %d).",
                    inImage->numRows, outVector->n);
            psMatrixToVector_EXIT;
        }

        size = PSELEMTYPE_SIZEOF(inImage->type.type) * inImage->numRows;

    } else if (outVector->type.dimen == PS_DIMEN_TRANSV) {
        PS_CHECK_DIMEN_AND_TYPE(outVector, PS_DIMEN_TRANSV, psMatrixToVector_EXIT);

        if (outVector->n == 0) {
            outVector->n = inImage->numCols;
        }

        if (outVector->n != inImage->numCols) {
            psError(PS_ERR_BAD_PARAMETER_SIZE, true,
                    "Image and vector sizes differ: (%d vs %d).",
                    inImage->numCols, outVector->n);
            psMatrixToVector_EXIT;
        }

        size = PSELEMTYPE_SIZEOF(inImage->type.type) * inImage->numCols;
    }

    memcpy(outVector->data.U8, inImage->data.U8[0], size);

    return outVector;
}

psImage* psVectorToMatrix(psImage* outImage, const psVector* inVector)
{
    psS32 size = 0;

    #define VECTORTOMATRIX_CLEANUP {psFree(outImage); return NULL; }
    // Error checks
    PS_VECTOR_CHECK_NULL_GENERAL(inVector, VECTORTOMATRIX_CLEANUP);

    if (inVector->type.dimen == PS_DIMEN_VECTOR) {
        PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_VECTOR, VECTORTOMATRIX_CLEANUP);
        PS_VECTOR_CHECK_EMPTY_GENERAL(inVector, VECTORTOMATRIX_CLEANUP);

        outImage = psImageRecycle(outImage, 1, inVector->n, inVector->type.type);

        // More checks for PS_DIMEN_VECTOR
        if (outImage->numCols > 1) {
            psError(PS_ERR_BAD_PARAMETER_SIZE, true,
                    "Image has more than 1 column: numCols = %d.",
                    outImage->numCols);
            VECTORTOMATRIX_CLEANUP;
        } else if (outImage->numRows != inVector->n) {
            psError(PS_ERR_BAD_PARAMETER_SIZE, true,
                    "Image and vector sizes differ: (%d vs %d).",
                    outImage->numRows, inVector->n);
            VECTORTOMATRIX_CLEANUP;
        }

        size = PSELEMTYPE_SIZEOF(outImage->type.type) * outImage->numRows;

    } else if (inVector->type.dimen == PS_DIMEN_TRANSV) {
        PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_TRANSV, VECTORTOMATRIX_CLEANUP);
        PS_VECTOR_CHECK_EMPTY_GENERAL(inVector, VECTORTOMATRIX_CLEANUP);
        outImage = psImageRecycle(outImage, inVector->n, 1, inVector->type.type);
        // More checks for PS_DIMEN_TRANSV
        if (outImage->numRows > 1) {
            psError(PS_ERR_BAD_PARAMETER_SIZE, true,
                    "Image has more than 1 row: numRows = %d.",
                    outImage->numRows);
            VECTORTOMATRIX_CLEANUP;
        } else if (outImage->numCols != inVector->n) {
            psError(PS_ERR_BAD_PARAMETER_SIZE, true,
                    "Image and vector sizes differ: (%d vs %d).",
                    outImage->numCols, inVector->n);
            VECTORTOMATRIX_CLEANUP;
        }

        size = PSELEMTYPE_SIZEOF(outImage->type.type) * outImage->numCols;
    }

    PS_IMAGE_CHECK_NULL_GENERAL(outImage, VECTORTOMATRIX_CLEANUP);
    PS_CHECK_DIMEN_AND_TYPE(outImage, PS_DIMEN_IMAGE, VECTORTOMATRIX_CLEANUP);

    memcpy(outImage->data.U8[0], inVector->data.U8, size);

    return outImage;
}
