matrix.h

/*
** Copyright 2007-2024, RTE (https://www.rte-france.com)
** See AUTHORS.txt
** SPDX-License-Identifier: MPL-2.0
** This file is part of Antares-Simulator,
** Adequacy and Performance assessment for interconnected energy networks.
**
** Antares_Simulator is free software: you can redistribute it and/or modify
** it under the terms of the Mozilla Public Licence 2.0 as published by
** the Mozilla Foundation, either version 2 of the License, or
** (at your option) any later version.
**
** Antares_Simulator is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** Mozilla Public Licence 2.0 for more details.
**
** You should have received a copy of the Mozilla Public Licence 2.0
** along with Antares_Simulator. If not, see <https://opensource.org/license/mpl-2-0/>.
*/
#ifndef __ANTARES_LIBS_ARRAY_MATRIX_H__
#define __ANTARES_LIBS_ARRAY_MATRIX_H__
 
#include <cassert>
#include <set>
 
#include <yuni/yuni.h>
#include <yuni/io/file.h>
 
#include <antares/memory/memory.h>
#include "antares/jit/jit.h"
 
namespace Antares
{
template<class T = double, class ReadWriteT = T>
class Matrix
{
public:
    using Type = T;
    using TypePtr = T*;
    using MatrixType = Matrix<T, ReadWriteT>;
 
    using ReadWriteType = ReadWriteT;
 
    using MatrixPtr = Matrix<T>*;
    using Vector = std::set<MatrixPtr>;
 
    using ColumnType = typename Antares::Memory::Stored<T>::Type;
 
    using BufferType = Yuni::Clob;
 
    enum Options
    {
        optNone = 0,
        optFixedSize = 1,
        optQuiet = 2,
        optImmediate = 4,
        optMarkAsModified = 8,
        optNoWarnIfEmpty = 16,
        optNeverFails = 32,
    };
 
    enum
    {
        filesizeHardLimit = 1536 * 1024 * 1024, // 1.5Go
    };
 
public:
 
 
    Matrix();
    Matrix(const Matrix& rhs);
 
    Matrix(Matrix&& rhs) noexcept;
 
    template<class U, class V>
    Matrix(const Matrix<U, V>& rhs);
 
    Matrix(uint w, uint h);
    virtual ~Matrix();
 
 
 
    template<class U, class V>
    void copyFrom(const Matrix<U, V>& rhs);
 
    template<class U, class V>
    void copyFrom(const Matrix<U, V>* rhs);
 
 
    void swap(MatrixType& rhs) noexcept;
 
 
 
    virtual bool loadFromCSVFile(const AnyString& filename,
                                 uint minWidth,
                                 uint maxHeight,
                                 uint options = optNone,
                                 BufferType* buffer = NULL);
 
    bool loadFromCSVFile(const AnyString& filename,
                         uint minWidth,
                         uint maxHeight,
                         BufferType* buffer);
 
    bool loadFromCSVFile(const AnyString& filename);
 
    virtual bool openFile(Yuni::IO::File::Stream& file, const AnyString& filename) const;
 
    virtual void saveBufferToFile(std::string& buffer, Yuni::IO::File::Stream& f) const;
 
    bool saveToCSVFile(const AnyString& filename,
                       uint precision = 6,
                       bool print_dimensions = false,
                       bool saveEvenIfAllZero = false) const;
 
    template<class PredicateT>
    bool saveToCSVFile(const AnyString& filename,
                       uint precision,
                       bool print_dimensions,
                       PredicateT& predicate,
                       bool saveEvenIfAllZero = false) const;
 
 
    virtual Yuni::IO::Error loadFromFileToBuffer(BufferType& buffer,
                                                 const AnyString& filename) const
    {
        return Yuni::IO::File::LoadFromFile(buffer, filename, filesizeHardLimit);
    }
 
    template<class PredicateT>
    void saveToFileDescriptor(std::string& data,
                              uint precision,
                              bool print_dimensions,
                              PredicateT& predicate) const
    {
        saveToBuffer(data, precision, print_dimensions, predicate, false);
    }
 
 
 
    void resize(uint w, uint h, bool fixedSize = false);
 
    void resizeWithoutDataLost(uint x, uint y, const T& defVal = T());
 
    void clear();
 
    void reset();
 
    void reset(uint w, uint h, bool fixedSize = false);
 
    ColumnType& column(uint n);
    const ColumnType& column(uint n) const;
 
    void zero();
 
    void fill(const T& v);
 
    void fillUnit();
 
    template<class U>
    void multiplyAllEntriesBy(const U& c);
 
    template<class U>
    void multiplyColumnBy(uint x, const U& c);
    template<class U>
    void divideColumnBy(uint x, const U& c);
 
    void averageTimeseries(bool roundValues = true);
 
    void roundAllEntries();
 
    T findLowerBound() const;
 
    T findUpperBound() const;
 
    void makeAllEntriesAbsolute();
 
    template<class U>
    void pasteToColumn(uint x, const U* data);
 
    void fillColumn(uint x, const T& value);
 
    void columnToZero(uint x);
 
    bool containsOnlyZero() const;
 
    template<class PredicateT>
    bool containsOnlyZero(PredicateT& predicate) const;
 
    void circularShiftRows(uint count);
 
    void circularShiftRows(uint column, uint count);
 
 
 
    bool forceReload(bool reload = false) const;
 
    void unloadFromMemory() const;
 
    void markAsModified() const;
 
    bool empty() const;
 
    void print() const;
 
 
 
    Matrix& operator=(const Matrix& rhs);
 
    Matrix& operator=(Matrix&& rhs) noexcept;
 
    template<class U>
    Matrix& operator=(const Matrix<U>& rhs);
 
    ColumnType& operator[](uint column);
    const ColumnType& operator[](uint column) const;
 
public:
    mutable uint width;
    mutable uint height;
    mutable ColumnType* entry;
    mutable JIT::Informations* jit;
 
    struct PredicateIdentity
    {
        template<class U = Type>
        inline U operator()(const U& value) const
        {
            return value;
        }
    };
 
    void saveToBuffer(std::string& data, uint precision = 6) const;
 
    template<class PredicateT>
    void saveToBuffer(std::string& data,
                      uint precision,
                      bool print_dimensions,
                      PredicateT& predicate,
                      bool saveEvenIfAllZero) const;
 
private:
    bool internalLoadCSVFile(const AnyString& filename,
                             uint minWidth,
                             uint maxHeight,
                             uint options,
                             BufferType* buffer = NULL);
 
    bool internalLoadJITData(const AnyString& filename,
                             uint minWidth,
                             uint maxHeight,
                             uint options);
 
    template<class PredicateT>
    bool internalSaveCSVFile(const AnyString& filename,
                             uint precision,
                             bool print_dimensions,
                             PredicateT& predicate,
                             bool saveEvenIfAllZero) const;
 
    bool loadFromBuffer(const AnyString& filename,
                        BufferType& data,
                        uint minWidth,
                        uint maxHeight,
                        const int fixedSize,
                        uint options);
    bool loadAllJITData() const;
 
    void reverseRows(uint column, uint start, uint end);
 
}; // class Matrix
 
template<class T>
class MatrixSubColumn
{
    // using Type = <sub column> ;
    // using Type = const <sub column> ;
};
 
template<class U>
class MatrixSubColumn<U**>
{
public:
    using Type = U*;
    using ConstType = const U*;
};
 
template<>
class MatrixSubColumn<Matrix<double>::ColumnType*>
{
public:
    using MatrixType = Matrix<double>;
    using Type = MatrixType::ColumnType&;
    using ConstType = const MatrixType::ColumnType&;
};
 
template<>
class MatrixSubColumn<Matrix<float>::ColumnType*>
{
public:
    using MatrixType = Matrix<float>;
    using Type = MatrixType::ColumnType&;
    using ConstType = const MatrixType::ColumnType&;
};
 
int MatrixTestForPositiveValues(const char* msg, const Matrix<>* m);
 
int MatrixTestIfValuesAreHigherThan(const char* msg, const Matrix<>* m, const double value);
 
int MatrixTestIfValuesAreLowerThan(const char* msg, const Matrix<>* m, const double value);
 
int MatrixTestForNegativeValues(const char* msg, const Matrix<>* m);
 
int MatrixTestForPositiveValues_LimitWidth(const char* msg, const Matrix<>* m, uint maxWidth);
 
template<class T1, class T2>
bool MatrixTestForAtLeastOnePositiveValue(const Matrix<T1, T2>& m);
 
} // namespace Antares
 
#include "matrix.hxx"
 
#endif // __ANTARES_LIBS_ARRAY_MATRIX_H__