Арифмитические операции над динамическими матрицами

class matrix_t {
  int ** data;
  unsigned int rows;
  unsigned int collumns;
  
  matrix_t add( matrix_t & other );
  matrix_t sub( matrix_t & other );
  matrix_t mul( matrix_t & other );
  matrix_t trans( matrix_t & other );
 
  std::ifstream & read( std::ifstream & stream );
  std::ofstream & write( std::ofstream & stream );
};

option(HUNTER_ENABLED "Enable Hunter package manager support" ON)
if(HUNTER_ENABLED)
  if(CMAKE_VERSION VERSION_LESS "3.0")
    message(FATAL_ERROR "At least CMake version 3.0 required for hunter dependency management."
      " Update CMake or set HUNTER_ENABLED to OFF.")
  endif()
endif()
 
include(CMakeParseArguments) # cmake_parse_arguments
 
option(HUNTER_STATUS_PRINT "Print working status" ON)
option(HUNTER_STATUS_DEBUG "Print a lot info" OFF)
 
set(HUNTER_WIKI "https://github.com/ruslo/hunter/wiki")
 
function(hunter_gate_status_print)
  foreach(print_message ${ARGV})
    if(HUNTER_STATUS_PRINT OR HUNTER_STATUS_DEBUG)
      message(STATUS "[hunter] ${print_message}")
    endif()
  endforeach()
endfunction()
 
function(hunter_gate_status_debug)
  foreach(print_message ${ARGV})
    if(HUNTER_STATUS_DEBUG)
      string(TIMESTAMP timestamp)
      message(STATUS "[hunter *** DEBUG *** ${timestamp}] ${print_message}")
    endif()
  endforeach()
endfunction()
 
function(hunter_gate_wiki wiki_page)
  message("------------------------------ WIKI -------------------------------")
  message("    ${HUNTER_WIKI}/${wiki_page}")
  message("-------------------------------------------------------------------")
  message("")
  message(FATAL_ERROR "")
endfunction()
 
function(hunter_gate_internal_error)
  message("")
  foreach(print_message ${ARGV})
    message("[hunter ** INTERNAL **] ${print_message}")
  endforeach()
  message("[hunter ** INTERNAL **] [Directory:${CMAKE_CURRENT_LIST_DIR}]")
  message("")
  hunter_gate_wiki("error.internal")
endfunction()
 
function(hunter_gate_fatal_error)
  cmake_parse_arguments(hunter "" "WIKI" "" "${ARGV}")
  string(COMPARE EQUAL "${hunter_WIKI}" "" have_no_wiki)
  if(have_no_wiki)
    hunter_gate_internal_error("Expected wiki")
  endif()
  message("")
  foreach(x ${hunter_UNPARSED_ARGUMENTS})
    message("[hunter ** FATAL ERROR **] ${x}")
  endforeach()
  message("[hunter ** FATAL ERROR **] [Directory:${CMAKE_CURRENT_LIST_DIR}]")
  message("")
  hunter_gate_wiki("${hunter_WIKI}")
endfunction()
 
function(hunter_gate_user_error)
  hunter_gate_fatal_error(${ARGV} WIKI "error.incorrect.input.data")
endfunction()
 
function(hunter_gate_self root version sha1 result)
  string(COMPARE EQUAL "${root}" "" is_bad)
  if(is_bad)
    hunter_gate_internal_error("root is empty")
  endif()
 
  string(COMPARE EQUAL "${version}" "" is_bad)
  if(is_bad)
    hunter_gate_internal_error("version is empty")
  endif()
 
  string(COMPARE EQUAL "${sha1}" "" is_bad)
  if(is_bad)
    hunter_gate_internal_error("sha1 is empty")
  endif()
 
  string(SUBSTRING "${sha1}" 0 7 archive_id)
 
  if(EXISTS "${root}/cmake/Hunter")
    set(hunter_self "${root}")
  else()
    set(
        hunter_self
        "${root}/_Base/Download/Hunter/${version}/${archive_id}/Unpacked"
    )
  endif()
 
  set("${result}" "${hunter_self}" PARENT_SCOPE)
endfunction()
 
# Set HUNTER_GATE_ROOT cmake variable to suitable value.
function(hunter_gate_detect_root)
  # Check CMake variable
  string(COMPARE NOTEQUAL "${HUNTER_ROOT}" "" not_empty)
  if(not_empty)
    set(HUNTER_GATE_ROOT "${HUNTER_ROOT}" PARENT_SCOPE)
    hunter_gate_status_debug("HUNTER_ROOT detected by cmake variable")
    return()
  endif()
 
  # Check environment variable
  string(COMPARE NOTEQUAL "$ENV{HUNTER_ROOT}" "" not_empty)
  if(not_empty)
    set(HUNTER_GATE_ROOT "$ENV{HUNTER_ROOT}" PARENT_SCOPE)
    hunter_gate_status_debug("HUNTER_ROOT detected by environment variable")
    return()
  endif()
 
  # Check HOME environment variable
  string(COMPARE NOTEQUAL "$ENV{HOME}" "" result)
  if(result)
    set(HUNTER_GATE_ROOT "$ENV{HOME}/.hunter" PARENT_SCOPE)
    hunter_gate_status_debug("HUNTER_ROOT set using HOME environment variable")
    return()
  endif()
 
  # Check SYSTEMDRIVE and USERPROFILE environment variable (windows only)
  if(WIN32)
    string(COMPARE NOTEQUAL "$ENV{SYSTEMDRIVE}" "" result)
    if(result)
      set(HUNTER_GATE_ROOT "$ENV{SYSTEMDRIVE}/.hunter" PARENT_SCOPE)
      hunter_gate_status_debug(
          "HUNTER_ROOT set using SYSTEMDRIVE environment variable"
      )
      return()
    endif()
 
    string(COMPARE NOTEQUAL "$ENV{USERPROFILE}" "" result)
    if(result)
      set(HUNTER_GATE_ROOT "$ENV{USERPROFILE}/.hunter" PARENT_SCOPE)
      hunter_gate_status_debug(
          "HUNTER_ROOT set using USERPROFILE environment variable"
      )
      return()
    endif()
  endif()
 
  hunter_gate_fatal_error(
      "Can't detect HUNTER_ROOT"
      WIKI "error.detect.hunter.root"
  )
endfunction()
 
macro(hunter_gate_lock dir)
  if(NOT HUNTER_SKIP_LOCK)
    if("${CMAKE_VERSION}" VERSION_LESS "3.2")
      hunter_gate_fatal_error(
          "Can't lock, upgrade to CMake 3.2 or use HUNTER_SKIP_LOCK"
          WIKI "error.can.not.lock"
      )
    endif()
    hunter_gate_status_debug("Locking directory: ${dir}")
    file(LOCK "${dir}" DIRECTORY GUARD FUNCTION)
    hunter_gate_status_debug("Lock done")
  endif()
endmacro()
 
function(hunter_gate_download dir)
  string(
      COMPARE
      NOTEQUAL
      "$ENV{HUNTER_DISABLE_AUTOINSTALL}"
      ""
      disable_autoinstall
  )
  if(disable_autoinstall AND NOT HUNTER_RUN_INSTALL)
    hunter_gate_fatal_error(
        "Hunter not found in '${dir}'"
        "Set HUNTER_RUN_INSTALL=ON to auto-install it from '${HUNTER_GATE_URL}'"
        "Settings:"
        "  HUNTER_ROOT: ${HUNTER_GATE_ROOT}"
        "  HUNTER_SHA1: ${HUNTER_GATE_SHA1}"
        WIKI "error.run.install"
    )
  endif()
  string(COMPARE EQUAL "${dir}" "" is_bad)
  if(is_bad)
    hunter_gate_internal_error("Empty 'dir' argument")
  endif()
 
  string(COMPARE EQUAL "${HUNTER_GATE_SHA1}" "" is_bad)
  if(is_bad)
    hunter_gate_internal_error("HUNTER_GATE_SHA1 empty")
  endif()
 
  string(COMPARE EQUAL "${HUNTER_GATE_URL}" "" is_bad)
  if(is_bad)
    hunter_gate_internal_error("HUNTER_GATE_URL empty")
  endif()
 
  set(done_location "${dir}/DONE")
  set(sha1_location "${dir}/SHA1")
 
  set(build_dir "${dir}/Build")
  set(cmakelists "${dir}/CMakeLists.txt")
 
  hunter_gate_lock("${dir}")
  if(EXISTS "${done_location}")
    # while waiting for lock other instance can do all the job
    hunter_gate_status_debug("File '${done_location}' found, skip install")
    return()
  endif()
 
  file(REMOVE_RECURSE "${build_dir}")
  file(REMOVE_RECURSE "${cmakelists}")
 
  file(MAKE_DIRECTORY "${build_dir}") # check directory permissions
 
  # Disabling languages speeds up a little bit, reduces noise in the output
  # and avoids path too long windows error
  file(
      WRITE
      "${cmakelists}"
      "cmake_minimum_required(VERSION 3.0)\n"
      "project(HunterDownload LANGUAGES NONE)\n"
      "include(ExternalProject)\n"
      "ExternalProject_Add(\n"
      "    Hunter\n"
      "    URL\n"
      "    \"${HUNTER_GATE_URL}\"\n"
      "    URL_HASH\n"
      "    SHA1=${HUNTER_GATE_SHA1}\n"
      "    DOWNLOAD_DIR\n"
      "    \"${dir}\"\n"
      "    SOURCE_DIR\n"
      "    \"${dir}/Unpacked\"\n"
      "    CONFIGURE_COMMAND\n"
      "    \"\"\n"
      "    BUILD_COMMAND\n"
      "    \"\"\n"
      "    INSTALL_COMMAND\n"
      "    \"\"\n"
      ")\n"
  )
 
  if(HUNTER_STATUS_DEBUG)
    set(logging_params "")
  else()
    set(logging_params OUTPUT_QUIET)
  endif()
 
  hunter_gate_status_debug("Run generate")
 
  # Need to add toolchain file too.
  # Otherwise on Visual Studio + MDD this will fail with error:
  # "Could not find an appropriate version of the Windows 10 SDK installed on this machine"
  if(EXISTS "${CMAKE_TOOLCHAIN_FILE}")
    get_filename_component(absolute_CMAKE_TOOLCHAIN_FILE "${CMAKE_TOOLCHAIN_FILE}" ABSOLUTE)
    set(toolchain_arg "-DCMAKE_TOOLCHAIN_FILE=${absolute_CMAKE_TOOLCHAIN_FILE}")
  else()
    # 'toolchain_arg' can't be empty
    set(toolchain_arg "-DCMAKE_TOOLCHAIN_FILE=")
  endif()
 
  string(COMPARE EQUAL "${CMAKE_MAKE_PROGRAM}" "" no_make)
  if(no_make)
    set(make_arg "")
  else()
    # Test case: remove Ninja from PATH but set it via CMAKE_MAKE_PROGRAM
    set(make_arg "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}")
  endif()
 
  execute_process(
      COMMAND
      "${CMAKE_COMMAND}"
      "-H${dir}"
      "-B${build_dir}"
      "-G${CMAKE_GENERATOR}"
      "${toolchain_arg}"
      ${make_arg}
      WORKING_DIRECTORY "${dir}"
      RESULT_VARIABLE download_result
      ${logging_params}
  )
 
  if(NOT download_result EQUAL 0)
    hunter_gate_internal_error("Configure project failed")
  endif()
 
  hunter_gate_status_print(
      "Initializing Hunter workspace (${HUNTER_GATE_SHA1})"
      "  ${HUNTER_GATE_URL}"
      "  -> ${dir}"
  )
  execute_process(
      COMMAND "${CMAKE_COMMAND}" --build "${build_dir}"
      WORKING_DIRECTORY "${dir}"
      RESULT_VARIABLE download_result
      ${logging_params}
  )
 
  if(NOT download_result EQUAL 0)
    hunter_gate_internal_error("Build project failed")
  endif()
 
  file(REMOVE_RECURSE "${build_dir}")
  file(REMOVE_RECURSE "${cmakelists}")
 
  file(WRITE "${sha1_location}" "${HUNTER_GATE_SHA1}")
  file(WRITE "${done_location}" "DONE")
 
  hunter_gate_status_debug("Finished")
endfunction()
 
# Must be a macro so master file 'cmake/Hunter' can
# apply all variables easily just by 'include' command
# (otherwise PARENT_SCOPE magic needed)
macro(HunterGate)
  if(HUNTER_GATE_DONE)
    # variable HUNTER_GATE_DONE set explicitly for external project
    # (see `hunter_download`)
    set_property(GLOBAL PROPERTY HUNTER_GATE_DONE YES)
  endif()
 
  # First HunterGate command will init Hunter, others will be ignored
  get_property(_hunter_gate_done GLOBAL PROPERTY HUNTER_GATE_DONE SET)
 
  if(NOT HUNTER_ENABLED)
    # Empty function to avoid error "unknown function"
    function(hunter_add_package)
    endfunction()
 
    set(
        _hunter_gate_disabled_mode_dir
        "${CMAKE_CURRENT_LIST_DIR}/cmake/Hunter/disabled-mode"
    )
    if(EXISTS "${_hunter_gate_disabled_mode_dir}")
      hunter_gate_status_debug(
          "Adding \"disabled-mode\" modules: ${_hunter_gate_disabled_mode_dir}"
      )
      list(APPEND CMAKE_PREFIX_PATH "${_hunter_gate_disabled_mode_dir}")
    endif()
  elseif(_hunter_gate_done)
    hunter_gate_status_debug("Secondary HunterGate (use old settings)")
    hunter_gate_self(
        "${HUNTER_CACHED_ROOT}"
        "${HUNTER_VERSION}"
        "${HUNTER_SHA1}"
        _hunter_self
    )
    include("${_hunter_self}/cmake/Hunter")
  else()
    set(HUNTER_GATE_LOCATION "${CMAKE_CURRENT_LIST_DIR}")
 
    string(COMPARE NOTEQUAL "${PROJECT_NAME}" "" _have_project_name)
    if(_have_project_name)
      hunter_gate_fatal_error(
          "Please set HunterGate *before* 'project' command. "
          "Detected project: ${PROJECT_NAME}"
          WIKI "error.huntergate.before.project"
      )
    endif()
 
    cmake_parse_arguments(
        HUNTER_GATE "LOCAL" "URL;SHA1;GLOBAL;FILEPATH" "" ${ARGV}
    )
 
    string(COMPARE EQUAL "${HUNTER_GATE_SHA1}" "" _empty_sha1)
    string(COMPARE EQUAL "${HUNTER_GATE_URL}" "" _empty_url)
    string(
        COMPARE
        NOTEQUAL
        "${HUNTER_GATE_UNPARSED_ARGUMENTS}"
        ""
        _have_unparsed
    )
    string(COMPARE NOTEQUAL "${HUNTER_GATE_GLOBAL}" "" _have_global)
    string(COMPARE NOTEQUAL "${HUNTER_GATE_FILEPATH}" "" _have_filepath)
 
    if(_have_unparsed)
      hunter_gate_user_error(
          "HunterGate unparsed arguments: ${HUNTER_GATE_UNPARSED_ARGUMENTS}"
      )
    endif()
    if(_empty_sha1)
      hunter_gate_user_error("SHA1 suboption of HunterGate is mandatory")
    endif()
    if(_empty_url)
      hunter_gate_user_error("URL suboption of HunterGate is mandatory")
    endif()
    if(_have_global)
      if(HUNTER_GATE_LOCAL)
        hunter_gate_user_error("Unexpected LOCAL (already has GLOBAL)")
      endif()
      if(_have_filepath)
        hunter_gate_user_error("Unexpected FILEPATH (already has GLOBAL)")
      endif()
    endif()
    if(HUNTER_GATE_LOCAL)
      if(_have_global)
        hunter_gate_user_error("Unexpected GLOBAL (already has LOCAL)")
      endif()
      if(_have_filepath)
        hunter_gate_user_error("Unexpected FILEPATH (already has LOCAL)")
      endif()
    endif()
    if(_have_filepath)
      if(_have_global)
        hunter_gate_user_error("Unexpected GLOBAL (already has FILEPATH)")
      endif()
      if(HUNTER_GATE_LOCAL)
        hunter_gate_user_error("Unexpected LOCAL (already has FILEPATH)")
      endif()
    endif()
 
    hunter_gate_detect_root() # set HUNTER_GATE_ROOT
 
    # Beautify path, fix probable problems with windows path slashes
    get_filename_component(
        HUNTER_GATE_ROOT "${HUNTER_GATE_ROOT}" ABSOLUTE
    )
    hunter_gate_status_debug("HUNTER_ROOT: ${HUNTER_GATE_ROOT}")
    if(NOT HUNTER_ALLOW_SPACES_IN_PATH)
      string(FIND "${HUNTER_GATE_ROOT}" " " _contain_spaces)
      if(NOT _contain_spaces EQUAL -1)
        hunter_gate_fatal_error(
            "HUNTER_ROOT (${HUNTER_GATE_ROOT}) contains spaces."
            "Set HUNTER_ALLOW_SPACES_IN_PATH=ON to skip this error"
            "(Use at your own risk!)"
            WIKI "error.spaces.in.hunter.root"
        )
      endif()
    endif()
 
    string(
        REGEX
        MATCH
        "[0-9]+\\.[0-9]+\\.[0-9]+[-_a-z0-9]*"
        HUNTER_GATE_VERSION
        "${HUNTER_GATE_URL}"
    )
    string(COMPARE EQUAL "${HUNTER_GATE_VERSION}" "" _is_empty)
    if(_is_empty)
      set(HUNTER_GATE_VERSION "unknown")
    endif()
 
    hunter_gate_self(
        "${HUNTER_GATE_ROOT}"
        "${HUNTER_GATE_VERSION}"
        "${HUNTER_GATE_SHA1}"
        _hunter_self
    )
 
    set(_master_location "${_hunter_self}/cmake/Hunter")
    if(EXISTS "${HUNTER_GATE_ROOT}/cmake/Hunter")
      # Hunter downloaded manually (e.g. by 'git clone')
      set(_unused "xxxxxxxxxx")
      set(HUNTER_GATE_SHA1 "${_unused}")
      set(HUNTER_GATE_VERSION "${_unused}")
    else()
      get_filename_component(_archive_id_location "${_hunter_self}/.." ABSOLUTE)
      set(_done_location "${_archive_id_location}/DONE")
      set(_sha1_location "${_archive_id_location}/SHA1")
 
      # Check Hunter already downloaded by HunterGate
      if(NOT EXISTS "${_done_location}")
        hunter_gate_download("${_archive_id_location}")
      endif()
 
      if(NOT EXISTS "${_done_location}")
        hunter_gate_internal_error("hunter_gate_download failed")
      endif()
 
      if(NOT EXISTS "${_sha1_location}")
        hunter_gate_internal_error("${_sha1_location} not found")
      endif()
      file(READ "${_sha1_location}" _sha1_value)
      string(COMPARE EQUAL "${_sha1_value}" "${HUNTER_GATE_SHA1}" _is_equal)
      if(NOT _is_equal)
        hunter_gate_internal_error(
            "Short SHA1 collision:"
            "  ${_sha1_value} (from ${_sha1_location})"
            "  ${HUNTER_GATE_SHA1} (HunterGate)"
        )
      endif()
      if(NOT EXISTS "${_master_location}")
        hunter_gate_user_error(
            "Master file not found:"
            "  ${_master_location}"
            "try to update Hunter/HunterGate"
        )
      endif()
    endif()
    include("${_master_location}")
    set_property(GLOBAL PROPERTY HUNTER_GATE_DONE YES)
  endif()
endmacro()

#include <iostream>
 
#include "matrix.hpp"
 
int main()
{
    matrix_t a, b;
    char op;
    if (a.read(std::cin) && std::cin >> op && b.read(std::cin)) {
        if (op == '+') {
            (a + b).write(std::cout);
        }
    }
 
    return 0;
}

#include <iostream>
using namespace std;
 
template <typename T> class matrix_t 
{
    private:
    T ** elements_;
    size_t rows_;
    size_t collumns_;
    public:
    matrix_t();
    matrix_t(matrix_t const & other);
    matrix_t & operator =(matrix_t const & other);
    ~matrix_t();
 
    size_t rows() const;
    size_t collumns() const;
 
    matrix_t operator +(matrix_t const & other) const;
    matrix_t operator -(matrix_t const & other) const;
    matrix_t operator *(matrix_t const & other) const;
 
    matrix_t & operator -=(matrix_t const & other);
    matrix_t & operator +=(matrix_t const & other);
    matrix_t & operator *=(matrix_t const & other);
 
    istream & read(istream & stream);
    ostream & write(ostream  & stream) const;
};
 
template <typename T> matrix_t<T>::matrix_t() : elements_{ nullptr }, rows_{ 0 }, collumns_{ 0 }
{
}
 
template <typename T> matrix_t<T>::matrix_t(matrix_t const & other)
{
    rows_ = other.rows();
    collumns_ = other.collumns();
    elements_ = new T *[other.rows()];
    for (size_t i = 0; i < other.rows(); ++i) {
        elements_[i] = new T[other.collumns()];
        for (size_t j = 0; j < other.collumns(); ++j) {
            elements_[i][j] = other.elements_[i][j];
        }
    }
}
 
template <typename T> matrix_t<T> & matrix_t<T>::operator =(matrix_t const & other)
{
    if (this != &other) {
        for (size_t i = 0; i < rows_; ++i) {
            delete[] elements_[i];
        }
        delete[] elements_;
 
        elements_ = new T *[other.rows()];
        for (size_t i = 0; i < other.rows(); ++i) {
            elements_[i] = new T[other.collumns()];
            for (size_t j = 0; j < other.collumns(); ++j) {
                elements_[i][j] = other.elements_[i][j];
            }
        }
        rows_ = other.rows();
        collumns_ = other.collumns();
    }
    return *this;
}
 
template <typename T> matrix_t<T>::~matrix_t()
{
    for (size_t i = 0; i < rows_; ++i) {
        delete[] elements_[i];
    }
    delete[] elements_;
}
 
template <typename T> size_t matrix_t<T>::rows() const
{
    return rows_;
}
 
template <typename T> size_t matrix_t<T>::collumns() const
{
    return collumns_;
}
 
template <typename T> matrix_t<T> matrix_t<T>::operator +(matrix_t const & other) const
{
    if (rows_ != other.rows_ || collumns_ != other.collumns_) {
        throw exception("Error: columns and/or rows mismatch");
    }
    matrix_t result;
    result.rows_ = rows_;
    result.collumns_ = collumns_;
    result.elements_ = new T *[rows_];
    for (size_t i = 0; i < rows_; ++i) {
        result.elements_[i] = new T[collumns_];
        for (size_t j = 0; j < collumns_; ++j) {
            result.elements_[i][j] = elements_[i][j] + other.elements_[i][j];
        }
    }
    return result;
}
 
template <typename T> matrix_t<T> matrix_t<T>::operator -(matrix_t const & other) const
{
    if (rows_ != other.rows_ || collumns_ != other.collumns_) {
        throw exception("Error: columns and/or rows mismatch");
    }
    matrix_t result;
    result.rows_ = rows_;
    result.collumns_ = collumns_;
    result.elements_ = new T *[rows_];
    for (std::size_t i = 0; i < rows_; ++i) {
        result.elements_[i] = new T[collumns_];
        for (std::size_t j = 0; j < collumns_; ++j) {
            result.elements_[i][j] = elements_[i][j] - other.elements_[i][j];
        }
    }
    return result;
}
 
template <typename T> matrix_t<T> matrix_t<T>::operator *(matrix_t const & other) const
{
    if (collumns_ != other.rows_) {
        throw exception("Error: columns != rows");
    }
    matrix_t result;
    result.rows_ = rows_;
    result.collumns_ = other.collumns_;
    result.elements_ = new T *[rows_];
    for (size_t i = 0; i < rows_; i++) {
        result.elements_[i] = new T [other.collumns()];
        for (size_t j = 0; j < other.collumns(); j++) {
            T temp = 0;
            for (size_t k = 0; k < collumns_; k++) {
                temp += elements_[i][k] * other.elements_[k][j];
            }
            result.elements_[i][j] = temp;
        }
    }
    return result;
}
 
template <typename T> matrix_t<T> & matrix_t<T>::operator -=(matrix_t const & other)
{
    if (rows_ != other.rows_ || collumns_ != other.collumns_) {
        throw exception("Error: columns and/or rows mismatch");
    }
    for (size_t i = 0; i < rows_; ++i) {
        for (size_t j = 0; j < collumns_; ++j) {
            elements_[i][j] = elements_[i][j] - other.elements_[i][j];
        }
    }
    return *this;
}
 
template <typename T> matrix_t<T> & matrix_t<T>::operator +=(matrix_t const & other)
{
    if (rows_ != other.rows_ || collumns_ != other.collumns_) {
        throw exception("Error: columns and/or rows mismatch");
    }
    for (size_t i = 0; i < rows_; ++i) {
        for (size_t j = 0; j < collumns_; ++j) {
            elements_[i][j] = elements_[i][j] + other.elements_[i][j];
        }
    }
    return *this;
}
 
template <typename T> matrix_t<T> & matrix_t<T>::operator *=(matrix_t const & other)
{
    if (collumns_ != other.rows_) {
        throw exception("Error: columns != rows");
    }
    matrix_t result;
    result.rows_ = rows_;
    result.collumns_ = other.collumns_;
    result.elements_ = new T *[rows_];
    for (size_t i = 0; i < rows_; i++) {
        result.elements_[i] = new T[other.collumns()];
        for (size_t j = 0; j < other.collumns(); j++) {
            T temp = 0;
            for (size_t k = 0; k < collumns_; k++) {
                temp += elements_[i][k] * other.elements_[k][j];
            }
            result.elements_[i][j] = temp;
        }
    }
    for (size_t i = 0; i < rows_; i++) {
        for (size_t j = 0; j < other.collumns(); j++) {
            elements_[i][j] = result.elements_[i][j];
        }
    }
    return *this;
}
 
template <typename T> istream & matrix_t<T>::read(istream & stream)
{
    size_t rows;
    size_t collumns;
    char symbol;
    bool success = true;
    if (stream >> rows && stream >> symbol && symbol == ',' && stream >> collumns) {
        T ** elements = new T *[rows];
        for (size_t i = 0; success && i < rows; ++i) {
            elements[i] = new T[collumns];
            for (size_t j = 0; j < collumns; ++j) {
                if (!(stream >> elements[i][j])) {
                    success = false;
                    break;
                }
            }
        }
 
        if (success) {
            for (size_t i = 0; i < rows_; ++i) {
                delete[] elements_[i];
            }
            delete[] elements_;
 
            rows_ = rows;
            collumns_ = collumns;
            elements_ = elements;
        }
        else {
            for (size_t i = 0; i < rows; ++i) {
                delete[] elements[i];
            }
            delete[] elements;
        }
    }
    else {
        throw exception("Error: incorrect matrix");
    }
    return stream;
}
 
template <typename T> ostream & matrix_t<T>::write(ostream & stream) const
{
    stream << rows_ << ", " << collumns_;
    for (size_t i = 0; i < rows_; ++i) {
        stream << '\n';
        for (size_t j = 0; j < collumns_; ++j) {
            stream << elements_[i][j];
            if (j != rows_ - 1) {
                stream << ' ';
            }
        }
    }
 
    return stream;
}

#include "matrix.hpp"
#include <cassert>
matrix_t::matrix_t() : elements_{ nullptr }, rows_{ 0 }, collumns_{ 0 }
{
}
 
matrix_t::matrix_t(matrix_t const & other)
{
    rows_ = other.rows();
    collumns_ = other.collumns();
    elements_ = new float *[other.rows()];
    for (std::size_t i = 0; i < other.rows(); ++i) {
        elements_[i] = new float[other.collumns()];
        for (std::size_t j = 0; j < other.collumns(); ++j) {
            elements_[i][j] = other.elements_[i][j];
        }
    }
}
 
matrix_t & matrix_t::operator =(matrix_t const & other)
{
    if (this != &other) {
        for (std::size_t i = 0; i < rows_; ++i) {
            delete[] elements_[i];
        }
        delete[] elements_;
 
        elements_ = new float *[other.rows()];
        for (std::size_t i = 0; i < other.rows(); ++i) {
            elements_[i] = new float[other.collumns()];
            for (std::size_t j = 0; j < other.collumns(); ++j) {
                elements_[i][j] = other.elements_[i][j];
            }
        }
        rows_ = other.rows();
        collumns_ = other.collumns();
    }
    return *this;
}
 
matrix_t::~matrix_t()
{
    for (std::size_t i = 0; i < rows_; ++i) {
        delete[] elements_[i];
    }
    delete[] elements_;
}
 
std::size_t matrix_t::rows() const
{
    return rows_;
}
 
std::size_t matrix_t::collumns() const
{
    return collumns_;
}
 
matrix_t matrix_t::operator +(matrix_t const & other) const
{
    assert(rows_ == other.rows_ && collumns_ == other.collumns_);
    matrix_t result;
    result.rows_ = rows_;
    result.collumns_ = collumns_;
    result.elements_ = new float *[rows_];
    for (std::size_t i = 0; i < rows_; ++i) {
        result.elements_[i] = new float[collumns_];
        for (std::size_t j = 0; j < collumns_; ++j) {
            result.elements_[i][j] = elements_[i][j] + other.elements_[i][j];
        }
    }
    return result;
}
 
matrix_t matrix_t::operator -(matrix_t const & other) const
{
    assert(rows_ == other.rows_ && collumns_ == other.collumns_);
    matrix_t result;
    result.rows_ = rows_;
    result.collumns_ = collumns_;
    result.elements_ = new float *[rows_];
    for (std::size_t i = 0; i < rows_; ++i) {
        result.elements_[i] = new float[collumns_];
        for (std::size_t j = 0; j < collumns_; ++j) {
            result.elements_[i][j] = elements_[i][j] - other.elements_[i][j];
        }
    }
    return result;
}
 
matrix_t matrix_t::operator *(matrix_t const & other) const
{
    assert(collumns_ == other.rows_);
    matrix_t result;
    result.rows_ = rows_;
    result.collumns_ = other.collumns_;
    result.elements_ = new float *[rows_];
    for (std::size_t i = 0; i < rows_; i++) {
        result.elements_[i] = new float[other.collumns()];
        for (std::size_t j = 0; j < other.collumns(); j++) {
            float temp = 0;
            for (std::size_t k = 0; k < collumns_; k++) {
                temp += elements_[i][k] * other.elements_[k][j];
            }
            result.elements_[i][j] = temp;
        }
    }
    return result;
}
 
matrix_t & matrix_t::operator -=(matrix_t const & other)
{
    assert(rows_ == other.rows_ && collumns_ == other.collumns_);
    for (std::size_t i = 0; i < rows_; ++i) {
        for (std::size_t j = 0; j < collumns_; ++j) {
            elements_[i][j] = elements_[i][j] - other.elements_[i][j];
        }
    }
    return *this;
}
 
matrix_t & matrix_t::operator +=(matrix_t const & other)
{
    assert(rows_ == other.rows_ && collumns_ == other.collumns_);
    for (std::size_t i = 0; i < rows_; ++i) {
        for (std::size_t j = 0; j < collumns_; ++j) {
            elements_[i][j] = elements_[i][j] + other.elements_[i][j];
        }
    }
    return *this;
}
 
matrix_t & matrix_t::operator *=(matrix_t const & other)
{
    assert(collumns_ == other.rows_);
    matrix_t result;
    result.rows_ = rows_;
    result.collumns_ = other.collumns_;
    result.elements_ = new float *[rows_];
    for (std::size_t i = 0; i < rows_; i++) {
        result.elements_[i] = new float[other.collumns()];
        for (std::size_t j = 0; j < other.collumns(); j++) {
            float temp = 0;
            for (std::size_t k = 0; k < collumns_; k++) {
                temp += elements_[i][k] * other.elements_[k][j];
            }
            result.elements_[i][j] = temp;
        }
    }
    for (std::size_t i = 0; i < rows_; i++) {
        for (std::size_t j = 0; j < other.collumns(); j++) {
            elements_[i][j] = result.elements_[i][j];
        }
    }
    return *this;
}
 
std::istream & matrix_t::read(std::istream & stream)
{
    std::size_t rows;
    std::size_t collumns;
    char symbol;
 
    bool success = true;
    if (stream >> rows && stream >> symbol && symbol == ',' && stream >> collumns) {
        float ** elements = new float *[rows];
        for (std::size_t i = 0; success && i < rows; ++i) {
            elements[i] = new float[collumns];
            for (std::size_t j = 0; j < collumns; ++j) {
                if (!(stream >> elements[i][j])) {
                    success = false;
                    break;
                }
            }
        }
 
        if (success) {
            for (std::size_t i = 0; i < rows_; ++i) {
                delete[] elements_[i];
            }
            delete[] elements_;
 
            rows_ = rows;
            collumns_ = collumns;
            elements_ = elements;
        }
        else {
            for (std::size_t i = 0; i < rows; ++i) {
                delete[] elements[i];
            }
            delete[] elements;
        }
    }
    else {
        success = false;
    }
 
    if (!success) {
        stream.setstate(std::ios_base::failbit);
    }
 
    return stream;
}
 
std::ostream & matrix_t::write(std::ostream & stream) const
{
    stream << rows_ << ", " << collumns_;
    for (std::size_t i = 0; i < rows_; ++i) {
        stream << '\n';
        for (std::size_t j = 0; j < collumns_; ++j) {
            stream << elements_[i][j];
            if (j != rows_ - 1) {
                stream << ' ';
            }
        }
    }
 
    return stream;
}

#define CATCH_CONFIG_MAIN
#include "catch.hpp"

#include <catch.hpp>
#include <sstream>
 
#include "matrix.hpp"
 
using namespace std;
 
TEST_CASE("creating matrix")
{
    matrix_t<int> matrix;
    REQUIRE( matrix.rows() == 0 );
    REQUIRE( matrix.collumns() == 0 );
}
 
TEST_CASE("reading matrix")
{
    string input{
        "3, 3\n"
        "1 1 1\n"
        "2 2 2\n"
        "3 3 3" };
    matrix_t<int> matrix;
    istringstream istream{ input };
    
    REQUIRE( matrix.read( istream ) );
    REQUIRE( matrix.rows() == 3 );
    REQUIRE( matrix.collumns() == 3 );
    
    ostringstream ostream;
    matrix.write( ostream );
    
    REQUIRE( input == ostream.str() );
}
TEST_CASE("operator =")
{
    string input1{
        "3, 3\n"
        "1 1 1\n"
        "1 1 1\n"
    "1 1 1" };
    string input2{
        "3, 3\n"
        "2 2 2\n"
        "2 2 2\n"
    "2 2 2" };
    matrix_t<int> matrix_1, matrix_2;
 
    istringstream istream1{ input1 };
    REQUIRE( matrix_1.read( istream1 ) );
 
    istringstream istream2{ input2 };
    REQUIRE( matrix_2.read( istream2 ) );
 
    matrix_1 = matrix_2;
    ostringstream ostream;
    matrix_1.write( ostream );
    
    REQUIRE( input2 == ostream.str() );
    
}
TEST_CASE("operator +")
{
    string input_1{
        "3, 3\n"
        "1 1 1\n"
        "1 1 1\n"
        "1 1 1" };
    string input_2{
        "3, 3\n"
        "2 2 2\n"
        "2 2 2\n"
        "2 2 2" };
    string input{
        "3, 3\n"
        "3 3 3\n"
        "3 3 3\n"
        "3 3 3" };
    
   
    matrix_t<int> matrix_1,matrix_2;
    istringstream istream1{ input_1 };
    istringstream istream2{ input_2 };
    REQUIRE( matrix_1.read( istream1 ) );
    REQUIRE( matrix_2.read( istream2 ) );
  
    ostringstream ostream;
    (matrix_1 + matrix_2).write( ostream );
    
    REQUIRE( input == ostream.str() );
}
 
TEST_CASE("operator -")
{
    string input_1{
        "3, 3\n"
        "3 3 3\n"
        "3 3 3\n"
        "3 3 3" };
    string input_2{
        "3, 3\n"
        "2 2 2\n"
        "2 2 2\n"
        "2 2 2" };
    string input{
        "3, 3\n"
        "1 1 1\n"
        "1 1 1\n"
        "1 1 1" };
    
   
    matrix_t<int> matrix_1,matrix_2;
    istringstream istream1{ input_1 };
    istringstream istream2{ input_2 };
    REQUIRE( matrix_1.read( istream1 ) );
    REQUIRE( matrix_2.read( istream2 ) );
  
    ostringstream ostream;
    (matrix_1 - matrix_2).write( ostream );
    
    REQUIRE( input == ostream.str() );
}
TEST_CASE("operator *")
{
    string input_1{
        "3, 3\n"
        "1 1 1\n"
        "1 1 1\n"
        "1 1 1" };
    string input_2{
        "3, 3\n"
        "2 2 2\n"
        "2 2 2\n"
        "2 2 2" };
    string input{
        "3, 3\n"
        "6 6 6\n"
        "6 6 6\n"
        "6 6 6" };
    
   
    matrix_t<int> matrix_1,matrix_2;
    istringstream istream1{ input_1 };
    istringstream istream2{ input_2 };
    REQUIRE( matrix_1.read( istream1 ) );
    REQUIRE( matrix_2.read( istream2 ) );
  
    ostringstream ostream;
    (matrix_1 * matrix_2).write( ostream );
    
    REQUIRE( input == ostream.str() );
}
 
TEST_CASE("operator +=")
{
    string input_1{
        "3, 3\n"
        "1 1 1\n"
        "1 1 1\n"
        "1 1 1" };
    string input_2{
        "3, 3\n"
        "2 2 2\n"
        "2 2 2\n"
        "2 2 2" };
    string input{
        "3, 3\n"
        "3 3 3\n"
        "3 3 3\n"
        "3 3 3" };
    
   
    matrix_t<int> matrix_1,matrix_2;
    istringstream istream1{ input_1 };
    istringstream istream2{ input_2 };
    REQUIRE( matrix_1.read( istream1 ) );
    REQUIRE( matrix_2.read( istream2 ) );
  
    matrix_1+=matrix_2;
    ostringstream ostream;
    matrix_1.write( ostream );
    
    REQUIRE( input == ostream.str() );
}
 
TEST_CASE("operator -=")
{
    string input_1{
        "3, 3\n"
        "3 3 3\n"
        "3 3 3\n"
        "3 3 3" };
    string input_2{
        "3, 3\n"
        "2 2 2\n"
        "2 2 2\n"
        "2 2 2" };
    string input{
        "3, 3\n"
        "1 1 1\n"
        "1 1 1\n"
        "1 1 1" };
    
   
    matrix_t<int> matrix_1,matrix_2;
    istringstream istream1{ input_1 };
    istringstream istream2{ input_2 };
    REQUIRE( matrix_1.read( istream1 ) );
    REQUIRE( matrix_2.read( istream2 ) );
    
    matrix_1-=matrix_2;
    ostringstream ostream;
    matrix_1.write( ostream );
    
    REQUIRE( input == ostream.str() );
}
 
TEST_CASE("operator *=")
{
    string input_1{
        "3, 3\n"
        "1 1 1\n"
        "1 1 1\n"
        "1 1 1" };
    string input_2{
        "3, 3\n"
        "2 2 2\n"
        "2 2 2\n"
        "2 2 2" };
    string input{
        "3, 3\n"
        "6 6 6\n"
        "6 6 6\n"
        "6 6 6" };
    
   
    matrix_t<int> matrix_1,matrix_2;
    istringstream istream1{ input_1 };
    istringstream istream2{ input_2 };
    REQUIRE( matrix_1.read( istream1 ) );
    REQUIRE( matrix_2.read( istream2 ) );
  
    matrix_1*=matrix_2;
    ostringstream ostream;
    matrix_1.write( ostream );
    
    REQUIRE( input == ostream.str() );
}
 
TEST_CASE ("typetests")
{
    string input{
        "3, 3\n"
        "1 1 1\n"
        "2 2 2\n"
        "3 3 3" };
   
        matrix_t<int> matrix;
        matrix_t<float> matrix1;
        matrix_t<double> matrix2;
        istringstream istream{ input };
        istringstream istream1{ input };
        istringstream istream2{ input };
    
    REQUIRE( matrix.read( istream ) );
    REQUIRE( matrix1.read( istream1 ) );
    REQUIRE( matrix2.read( istream2 ) );
    
    ostringstream ostream;
    matrix.write( ostream );
    ostream<<'\n';
    matrix1.write(ostream);
 
    ostream<<'\n';
    matrix2.write(ostream);
    
    REQUIRE( input+'\n'+input+'\n'+input == ostream.str() );
}

_builds
.DS_Store
*.swp

language: cpp
sudo: false
 
matrix:
  include:
    - os: linux
      compiler: gcc
      addons: &gcc7
        apt:
          sources: ['ubuntu-toolchain-r-test']
          packages: ['g++-7']
      env: CXX_EVAL="g++-7" CC_EVAL="gcc-7" BUILD_TYPE='Release'
 
    - os: linux
      compiler: gcc
      addons: *gcc7
      env: CXX_EVAL="g++-7" CC_EVAL="gcc-7" BUILD_TYPE='Debug'
 
    - os: linux
      compiler: clang
      env: BUILD_TYPE='Release' CXX_EVAL="clang++-5.0" CC_EVAL="clang-5.0"
      addons:
        apt:
          sources:
            - sourceline: 'deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-5.0 main' 
              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
            - ubuntu-toolchain-r-test
          packages: ['clang-5.0']
 
    - os: linux
      compiler: clang
      env: BUILD_TYPE='Debug' CXX_EVAL="clang++-5.0" CC_EVAL="clang-5.0"
      addons:
        apt:
          sources:
            - sourceline: 'deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-5.0 main' 
              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
            - ubuntu-toolchain-r-test
          packages: ['clang-5.0']
          
    - os: osx
      osx_image: xcode8.3
      compiler: clang
      env: CXX_EVAL="clang++" CC_EVAL="clang" BUILD_TYPE='Debug'
 
    - os: osx
      osx_image: xcode8.3
      compiler: clang
      env: CXX_EVAL="clang++" CC_EVAL="clang" BUILD_TYPE='Release'
 
 
before_install:
  - export CXX=$CXX_EVAL
  - export CC=$CC_EVAL
  - export CXXFLAGS="-Werror"
 
install:
  - DEPS_DIR="${TRAVIS_BUILD_DIR}/deps"
  - mkdir -p ${DEPS_DIR} && cd ${DEPS_DIR}
  - |
    if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
      CMAKE_URL="https://cmake.org/files/v3.9/cmake-3.9.4-Linux-x86_64.tar.gz"
      mkdir cmake && travis_retry wget --no-check-certificate --quiet -O - ${CMAKE_URL} | tar --strip-components=1 -xz -C cmake
      export PATH=${DEPS_DIR}/cmake/bin:${PATH}
    elif [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
      which cmake || brew install cmake
    fi
before_script:
  - which $CXX
  - $CXX --version
  - cd ${TRAVIS_BUILD_DIR}
  - cmake -H. -B_builds -DBUILD_TESTS=ON
script:
- cmake --build _builds
- cmake --build _builds --target test -- ARGS=--verbose

cmake_minimum_required(VERSION 3.8)
 
include("cmake/HunterGate.cmake")
HunterGate(
    URL "https://github.com/ruslo/hunter/archive/v0.19.123.tar.gz"
    SHA1 "57d07480686f82ddc916a5980b4f2a18e5954c2b"
)
 
project(matrix)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
option(BUILD_TESTS "Build tests" OFF)
option(BUILD_EXAMPLES "Build Examples" OFF)
 
add_library(${PROJECT_NAME} "${PROJECT_SOURCE_DIR}/sources/matrix.cpp")
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include/)
 
if(BUILD_TESTS)
  hunter_add_package(Catch)
  find_package(Catch CONFIG REQUIRED)
 
  enable_testing()
 
  file(GLOB ${PROJECT_NAME}_TEST_SOURCES tests/*.cpp)
  add_executable(tests ${${PROJECT_NAME}_TEST_SOURCES})
  target_link_libraries(tests ${PROJECT_NAME} Catch::Catch )
 
  add_test(NAME test_name COMMAND tests "-s" "-r" "compact" "--use-colour" "yes") 
endif()
 
if(BUILD_EXAMPLES)
    file(GLOB EXAMPLE_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/examples/*.cpp")
    foreach(EXAMPLE_SOURCE ${EXAMPLE_SOURCES})
        get_filename_component(EXAMPLE_NAME ${EXAMPLE_SOURCE} NAME_WE)
        set(EXAMPLE_TARGET_NAME example_${EXAMPLE_NAME})
        add_executable(${EXAMPLE_TARGET_NAME} ${EXAMPLE_SOURCE})
        target_link_libraries(${EXAMPLE_TARGET_NAME} ${PROJECT_NAME})
        set_target_properties(${EXAMPLE_TARGET_NAME} PROPERTIES OUTPUT_NAME ${EXAMPLE_NAME})
        install(TARGETS ${EXAMPLE_TARGET_NAME}
                RUNTIME DESTINATION bin
                )
    endforeach(EXAMPLE_SOURCE ${EXAMPLE_SOURCES})
endif()