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
      69
      70
      71
      72
      73
      74
      75
      76
      77
      78
      79
      80
<doc  81
      82
<doc  83
      84

      85
<doc  86
      87
<doc  88
      89
<doc  90
      91
<doc  92
      93
<doc  94
      95

      96
<doc  97
      98

      99
<doc 100
     101

     102
     103
     104
<doc 105
     106

     107
<doc 108
     109

     110
<doc 111
     112
     113

     114
<doc 115
     116
     117

     118
<doc 119
     120
     121

     122
<doc 123
     124

     125
<doc 126
     127

     128
<doc 129
     130

     131
<doc 132
     133

     134
<doc 135
     136

     137
<doc 138
     139

     140
<doc 141
     142
     143
     144

     145
<doc 146
     147

     148
<doc 149
     150

     151
     152
     153
<doc 154
     155

     156
<doc 157
     158

     159
<doc 160
     161
     162

     163
<doc 164
     165
     166

     167
<doc 168
     169
     170

     171
<doc 172
     173
     174

     175
<doc 176
     177

     178
<doc 179
     180

     181
     182
<doc 183
     184

     185
<doc 186
     187

     188
<doc 189
     190

     191
<doc 192
     193

     194
<doc 195
     196

     197
<doc 198
     199

     200
<doc 201
     202

     203
<doc 204
     205

     206
<doc 207
     208

     209
<doc 210
     211

     212
<doc 213
     214
     215
     216

     217
<doc 218
     219
     220
     221

     222
<doc 223
     224

     225
<doc 226
     227

     228
     229
<doc 230
     231

     232
<doc 233
     234

     235
<doc 236
     237

     238
     239
     240
     241
     242
     243
     244
     245
     246
     247
     248
     249
<doc 250
     251

     252
<doc 253
     254

     255
     256
     257
     258
     259
     260
     261
     262
     263
     264
     265
     266
<doc 267
     268
     269

     270
     271
     272
     273
     274
     275
     276
     277
<doc 278
     279
     280

     281
     282
     283
     284
     285
     286
     287
     288
     289
     290
     291
<doc 292
     293
     294

     295
     296
     297
     298
     299
     300
     301
     302
     303
     304
<doc 305
     306
     307

     308
     309
     310
     311
     312
     313
     314
     315
     316
     317
     318
     319
     320
     321
     322
     323
     324
     325
     326
     327
     328
     329
     330
     331
     332
     333
     334
     335
     336
     337
     338
     339
     340
     341
     342
     343
     344
     345
<doc 346
     347
     348

     349
<doc 350
     351
     352
     353

     354
     355
     356
     357
     358
     359
<doc 360
     361
     362

     363
<doc 364
     365
     366
     367

     368
     369
     370
     371
     372
     373
<doc 374
     375
     376
     377

     378
     379
     380
     381
/*
 *   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_VECTORTYPES_IMPL_DENSEVECTOR_H
#define FLENS_VECTORTYPES_IMPL_DENSEVECTOR_H 1

#include <flens/auxiliary/auxiliary.h>
#include <flens/scalartypes/scalar.h>
#include <flens/vectortypes/auxiliary/imagvector.h>
#include <flens/vectortypes/auxiliary/realvector.h>
#include <flens/storage/array/imagarray.h>
#include <flens/storage/array/realarray.h>
#include <flens/vectortypes/impl/dv/constelementclosure.h>
#include <flens/vectortypes/impl/dv/elementclosure.h>
#include <flens/vectortypes/impl/dv/initializer.h>
#include <flens/vectortypes/vector.h>

namespace flens {

// forward declaration
template <typename IndexType>
    class IndexVariable;

template <typename A>
class DenseVector
    : public Vector<DenseVector<A> >
{
    public:
        typedef A                                           Engine;
        typedef typename Engine::ElementType                ElementType;
        typedef typename Engine::IndexType                  IndexType;

        // view types from Engine
        typedef typename Engine::ConstView                  EngineConstView;
        typedef typename Engine::View                       EngineView;
        typedef typename Engine::NoView                     EngineNoView;

        // view types
        typedef DenseVector<EngineConstView>                ConstView;
        typedef DenseVector<EngineView>                     View;
        typedef DenseVector<EngineNoView>                   NoView;

    private:
        typedef DenseVector                                 DV;

    public:
        typedef flens::IndexVariable<IndexType>             IndexVariable;
        typedef densevector::ConstElementClosure<DV>        ConstElementClosure;
        typedef densevector::ElementClosure<DV>             ElementClosure;
        typedef densevector::Initializer<DV>                Initializer;

        DenseVector();

        explicit
        DenseVector(IndexType length);

        DenseVector(IndexType length, IndexType firstIndex);

        DenseVector(const Range<IndexType> &range);

        DenseVector(const Engine &engine, bool reverse=false);

        DenseVector(const DenseVector &rhs);

        template <typename RHS>
            DenseVector(const DenseVector<RHS> &rhs);

        template <typename RHS>
            DenseVector(DenseVector<RHS> &rhs);

        template <typename RHS>
            DenseVector(const Vector<RHS> &rhs);

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

        Initializer
        operator=(const ElementType &value);

        DenseVector &
        operator=(const DenseVector &rhs);

        template <typename RHS>
            DenseVector &
            operator=(const Vector<RHS> &rhs);

        template <typename RHS>
            DenseVector &
            operator+=(const Vector<RHS> &rhs);

        template <typename RHS>
            DenseVector &
            operator-=(const Vector<RHS> &rhs);

        DenseVector &
        operator+=(const ElementType &rhs);

        DenseVector &
        operator-=(const ElementType &rhs);

        DenseVector &
        operator*=(const ElementType &alpha);

        DenseVector &
        operator/=(const ElementType &alpha);

        const ElementType &
        operator()(IndexType index) const;

        ElementType &
        operator()(IndexType index);

        template <typename S>
            const densevector::ConstElementClosure<DenseVector,
                                                   typename Scalar<S>::Impl>
            operator()(const Scalar<S> &index) const;

        const ConstElementClosure
        operator()(const IndexVariable &index) const;

        ElementClosure
        operator()(IndexVariable &index);

        //-- views -------------------------------------------------------------

        const ConstView
        operator()(const Range<IndexType> &range) const;

        View
        operator()(const Range<IndexType> &range);

        const ConstView
        operator()(const Range<IndexType> &range,
                   IndexType firstViewIndex) const;

        View
        operator()(const Range<IndexType> &range,
                   IndexType firstViewIndex);

        const ConstView
        operator()(const Underscore<IndexType> &all,
                   IndexType firstViewIndex) const;

        View
        operator()(const Underscore<IndexType> &all,
                   IndexType firstViewIndex);

        const ConstView
        reverse() const;

        View
        reverse();

        // -- methods ----------------------------------------------------------
        Range<IndexType>
        range() const;

        IndexType
        firstIndex() const;

        IndexType
        lastIndex() const;

        IndexType
        length() const;

        IndexType
        inc() const;

        IndexType
        endIndex() const;

        const ElementType *
        data() const;

        ElementType *
        data();

        IndexType
        stride() const;

        IndexType
        indexBase() const;

        template <typename RHS>
            bool
            resize(const DenseVector<RHS> &rhs,
                   const ElementType &value = ElementType());

        bool
        resize(IndexType length,
               IndexType firstIndex = Engine::defaultIndexBase,
               const ElementType &value = ElementType());

        bool
        fill(const ElementType &value = ElementType(0));

        void
        changeIndexBase(IndexType firstIndex);

        // -- implementation ---------------------------------------------------
        const A &
        engine() const;

        A &
        engine();

        bool
        reversed() const;

    private:
        A    _array;
        bool _reverse;
};

//-- Traits --------------------------------------------------------------------

//
//  IsDenseVector
//

struct _DenseVectorChecker
{

    struct Two
    {
        char x;
        char y;
    };

    static Two
    check(_AnyConversion);

    template <typename Any>
        static char
        check(DenseVector<Any>);
};

template <typename T>
struct IsDenseVector
{
    static T var;
    static const bool value = sizeof(_DenseVectorChecker::check(var))==1;
};

//
//  IsIntegerDenseVector
//

template <typename T>
struct IsIntegerDenseVector
{
    typedef typename std::remove_reference<T>::type  TT;

    static const bool value = IsDenseVector<TT>::value
                           && IsInteger<typename TT::ElementType>::value;
};


//
//  IsRealDenseVector
//

template <typename T>
struct IsRealDenseVector
{
    typedef typename std::remove_reference<T>::type  TT;

    static const bool value = IsDenseVector<TT>::value
                           && IsNotComplex<typename TT::ElementType>::value;
};

//
//  IsComplexDenseVector
//

template <typename T>
struct IsComplexDenseVector
{
    typedef typename std::remove_reference<T>::type  TT;

    static const bool value = IsDenseVector<TT>::value
                           && IsComplex<typename TT::ElementType>::value;
};

//
//   ImagVector
//

template <typename VZ>
struct ImagVector<DenseVector<VZ> >
{
    typedef typename ImagArray<VZ>::ConstView   ConstViewEngine;
    typedef typename ImagArray<VZ>::View        ViewEngine;
    typedef DenseVector<ConstViewEngine>        ConstView;
    typedef DenseVector<ViewEngine>             View;
};

//
//   RealVector
//

template <typename VZ>
struct RealVector<DenseVector<VZ> >
{
    typedef typename RealArray<VZ>::ConstView   ConstViewEngine;
    typedef typename RealArray<VZ>::View        ViewEngine;
    typedef DenseVector<ConstViewEngine>        ConstView;
    typedef DenseVector<ViewEngine>             View;
};

//-- DenseVector specific functions --------------------------------------------

//
//  imag
//

template <typename VZ>
    typename ImagVector<DenseVector<VZ> >::ConstView
    imag(const DenseVector<VZ> &z);

template <typename VZ>
    typename RestrictTo<IsDenseVector<VZ>::value,
             typename ImagVector<typename RemoveRef<VZ>::Type>::View>::Type
    imag(VZ &&z);


//
//  real
//

template <typename VZ>
    typename RealVector<DenseVector<VZ> >::ConstView
    real(const DenseVector<VZ> &z);

template <typename VZ>
    typename RestrictTo<IsDenseVector<VZ>::value,
             typename RealVector<typename RemoveRef<VZ>::Type>::View>::Type
    real(VZ &&z);


//
//  fillRandom
//

template <typename VX>
    typename RestrictTo<IsDenseVector<VX>::value,
             bool>::Type
    fillRandom(VX &&x);

// namespace flens

#endif // FLENS_VECTORTYPES_IMPL_DENSEVECTOR_H