1
       2
       3
       4
       5
       6
       7
       8
       9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
<doc  53
      54
      55
      56
      57

      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
<doc  69
      70
      71

      72
<doc  73
      74
      75
      76
<doc  77
      78

      79
      80
      81
<doc  82
      83

      84
<doc  85
      86

      87
<doc  88
      89

      90
<doc  91
      92

      93
<doc  94
      95

      96
<doc  97
      98

      99
<doc 100
     101

     102
<doc 103
     104

     105
<doc 106
     107

     108
<doc 109
     110

     111
     112
     113
     114
     115
     116
     117
     118
     119
     120
     121
     122
     123
     124
     125
     126
     127
     128
<doc 129
     130
     131

<doc 132
     133
     134
     135
     136
     137
     138
     139
<doc 140
     141
     142

<doc 143
     144
<doc 145
     146

     147
<doc 148
     149

     150
     151
     152
     153
     154
     155
     156
     157
     158
     159
     160
     161
     162
     163
     164
     165
<doc 166
     167

     168
     169
<doc 170
     171
     172
     173

     174
     175
     176
     177
     178
     179
     180
<doc 181
     182

     183
     184
<doc 185
     186
     187
     188

     189
     190
     191
     192
     193
/*
 *   Copyright (c) 2007-2012, Michael Lehn
 *
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following conditions
 *   are met:
 *
 *   1) Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2) Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the
 *      distribution.
 *   3) Neither the name of the FLENS development group nor the names of
 *      its contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef FLENS_STORAGE_COORDSTORAGE_COORDSTORAGE_H
#define FLENS_STORAGE_COORDSTORAGE_COORDSTORAGE_H 1

#include <cxxstd/algorithm.h>
#include <cxxstd/cstddef.h>
#include <cxxstd/vector.h>
#include <flens/storage/indexoptions.h>

namespace flens {

// forward declarations
template <typename T, typename IndexType>
    struct Coord;

template <typename T>
    struct CoordProxy;

struct CoordRowColCmp;


template <typename T,
          typename Cmp = CoordRowColCmp,
          typename I = IndexOptions<> >
class CoordStorage
{
    public:
        typedef T                        ElementType;
        typedef typename I::IndexType    IndexType;
        typedef CoordProxy<T>            ElementProxy;

        typedef Coord<T, IndexType>      CoordType;
        typedef std::vector<CoordType>   CoordVector;

        static const IndexType                        defaultIndexBase
                                                          = I::defaultIndexBase;

        CoordStorage(IndexType numRows, IndexType numCols,
                     IndexType densityEstimate = 1,
                     IndexType indexBase = I::defaultIndexBase);

        ~CoordStorage();

        //-- operators ---------------------------------------------------------

        ElementProxy
        operator()(IndexType row, IndexType col);

        //-- methods -----------------------------------------------------------

        const IndexType
        indexBase() const;

        const IndexType
        firstRow() const;

        const IndexType
        lastRow() const;

        const IndexType
        firstCol() const;

        const IndexType
        lastCol() const;

        const IndexType
        numRows() const;

        const IndexType
        numCols() const;

        void
        accumulate() const;

        const CoordVector &
        coordVector() const;

        const IndexType
        numNonZeros() const;

    //private:
        // Lehn:  I do not allow copying matrices with coordiante storage unless
        //        someone gives me a reason.
        CoordStorage(const CoordStorage &rhs);

        IndexType  numRows_, numCols_;
        IndexType  indexBase_;

        mutable CoordVector  coord_;
        mutable size_t       lastSortedCoord_;
        mutable bool         isSorted_;
        mutable bool         isAccumulated_;
        Cmp                  less_;
};

//-- Coord ---------------------------------------------------------------------

template <typename T, typename IndexType>
struct Coord
{
    Coord(IndexType row, IndexType col, const T &value);

    IndexType   row, col;
    T           value;
};

//-- CoordProxy ----------------------------------------------------------------

template <typename T>
struct CoordProxy
{
    CoordProxy(T *value);

    void
    operator+=(const T &x);

    void
    operator-=(const T &x);

    private:
        T  *value;

//
//      We only allow accumulation of data.  Assignment would be too expensive.
//
        void
        operator=(const T &x);
};

//-- CoordRowColCmp ------------------------------------------------------------
//
//  This ordering gets used for converting the coordinate storage format to
//  the compressed row storage format
//
struct CoordRowColCmp
{
        // return true if a < b
        //   <=>  a.row<b.row  or  a.row==b.row and a.col<b.col
        template <typename T, typename IndexType>
            bool
            operator()(const Coord<T, IndexType> &a,
                       const Coord<T, IndexType> &b) const;
};

//-- CoordColRowCmp ------------------------------------------------------------
//
//  This ordering gets used for converting the coordinate storage format to
//  the compressed row storage format
//
struct CoordColRowCmp
{
        // return true if a < b
        //   <=>  a.col<b.col  or  a(2)==b(2) and a.row<b.row
        template <typename T, typename IndexType>
            bool
            operator()(const Coord<T, IndexType> &a,
                       const Coord<T, IndexType> &b) const;
};

// namespace flens

#endif // FLENS_STORAGE_COORDSTORAGE_COORDSTORAGE_H