matblock_io.c

Go to the documentation of this file.

/*
 * This work is licensed under a Creative Commons 
 * Attribution-Noncommercial-Share Alike 3.0 United States License.
 * 
 *    http://creativecommons.org/licenses/by-nc-sa/3.0/us/
 * 
 * You are free:
 * 
 *    to Share - to copy, distribute, display, and perform the work
 *    to Remix - to make derivative works
 * 
 * Under the following conditions:
 * 
 *    Attribution. You must attribute the work in the manner specified by the
 *    author or licensor (but not in any way that suggests that they endorse you
 *    or your use of the work).
 * 
 *    Noncommercial. You may not use this work for commercial purposes.
 * 
 *    Share Alike. If you alter, transform, or build upon this work, you may
 *    distribute the resulting work only under the same or similar license to
 *    this one.
 * 
 * For any reuse or distribution, you must make clear to others the license
 * terms of this work. The best way to do this is by including this header.
 * 
 * Any of the above conditions can be waived if you get permission from the
 * copyright holder.
 * 
 * Apart from the remix rights granted under this license, nothing in this
 * license impairs or restricts the author's moral rights.
 */


#include <jwsc/config.h>

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <inttypes.h>
#include <assert.h>
#include <ctype.h>

#include "jwsc/base/error.h"
#include "jwsc/base/file_io.h"
#include "jwsc/math/complex.h"
#include "jwsc/matblock/matblock.h"
#include "jwsc/matblock/matblock_io.h"


Error* read_matblock_with_header_u32(Matblock_u32** m_out, const char* fname)
{
    FILE*  fp;
    Error* e;

    if ((fp = fopen(fname, "r")) == NULL)
    {
        free_matblock_u32(*m_out); *m_out = NULL;
        return JWSC_EIO(strerror(errno));
    }

    if ((e = read_matblock_with_header_fp_u32(m_out, fp)) != NULL)
    {
        fclose(fp);
        return e;
    }

    if (fclose(fp) != 0)
    {
        free_matblock_u32(*m_out); *m_out = NULL;
        return JWSC_EIO(strerror(errno));
    }

    return NULL;
}

Error* read_matblock_with_header_i32(Matblock_i32** m_out, const char* fname)
{
    FILE*  fp;
    Error* e;

    if ((fp = fopen(fname, "r")) == NULL)
    {
        free_matblock_i32(*m_out); *m_out = NULL;
        return JWSC_EIO(strerror(errno));
    }

    if ((e = read_matblock_with_header_fp_i32(m_out, fp)) != NULL)
    {
        fclose(fp);
        return e;
    }

    if (fclose(fp) != 0)
    {
        free_matblock_i32(*m_out); *m_out = NULL;
        return JWSC_EIO(strerror(errno));
    }

    return NULL;
}

Error* read_matblock_with_header_i64(Matblock_i64** m_out, const char* fname)
{
    FILE*  fp;
    Error* e;

    if ((fp = fopen(fname, "r")) == NULL)
    {
        free_matblock_i64(*m_out); *m_out = NULL;
        return JWSC_EIO(strerror(errno));
    }

    if ((e = read_matblock_with_header_fp_i64(m_out, fp)) != NULL)
    {
        fclose(fp);
        return e;
    }

    if (fclose(fp) != 0)
    {
        free_matblock_i64(*m_out); *m_out = NULL;
        return JWSC_EIO(strerror(errno));
    }

    return NULL;
}

Error* read_matblock_with_header_f(Matblock_f** m_out, const char* fname)
{
    FILE*  fp;
    Error* e;

    if ((fp = fopen(fname, "r")) == NULL)
    {
        free_matblock_f(*m_out); *m_out = NULL;
        return JWSC_EIO(strerror(errno));
    }

    if ((e = read_matblock_with_header_fp_f(m_out, fp)) != NULL)
    {
        fclose(fp);
        return e;
    }

    if (fclose(fp) != 0)
    {
        free_matblock_f(*m_out); *m_out = NULL;
        return JWSC_EIO(strerror(errno));
    }

    return NULL;
}

Error* read_matblock_with_header_d(Matblock_d** m_out, const char* fname)
{
    FILE*  fp;
    Error* e;

    if ((fp = fopen(fname, "r")) == NULL)
    {
        free_matblock_d(*m_out); *m_out = NULL;
        return JWSC_EIO(strerror(errno));
    }

    if ((e = read_matblock_with_header_fp_d(m_out, fp)) != NULL)
    {
        fclose(fp);
        return e;
    }

    if (fclose(fp) != 0)
    {
        free_matblock_d(*m_out); *m_out = NULL;
        return JWSC_EIO(strerror(errno));
    }

    return NULL;
}

Error* read_matblock_with_header_cf(Matblock_cf** m_out, const char* fname)
{
    FILE*  fp;
    Error* e;

    if ((fp = fopen(fname, "r")) == NULL)
    {
        free_matblock_cf(*m_out); *m_out = NULL;
        return JWSC_EIO(strerror(errno));
    }

    if ((e = read_matblock_with_header_fp_cf(m_out, fp)) != NULL)
    {
        fclose(fp);
        return e;
    }

    if (fclose(fp) != 0)
    {
        free_matblock_cf(*m_out); *m_out = NULL;
        return JWSC_EIO(strerror(errno));
    }

    return NULL;
}

Error* read_matblock_with_header_cd(Matblock_cd** m_out, const char* fname)
{
    FILE*  fp;
    Error* e;

    if ((fp = fopen(fname, "r")) == NULL)
    {
        free_matblock_cd(*m_out); *m_out = NULL;
        return JWSC_EIO(strerror(errno));
    }

    if ((e = read_matblock_with_header_fp_cd(m_out, fp)) != NULL)
    {
        fclose(fp);
        return e;
    }

    if (fclose(fp) != 0)
    {
        free_matblock_cd(*m_out); *m_out = NULL;
        return JWSC_EIO(strerror(errno));
    }

    return NULL;
}

Error* read_matblock_with_header_fp_u32(Matblock_u32** m_out, FILE* fp)
{
    uint32_t num_mats, num_rows, num_cols;
    uint32_t mat, row, col;
    Matblock_u32* m;

    if (skip_fp_spaces_and_comments(fp) == 0)
    {
        free_matblock_u32(*m_out); *m_out = NULL;
        return JWSC_EIO("No matblock to read in file");
    }

    if (fscanf(fp, "num_mats=%u num_rows=%u num_cols=%u\n", &num_mats,
                &num_rows, &num_cols) != 3)
    {
        free_matblock_u32(*m_out); *m_out = NULL;
        return JWSC_EIO("File to read matblock from not formatted properly");
    }

    create_matblock_u32(m_out, num_mats, num_rows, num_cols);
    m = *m_out;

    for (mat = 0; mat < num_mats; mat++)
    {
        for (row = 0; row < num_rows; row++)
        {
            for (col = 0; col < num_cols; col++)
            {
                if (fscanf(fp, "%u", &(m->elts[ mat ][ row ][ col ])) != 1)
                {
                    free_matblock_u32(*m_out); *m_out = NULL;
                    return JWSC_EIO("File to read matblock from not formatted properly");
                }
            }
        }
    }

    return NULL;
}

Error* read_matblock_with_header_fp_i32(Matblock_i32** m_out, FILE* fp)
{
    uint32_t num_mats, num_rows, num_cols;
    uint32_t mat, row, col;
    Matblock_i32* m;

    if (skip_fp_spaces_and_comments(fp) == 0)
    {
        free_matblock_i32(*m_out); *m_out = NULL;
        return JWSC_EIO("No matblock to read in file");
    }

    if (fscanf(fp, "num_mats=%u num_rows=%u num_cols=%u\n", &num_mats,
                &num_rows, &num_cols) != 3)
    {
        free_matblock_i32(*m_out); *m_out = NULL;
        return JWSC_EIO("File to read matblock from not formatted properly");
    }

    create_matblock_i32(m_out, num_mats, num_rows, num_cols);
    m = *m_out;

    for (mat = 0; mat < num_mats; mat++)
    {
        for (row = 0; row < num_rows; row++)
        {
            for (col = 0; col < num_cols; col++)
            {
                if (fscanf(fp, "%d", &(m->elts[ mat ][ row ][ col ])) != 1)
                {
                    free_matblock_i32(*m_out); *m_out = NULL;
                    return JWSC_EIO("File to read matblock from not formatted properly");
                }
            }
        }
    }

    return NULL;
}

Error* read_matblock_with_header_fp_i64(Matblock_i64** m_out, FILE* fp)
{
    uint32_t num_mats, num_rows, num_cols;
    uint32_t mat, row, col;
    Matblock_i64* m;

    if (skip_fp_spaces_and_comments(fp) == 0)
    {
        free_matblock_i64(*m_out); *m_out = NULL;
        return JWSC_EIO("No matblock to read in file");
    }

    if (fscanf(fp, "num_mats=%u num_rows=%u num_cols=%u\n", &num_mats,
                &num_rows, &num_cols) != 3)
    {
        free_matblock_i64(*m_out); *m_out = NULL;
        return JWSC_EIO("File to read matblock from not formatted properly");
    }

    create_matblock_i64(m_out, num_mats, num_rows, num_cols);
    m = *m_out;

    for (mat = 0; mat < num_mats; mat++)
    {
        for (row = 0; row < num_rows; row++)
        {
            for (col = 0; col < num_cols; col++)
            {
                if (fscanf(fp, "%" SCNd64, &(m->elts[ mat ][ row ][ col ])) != 1)
                {
                    free_matblock_i64(*m_out); *m_out = NULL;
                    return JWSC_EIO("File to read matblock from not formatted properly");
                }
            }
        }
    }

    return NULL;
}

Error* read_matblock_with_header_fp_f(Matblock_f** m_out, FILE* fp)
{
    uint32_t num_mats, num_rows, num_cols;
    uint32_t mat, row, col;
    Matblock_f* m;

    if (skip_fp_spaces_and_comments(fp) == 0)
    {
        free_matblock_f(*m_out); *m_out = NULL;
        return JWSC_EIO("No matblock to read in file");
    }

    if (fscanf(fp, "num_mats=%u num_rows=%u num_cols=%u\n", &num_mats,
                &num_rows, &num_cols) != 3)
    {
        free_matblock_f(*m_out); *m_out = NULL;
        return JWSC_EIO("File to read matblock from not formatted properly");
    }

    create_matblock_f(m_out, num_mats, num_rows, num_cols);
    m = *m_out;

    for (mat = 0; mat < num_mats; mat++)
    {
        for (row = 0; row < num_rows; row++)
        {
            for (col = 0; col < num_cols; col++)
            {
                if (fscanf(fp, "%f", &(m->elts[ mat ][ row ][ col ])) != 1)
                {
                    free_matblock_f(*m_out); *m_out = NULL;
                    return JWSC_EIO("File to read matblock from not formatted properly");
                }
            }
        }
    }

    return NULL;
}

Error* read_matblock_with_header_fp_d(Matblock_d** m_out, FILE* fp)
{
    uint32_t num_mats, num_rows, num_cols;
    uint32_t mat, row, col;
    Matblock_d* m;

    if (skip_fp_spaces_and_comments(fp) == 0)
    {
        free_matblock_d(*m_out); *m_out = NULL;
        return JWSC_EIO("No matblock to read in file");
    }

    if (fscanf(fp, "num_mats=%u num_rows=%u num_cols=%u\n", &num_mats,
                &num_rows, &num_cols) != 3)
    {
        free_matblock_d(*m_out); *m_out = NULL;
        return JWSC_EIO("File to read matblock from not formatted properly");
    }

    create_matblock_d(m_out, num_mats, num_rows, num_cols);
    m = *m_out;

    for (mat = 0; mat < num_mats; mat++)
    {
        for (row = 0; row < num_rows; row++)
        {
            for (col = 0; col < num_cols; col++)
            {
                if (fscanf(fp, "%lf", &(m->elts[ mat ][ row ][ col ])) != 1)
                {
                    free_matblock_d(*m_out); *m_out = NULL;
                    return JWSC_EIO("File to read matblock from not formatted properly");
                }
            }
        }
    }

    return NULL;
}

Error* read_matblock_with_header_fp_cf(Matblock_cf** m_out, FILE* fp)
{
    uint32_t num_mats, num_rows, num_cols;
    uint32_t mat, row, col;
    Matblock_cf* m;

    if (skip_fp_spaces_and_comments(fp) == 0)
    {
        free_matblock_cf(*m_out); *m_out = NULL;
        return JWSC_EIO("No matblock to read in file");
    }

    if (fscanf(fp, "num_mats=%u num_rows=%u num_cols=%u\n", &num_mats,
                &num_rows, &num_cols) != 3)
    {
        free_matblock_cf(*m_out); *m_out = NULL;
        return JWSC_EIO("File to read matblock from not formatted properly");
    }

    create_matblock_cf(m_out, num_mats, num_rows, num_cols);
    m = *m_out;

    for (mat = 0; mat < num_mats; mat++)
    {
        for (row = 0; row < num_rows; row++)
        {
            for (col = 0; col < num_cols; col++)
            {
                if (fscanf(fp, "%f %f", &(m->elts[ mat ][ row ][ col ].r), 
                            &(m->elts[ mat ][ row ][ col ].i)) != 3)
                {
                    free_matblock_cf(*m_out); *m_out = NULL;
                    return JWSC_EIO("File to read matblock from not formatted properly");
                }
            }
        }
    }

    return NULL;
}

Error* read_matblock_with_header_fp_cd(Matblock_cd** m_out, FILE* fp)
{
    uint32_t num_mats, num_rows, num_cols;
    uint32_t mat, row, col;
    Matblock_cd* m;

    if (skip_fp_spaces_and_comments(fp) == 0)
    {
        free_matblock_cd(*m_out); *m_out = NULL;
        return JWSC_EIO("No matblock to read in file");
    }

    if (fscanf(fp, "num_mats=%u num_rows=%u num_cols=%u\n", &num_mats,
                &num_rows, &num_cols) != 3)
    {
        free_matblock_cd(*m_out); *m_out = NULL;
        return JWSC_EIO("File to read matblock from not formatted properly");
    }

    create_matblock_cd(m_out, num_mats, num_rows, num_cols);
    m = *m_out;

    for (mat = 0; mat < num_mats; mat++)
    {
        for (row = 0; row < num_rows; row++)
        {
            for (col = 0; col < num_cols; col++)
            {
                if (fscanf(fp, "%lf %lf", &(m->elts[ mat ][ row ][ col ].r),
                            &(m->elts[ mat ][ row ][ col ].i)) == 2)
                {
                    free_matblock_cd(*m_out); *m_out = NULL;
                    return JWSC_EIO("File to read matblock from not formatted properly");
                }
            }
        }
    }

    return NULL;
}

Error* write_matblock_with_header_u32(const Matblock_u32* m, const char* fname)
{
    FILE* fp;

    if ((fp = fopen(fname, "w")) == NULL)
    {
        return JWSC_EIO(strerror(errno));
    }

    write_matblock_with_header_fp_u32(m, fp);

    if (fclose(fp) != 0)
    {
        return JWSC_EIO(strerror(errno));
    }

    return NULL;
}

Error* write_matblock_with_header_i32(const Matblock_i32* m, const char* fname)
{
    FILE* fp;

    if ((fp = fopen(fname, "w")) == NULL)
    {
        return JWSC_EIO(strerror(errno));
    }

    write_matblock_with_header_fp_i32(m, fp);

    if (fclose(fp) != 0)
    { return JWSC_EIO(strerror(errno));
    }

    return NULL;
}

Error* write_matblock_with_header_i64(const Matblock_i64* m, const char* fname)
{
    FILE* fp;

    if ((fp = fopen(fname, "w")) == NULL)
    {
        return JWSC_EIO(strerror(errno));
    }

    write_matblock_with_header_fp_i64(m, fp);

    if (fclose(fp) != 0)
    {
        return JWSC_EIO(strerror(errno));
    }

    return NULL;
}

Error* write_matblock_with_header_f(const Matblock_f* m, const char* fname)
{
    FILE* fp;

    if ((fp = fopen(fname, "w")) == NULL)
    {
        return JWSC_EIO(strerror(errno));
    }

    write_matblock_with_header_fp_f(m, fp);

    if (fclose(fp) != 0)
    {
        return JWSC_EIO(strerror(errno));
    }

    return NULL;
}

Error* write_matblock_with_header_d(const Matblock_d* m, const char* fname)
{
    FILE* fp;

    if ((fp = fopen(fname, "w")) == NULL)
    {
        return JWSC_EIO(strerror(errno));
    }

    write_matblock_with_header_fp_d(m, fp);

    if (fclose(fp) != 0)
    {
        return JWSC_EIO(strerror(errno));
    }

    return NULL;
}

Error* write_matblock_with_header_cf(const Matblock_cf* m, const char* fname)
{
    FILE* fp;

    if ((fp = fopen(fname, "w")) == NULL)
    {
        return JWSC_EIO(strerror(errno));
    }

    write_matblock_with_header_fp_cf(m, fp);

    if (fclose(fp) != 0)
    {
        return JWSC_EIO(strerror(errno));
    }

    return NULL;
}

Error* write_matblock_with_header_cd(const Matblock_cd* m, const char* fname)
{
    FILE* fp;

    if ((fp = fopen(fname, "w")) == NULL)
    {
        return JWSC_EIO(strerror(errno));
    }

    write_matblock_with_header_fp_cd(m, fp);

    if (fclose(fp) != 0)
    {
        return JWSC_EIO(strerror(errno));
    }

    return NULL;
}

Error* write_matblock_with_header_fp_u32(const Matblock_u32* m, FILE* fp)
{
    uint32_t num_mats, num_rows, num_cols;
    uint32_t mat, row, col;

    num_mats = m->num_mats;
    num_rows = m->num_rows;
    num_cols = m->num_cols;
    fprintf(fp, "num_mats=%u num_rows=%u num_cols=%u\n", num_mats, num_rows,
            num_cols);

    for (mat = 0; mat < num_mats; mat++)
    {
        for (row = 0; row < num_rows; row++)
        {
            for (col = 0; col < num_cols; col++)
            {
                fprintf(fp, "%u ", m->elts[ mat ][ row ][ col ]);
            }
            fprintf(fp, "\n");
        }
    }

    return NULL;
}

Error* write_matblock_with_header_fp_i32(const Matblock_i32* m, FILE* fp)
{
    uint32_t num_mats, num_rows, num_cols;
    uint32_t mat, row, col;

    num_mats = m->num_mats;
    num_rows = m->num_rows;
    num_cols = m->num_cols;
    fprintf(fp, "num_mats=%u num_rows=%u num_cols=%u\n", num_mats, num_rows,
            num_cols);

    for (mat = 0; mat < num_mats; mat++)
    {
        for (row = 0; row < num_rows; row++)
        {
            for (col = 0; col < num_cols; col++)
            {
                fprintf(fp, "%d ", m->elts[ mat ][ row ][ col ]);
            }
            fprintf(fp, "\n");
        }
    }

    return NULL;
}

Error* write_matblock_with_header_fp_i64(const Matblock_i64* m, FILE* fp)
{
    uint32_t num_mats, num_rows, num_cols;
    uint32_t mat, row, col;

    num_mats = m->num_mats;
    num_rows = m->num_rows;
    num_cols = m->num_cols;
    fprintf(fp, "num_mats=%u num_rows=%u num_cols=%u\n", num_mats, num_rows,
            num_cols);

    for (mat = 0; mat < num_mats; mat++)
    {
        for (row = 0; row < num_rows; row++)
        {
            for (col = 0; col < num_cols; col++)
            {
                fprintf(fp, "%" PRId64 " ", m->elts[ mat ][ row ][ col ]);
            }
            fprintf(fp, "\n");
        }
    }

    return NULL;
}

Error* write_matblock_with_header_fp_f(const Matblock_f* m, FILE* fp)
{
    uint32_t num_mats, num_rows, num_cols;
    uint32_t mat, row, col;

    num_mats = m->num_mats;
    num_rows = m->num_rows;
    num_cols = m->num_cols;
    fprintf(fp, "num_mats=%u num_rows=%u num_cols=%u\n", num_mats, num_rows,
            num_cols);

    for (mat = 0; mat < num_mats; mat++)
    {
        for (row = 0; row < num_rows; row++)
        {
            for (col = 0; col < num_cols; col++)
            {
                fprintf(fp, "%f ", m->elts[ mat ][ row ][ col ]);
            }
            fprintf(fp, "\n");
        }
    }

    return NULL;
}

Error* write_matblock_with_header_fp_d(const Matblock_d* m, FILE* fp)
{
    uint32_t num_mats, num_rows, num_cols;
    uint32_t mat, row, col;

    num_mats = m->num_mats;
    num_rows = m->num_rows;
    num_cols = m->num_cols;
    fprintf(fp, "num_mats=%u num_rows=%u num_cols=%u\n", num_mats, num_rows,
            num_cols);

    for (mat = 0; mat < num_mats; mat++)
    {
        for (row = 0; row < num_rows; row++)
        {
            for (col = 0; col < num_cols; col++)
            {
                fprintf(fp, "%.8e ", m->elts[ mat ][ row ][ col ]);
            }
            fprintf(fp, "\n");
        }
    }

    return NULL;
}

Error* write_matblock_with_header_fp_cf(const Matblock_cf* m, FILE* fp)
{
    uint32_t num_mats, num_rows, num_cols;
    uint32_t mat, row, col;

    num_mats = m->num_mats;
    num_rows = m->num_rows;
    num_cols = m->num_cols;
    fprintf(fp, "num_mats=%u num_rows=%u num_cols=%u\n", num_mats, num_rows,
            num_cols);

    for (mat = 0; mat < num_mats; mat++)
    {
        for (row = 0; row < num_rows; row++)
        {
            for (col = 0; col < num_cols; col++)
            {
                fprintf(fp, "%f %f ", m->elts[ mat ][ row ][ col ].r,
                        m->elts[ mat ][ row ][ col ].i);
            }
            fprintf(fp, "\n");
        }
    }

    return NULL;
}

Error* write_matblock_with_header_fp_cd(const Matblock_cd* m, FILE* fp)
{
    uint32_t num_mats, num_rows, num_cols;
    uint32_t mat, row, col;

    num_mats = m->num_mats;
    num_rows = m->num_rows;
    num_cols = m->num_cols;
    fprintf(fp, "num_mats=%u num_rows=%u num_cols=%u\n", num_mats, num_rows,
            num_cols);

    for (mat = 0; mat < num_mats; mat++)
    {
        for (row = 0; row < num_rows; row++)
        {
            for (col = 0; col < num_cols; col++)
            {
                fprintf(fp, "%lf %lf ", m->elts[ mat ][ row ][ col ].r,
                        m->elts[ mat ][ row ][ col ].i);
            }
            fprintf(fp, "\n");
        }
    }

    return NULL;
}