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
<doc  51
      52
      53
      54
      55

      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
<doc  67
      68
      69

      70
<doc  71
      72
      73
      74
<doc  75
      76

      77
      78
      79
<doc  80
      81

      82
<doc  83
      84

      85
<doc  86
      87

      88
<doc  89
      90

      91
<doc  92
      93

      94
<doc  95
      96

      97
<doc  98
      99

     100
<doc 101
     102

     103
<doc 104
     105

     106
<doc 107
     108

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

<doc 130
     131
     132
     133
     134
     135
     136
     137
<doc 138
     139
     140

<doc 141
     142
<doc 143
     144

     145
<doc 146
     147

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

     166
     167
<doc 168
     169
     170
     171

     172
     173
     174
     175
     176
     177
     178
<doc 179
     180

     181
     182
<doc 183
     184
     185
     186

     187
     188
     189
     190
     191
/*
 *   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 <vector>
#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