base.hpp

Go to the documentation of this file.

// OpenBEM - Copyright (C) 2026 Shashwat Sharma
 
// This file is part of OpenBEM.
 
// OpenBEM is free software: you can redistribute it and/or modify it under the terms of the
// GNU General Public License as published by the Free Software Foundation, either version 3
// of the License, or (at your option) any later version.
 
// You should have received a copy of the GNU General Public License along with OpenBEM.
// If not, see <https://www.gnu.org/licenses/>.
 
 
#ifndef MATRIX_BASE_HPP
#define MATRIX_BASE_HPP
 
#include <stdexcept>
#include <cmath>
#include <vector>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <string>
 
#include "types.hpp"
 
 
namespace bem
{
 
template <typename T>
class MatrixBase
{
public:
 
    virtual Index num_rows() const = 0;
 
 
    virtual Index num_cols() const = 0;
 
 
    virtual void resize(Index rows, Index cols) = 0;
 
 
    virtual void clear() = 0;
 
 
    virtual T value(Index row, Index col) const = 0;
 
 
    virtual void set_value(Index row, Index col, const T& a) = 0;
 
 
    virtual void add_ax(const MatrixBase<T>& x, const T& a = T(1)) = 0;
 
 
    virtual void scale(const T& a) = 0;
 
 
    virtual void set_zero() = 0;
 
 
    virtual const T* data() const = 0;
 
 
    virtual T* data() = 0;
 
 
    virtual void mat_solve(MatrixBase<T>& x, const MatrixBase<T>& b) = 0;
 
 
    virtual Index size() const { return num_rows() * num_cols(); };
 
 
    virtual void add_value(Index row, Index col, const T& a)
    {
        set_value(row, col, value(row, col) + a);
        return;
    };
 
 
    virtual void preallocate(const std::vector<Index>& nnz) {};
 
 
    virtual void preallocate(Index num_entries) {};
 
 
    virtual void assemble() {};
 
 
    virtual void set_identity()
    {
        set_zero();
        for (Index ii = 0; ii < num_rows(); ++ii)
            set_value(ii, ii, T(1));
        return;
    };
 
 
    virtual void write_binary(const std::string name = "matrix") const
    {
        std::ofstream out (name, std::ios::out | std::ios::binary | std::ios::trunc);
        Index rows = num_rows(), cols = num_cols();
        out.write((char*) (&rows), sizeof(Index));
        out.write((char*) (&cols), sizeof(Index));
        out.write((char*) data(), rows * cols * sizeof(T));
        out.close();
        return;
    };
 
 
    virtual void read_binary(const std::string name = "matrix")
    {
        std::ifstream in (name, std::ios::in | std::ios::binary);
        Index rows = 0, cols = 0;
        in.read((char*) (&rows), sizeof(Index));
        in.read((char*) (&cols), sizeof(Index));
        resize(rows, cols);
        in.read((char *) data() , rows * cols * sizeof(T));
        in.close();
        return;
    };
 
 
    virtual void print(const std::string name = "matrix") const
    {
        std::cout << "\n--- " << name << " (" << num_rows() << " x " << num_cols() << ") ---" << std::endl;
        for (Index ii = 0; ii < num_rows(); ++ii)
        {
            for (Index jj = 0; jj < num_cols(); ++jj)
            {
                std::cout << std::scientific
                          << std::setprecision(4)
                          << std::setw(14)
                          << value(ii, jj)
                          << "  "
                          << std::flush;
            }
            std::cout << std::endl;
        }
        std::cout << "---" << std::endl;
        return;
    };
 
};
 
}
 
#endif