matrix_variables_grid.hpp

Go to the documentation of this file.

/*
 *    This file is part of ACADO Toolkit.
 *
 *    ACADO Toolkit -- A Toolkit for Automatic Control and Dynamic Optimization.
 *    Copyright (C) 2008-2014 by Boris Houska, Hans Joachim Ferreau,
 *    Milan Vukov, Rien Quirynen, KU Leuven.
 *    Developed within the Optimization in Engineering Center (OPTEC)
 *    under supervision of Moritz Diehl. All rights reserved.
 *
 *    ACADO Toolkit is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation; either
 *    version 3 of the License, or (at your option) any later version.
 *
 *    ACADO Toolkit 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 GNU
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with ACADO Toolkit; if not, write to the Free Software
 *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */


#ifndef ACADO_TOOLKIT_MATRIX_VARIABLES_GRID_HPP
#define ACADO_TOOLKIT_MATRIX_VARIABLES_GRID_HPP

#include <acado/variables_grid/grid.hpp>

BEGIN_NAMESPACE_ACADO

const Grid emptyGrid;
const Grid trivialGrid( 1 );

class VariablesGrid;
class MatrixVariable;

class MatrixVariablesGrid : public Grid
{
    //
    // PUBLIC MEMBER FUNCTIONS:
    //
    public:

        MatrixVariablesGrid( );

        MatrixVariablesGrid(    uint _nRows,
                                                                uint _nCols,
                                                                const Grid& _grid,
                                                                VariableType _type = VT_UNKNOWN,
                                                                const char** const _names = 0,
                                                                const char** const _units = 0,
                                                                const DVector* const _scaling = 0,
                                                                const DVector* const _lb = 0,
                                                                const DVector* const _ub = 0,
                                                                const BooleanType* const _autoInit = 0
                                                                );

        MatrixVariablesGrid(    uint _nRows,
                                                                uint _nCols,
                                                                uint _nPoints,
                                                                VariableType _type = VT_UNKNOWN,
                                                                const char** const _names = 0,
                                                                const char** const _units = 0,
                                                                const DVector* const _scaling = 0,
                                                                const DVector* const _lb = 0,
                                                                const DVector* const _ub = 0,
                                                                const BooleanType* const _autoInit = 0
                                                                );

                MatrixVariablesGrid(    uint _nRows,
                                                                uint _nCols,
                                                                double _firstTime,
                                                                double _lastTime,
                                                                uint _nPoints,
                                                                VariableType _type = VT_UNKNOWN,
                                                                const char** const _names = 0,
                                                                const char** const _units = 0,
                                                                const DVector* const _scaling = 0,
                                                                const DVector* const _lb = 0,
                                                                const DVector* const _ub = 0,
                                                                const BooleanType* const _autoInit = 0
                                                                );

        MatrixVariablesGrid(    const DMatrix& arg,
                                                                const Grid& _grid = trivialGrid,
                                                                VariableType _type = VT_UNKNOWN
                                                                );

        MatrixVariablesGrid(    const MatrixVariablesGrid& rhs
                                                                );

        virtual ~MatrixVariablesGrid( );

        MatrixVariablesGrid& operator=( const MatrixVariablesGrid& rhs
                                                                                );




                MatrixVariablesGrid& operator=( const DMatrix& rhs
                                                                                );


        double& operator()(     uint pointIdx,
                                                                        uint rowIdx,
                                                                        uint colIdx
                                                                        );

        double operator()(      uint pointIdx,
                                                                        uint rowIdx,
                                                                        uint colIdx
                                                                        ) const;

        MatrixVariablesGrid operator()( const uint rowIdx
                                                                                                ) const;

        MatrixVariablesGrid operator[]( const uint pointIdx
                                                                                                ) const;


                MatrixVariablesGrid operator+(  const MatrixVariablesGrid& arg
                                                                                                ) const;

                MatrixVariablesGrid& operator+=(        const MatrixVariablesGrid& arg
                                                                                                );


                MatrixVariablesGrid operator-(  const MatrixVariablesGrid& arg
                                                                                                ) const;

                MatrixVariablesGrid& operator-=(        const MatrixVariablesGrid& arg
                                                                                                );


        returnValue init( );

        returnValue init(       uint _nRows,
                                                        uint _nCols,
                                                        const Grid& _grid,
                                                        VariableType _type = VT_UNKNOWN,
                                                        const char** const _names = 0,
                                                        const char** const _units = 0,
                                                        const DVector* const _scaling = 0,
                                                        const DVector* const _lb = 0,
                                                        const DVector* const _ub = 0,
                                                        const BooleanType* const _autoInit = 0
                                                        );

        returnValue init(       uint _nRows,
                                                        uint _nCols,
                                                        uint _nPoints,
                                                        VariableType _type = VT_UNKNOWN,
                                                        const char** const _names = 0,
                                                        const char** const _units = 0,
                                                        const DVector* const _scaling = 0,
                                                        const DVector* const _lb = 0,
                                                        const DVector* const _ub = 0,
                                                        const BooleanType* const _autoInit = 0
                                                        );

        returnValue init(       uint _nRows,
                                                        uint _nCols,
                                                        double _firstTime,
                                                        double _lastTime,
                                                        uint _nPoints,
                                                        VariableType _type = VT_UNKNOWN,
                                                        const char** const _names = 0,
                                                        const char** const _units = 0,
                                                        const DVector* const _scaling = 0,
                                                        const DVector* const _lb = 0,
                                                        const DVector* const _ub = 0,
                                                        const BooleanType* const _autoInit = 0
                                                        );

                returnValue init(       const DMatrix& arg,
                                                        const Grid& _grid = trivialGrid,
                                                        VariableType _type = VT_UNKNOWN
                                                        );

                returnValue addMatrix(  const DMatrix& newMatrix,
                                                                double newTime = -INFTY
                                                                );

                returnValue setMatrix(  uint pointIdx,
                                                                const DMatrix& _value
                                                                ) const;

                returnValue setAllMatrices(     const DMatrix& _values
                                                                        );


                DMatrix getMatrix(      uint pointIdx
                                                        ) const;

                DMatrix getFirstMatrix( ) const;

                DMatrix getLastMatrix( ) const;


                uint getDim( ) const;


                uint getNumRows( ) const;

                uint getNumCols( ) const;

                uint getNumValues( ) const;


                uint getNumRows(        uint pointIdx
                                                                ) const;

                uint getNumCols(        uint pointIdx
                                                                ) const;

                uint getNumValues(      uint pointIdx
                                                                        ) const;


        VariableType getType( ) const;

        returnValue setType(    VariableType _type
                                                                        );

                VariableType getType(   uint pointIdx
                                                                                ) const;

        returnValue setType(    uint pointIdx,
                                                                        VariableType _type
                                                                        );

                returnValue getName(    uint pointIdx,
                                                                        uint idx,
                                                                        char* const _name
                                                                        ) const;

                returnValue setName(    uint pointIdx,
                                                                        uint idx,
                                                                        const char* const _name
                                                                        );


                returnValue getUnit(    uint pointIdx,
                                                                        uint idx,
                                                                        char* const _unit
                                                                        ) const;

                returnValue setUnit(    uint pointIdx,
                                                                        uint idx,
                                                                        const char* const _unit
                                                                        );

                DVector getScaling(     uint pointIdx
                                                                                                ) const;

                returnValue setScaling( uint pointIdx,
                                                                                const DVector& _scaling
                                                                                );

                double getScaling(      uint pointIdx,
                                                                        uint valueIdx
                                                                        ) const;

                returnValue setScaling( uint pointIdx,
                                                                                uint valueIdx,
                                                                                double _scaling
                                                                                );

                DVector getLowerBounds( uint pointIdx
                                                                                                        ) const;

                returnValue setLowerBounds(     uint pointIdx,
                                                                                        const DVector& _lb
                                                                                        );

                double getLowerBound(   uint pointIdx,
                                                                                uint valueIdx
                                                                                ) const;

                returnValue setLowerBound(      uint pointIdx,
                                                                                        uint valueIdx,
                                                                                        double _lb
                                                                                        );

                DVector getUpperBounds( uint pointIdx
                                                                                                        ) const;

                returnValue setUpperBounds(     uint pointIdx,
                                                                                        const DVector& _ub
                                                                                        );

                double getUpperBound(   uint pointIdx,
                                                                                uint valueIdx
                                                                                ) const;

                returnValue setUpperBound(      uint pointIdx,
                                                                                        uint valueIdx,
                                                                                        double _ub
                                                                                        );


                BooleanType getAutoInit(        uint pointIdx
                                                                                ) const;

                returnValue setAutoInit(        uint pointIdx,
                                                                                BooleanType _autoInit
                                                                                );

                returnValue disableAutoInit( );

                returnValue enableAutoInit( );


                BooleanType hasNames( ) const;

                BooleanType hasUnits( ) const;

                BooleanType hasScaling( ) const;

                BooleanType hasLowerBounds( ) const;

                BooleanType hasUpperBounds( ) const;


                double getMax( ) const;

                double getMin( ) const;

                double getMean( ) const;

                returnValue setZero( );

                returnValue setAll(     double _value
                                                                        );

                returnValue appendTimes(        const MatrixVariablesGrid& arg,
                                                                        MergeMethod _mergeMethod = MM_DUPLICATE
                                                                        );

                returnValue appendValues(       const MatrixVariablesGrid& arg
                                                                        );

                returnValue merge(      const MatrixVariablesGrid& arg,
                                                        MergeMethod _mergeMethod = MM_DUPLICATE,
                                                        BooleanType keepOverlap = BT_TRUE
                                                        );

        returnValue getGrid(    Grid& _grid
                                                                        ) const;

                Grid getTimePoints( ) const;

        MatrixVariablesGrid getTimeSubGrid(     uint startIdx,
                                                                                        uint endIdx
                                                                                        ) const;

        MatrixVariablesGrid getValuesSubGrid(   uint startIdx,
                                                                                                uint endIdx
                                                                                                ) const;

                returnValue refineGrid( const Grid& arg,
                                                                InterpolationMode mode = IM_CONSTANT
                                                                );

                returnValue coarsenGrid(        const Grid& arg
                                                                        );

                MatrixVariablesGrid getRefinedGrid(     const Grid& arg,
                                                                                        InterpolationMode mode = IM_CONSTANT
                                                                                        ) const;

                MatrixVariablesGrid getCoarsenedGrid(   const Grid& arg
                                                                                                ) const;

                MatrixVariablesGrid& shiftTimes(        double timeShift
                                                                                        );

                MatrixVariablesGrid& shiftBackwards( DMatrix lastValue = emptyMatrix );

                DVector linearInterpolation(    double time
                                                                        ) const;

                returnValue print(      std::ostream& stream           = std::cout,
                                                        const char* const name         = DEFAULT_LABEL,
                                                        const char* const startString  = DEFAULT_START_STRING,
                                                        const char* const endString    = DEFAULT_END_STRING,
                                                        uint width                     = DEFAULT_WIDTH,
                                                        uint precision                 = DEFAULT_PRECISION,
                                                        const char* const colSeparator = DEFAULT_COL_SEPARATOR,
                                                        const char* const rowSeparator = DEFAULT_ROW_SEPARATOR
                                                        ) const;

                returnValue print(      const char* const filename,
                                                        const char* const name         = DEFAULT_LABEL,
                                                        const char* const startString  = DEFAULT_START_STRING,
                                                        const char* const endString    = DEFAULT_END_STRING,
                                                        uint width                     = DEFAULT_WIDTH,
                                                        uint precision                 = DEFAULT_PRECISION,
                                                        const char* const colSeparator = DEFAULT_COL_SEPARATOR,
                                                        const char* const rowSeparator = DEFAULT_ROW_SEPARATOR
                                                        ) const;

                returnValue print(      const char* const filename,
                                                        const char* const name,
                                                        PrintScheme printScheme
                                                        ) const;

                returnValue print(      std::ostream& stream,
                                                        const char* const name,
                                                        PrintScheme printScheme
                                                        ) const;

                returnValue read(       std::istream& stream
                                                        );

                returnValue read(       const char* const filename
                                                        );

                friend std::ostream& operator<<(        std::ostream& stream,
                                                                                        const MatrixVariablesGrid& arg
                                                                                        );

                friend std::istream& operator>>(        std::istream& stream,
                                                                                MatrixVariablesGrid& arg
                                                                                );

                returnValue sprint(     std::ostream& stream
                                                        );

    //
    // PROTECTED MEMBER FUNCTIONS:
    //
    protected:

                returnValue clearValues( );


                returnValue initMatrixVariables(        uint _nRows,
                                                                                        uint _nCols,
                                                                                        VariableType _type = VT_UNKNOWN,
                                                                                        const char** const _names = 0,
                                                                                        const char** const _units = 0,
                                                                                        const DVector* const _scaling = 0,
                                                                                        const DVector* const _lb = 0,
                                                                                        const DVector* const _ub = 0,
                                                                                        const BooleanType* const _autoInit = 0
                                                                                        );

                returnValue addMatrix(  const MatrixVariable& newMatrix,
                                                                double newTime = -INFTY
                                                                );

    //
    // DATA MEMBERS:
    //
    protected:

                MatrixVariable** values;
};

CLOSE_NAMESPACE_ACADO

#endif  // ACADO_TOOLKIT_MATRIX_VARIABLES_GRID_HPP

/*
 *      end of file
 */