root/trunk/multiarray/dflat/DenseVector.d

/*==========================================================================
 * densevector.d
 *    Written in the D Programming Language (http://www.digitalmars.com/d)
 */
/***************************************************************************
 * <TODO: Module Summary>
 *
 * <TODO: Description>
 *
 * Authors:  William V. Baxter III, OLM Digital, Inc.
 * Date: 14 Feb 2008
 * Copyright: (C) 2008  William Baxter, OLM Digital, Inc.
 *            Based in part on FLENS, Copyright (c) 2007, Michael Lehn
 *            All rights reserved.
 * License:
 *
 *   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 DFLAT 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.
 */
//===========================================================================

module dflat.DenseVector;

version(Tango) import std.compat;

//import dflat.Matvec;
import dflat.dflat_blas;
import dflat.Range;
//import dflat.Traits;
import dflat.Blas;

// == DenseVector ==============================================================

import std.stdio;
/**
   The A parameter is some array storage type like dflat.Array
 */
struct DenseVector(A)
{
public:

    alias A                            Storage;
    alias A.View                       AView;
    alias A.NoView                     ANoView;

    alias DenseVector!(AView)          View;
    alias DenseVector!(ANoView)        NoView;

    alias A.ElementType                ElementType;

    private alias A.ElementType        T; // for convenience

    static DenseVector opCall() { 
        DenseVector R; return R;
    }

    static DenseVector opCall(/*const*/ ref A eng) {
        DenseVector R; with(R) {
            engine_ = A(eng);
        } return R;
    }

    static if(is(A==ANoView)) {
        // only Non-view has these constructors
        static DenseVector opCall(int len, int firstIndex = 0) {
            DenseVector R; with(R) {
                engine_ = A(len, firstIndex);
            } return R;
        }

        static DenseVector opCall(Range r) {
            DenseVector R; R = r;
            return R;
        }

        void resizeOrClear(int length, int firstIndex=0)
        {
            engine_.resizeOrClear(length,firstIndex);
        }

        void setBeginIndex(int firstIndex)
        {
            engine_.setBeginIndex(firstIndex);
        }

    }

    static DenseVector opCall(/*const*/ ref DenseVector rhs) {
        DenseVector R; with(R) {
            engine_ = A(rhs.engine_);
        } return R;
    }

    static DenseVector opCall(/*const*/ T[] rhs) {
        DenseVector R;
        R = rhs;
        return R;
    }
/+
 // needs a diff name to not conflict
    static DenseVector opCall(E)(/*const*/ref DenseVector!(E) rhs) {
        DenseVector R; with(R) {
            engine_ = A(rhs.engine);
        } return R;
    }
+/
    /+
     static DenseVector opCall(E)(/*const*/ ref Vector!(E) rhs) {
        DenseVector R; with(R) {
        } return R;
    }
    +/
    // -- operators --------------------------------------------------------

    /+ListInitializerSwitch!(DenseVector!(A))
    opAssign(/*const*/ref T value) {
        return ListInitializerSwitch<DenseVector<A> >(_engine.ptr(),
                                                      _engine.stride(),
                                                      _engine.length(),
                                                      value);
    }+/

    DenseVector dup() {
        DenseVector R; R.engine_ = engine_.dup;
        return R;
    }

    /+
    void opAssign(RHS)(/*const*/ref Vector!(RHS) rhs)
    {
        copy(rhs.impl(), *this);
        return *this;
    }+/

    /** Set the array to contain the range of numbers specified 
     */
    void opAssign(/*const*/ref Range r) 
    {
        assert(r.isFixed, "Relative range not allowed in this context");
        this.resize(r);
        int index = beginIndex();
        for (int i=0; i<length(); ++i) {
            *engine_.elem_ptr(index++) = cast(T)(r.begin+i*r.stride);
        }
    }

    void opAssign(T[] arr) {
        this.resize(arr.length);
        int index = beginIndex();
        // We do this slow thing because we could have a view...
        if (this.stride!=1) {
            for (int i=0; i<length(); ++i) {
                *engine_.elem_ptr(index++) = cast(T)(arr[i]);
            }
        }
        else {
            engine_.ptr[0..arr.length] = arr[0..arr.length];
        }
    }


    void opAddAssign(RHS)(/*const*/ ref Vector!(RHS) rhs) {
        axpy(cast(T)1, rhs.impl(), *this);
    }

    void opAddAssign()(T c) {
        for (int i=beginIndex(); i<endIndex(); ++i) {
            *engine_.elem_ptr(i) += c;
        }
    }

    void opSubAssign(RHS)(/*const*/ ref Vector!(RHS) rhs) {
        axpy(cast(T)(-1), rhs.impl(), *this);
    }

    void opSubAssign()(T c) 
    {
        for (int i=beginIndex(); i<endIndex(); ++i) {
            *engine_.elem_ptr(i) -= c;
        }
    }

    void opMulAssign(T alpha) 
    {
        scal_dv!(A)(alpha, *this);

    }

    void opDivAssign(T alpha) 
    {
        scal_dv!(A)(cast(T)(1)/alpha, *this);
    }

    DenseVector opNeg()
    {
        auto ret = this.dup;
        ret *= cast(T)-1;
        return ret;
    }


    T opIndex(int index) 
    { 
        return engine_[index];
    }

    void opIndexAssign(T val, int index) 
    { 
        engine_[index] = val;
    }

    // Indexing operators

    View opIndex(/*const*/ ref Range r) {
        version(STIP) {
            return View(engine_.view(r.begin, r.end, r.stride, r.begin));
        }
        else {
            return View(engine_.view(r.begin, r.end, r.stride, beginIndex()));
        }
    }

    View opIndex(int firstIndex, int stride, int lastIndex) {
        version(STIP) {
            return View(engine_.view(firstIndex, lastIndex, stride, beginIndex()));
        }
        else {
            return View(engine_.view(firstIndex, lastIndex, stride, beginIndex()));
        }
    }

    T* elem_ptr(T val, int index) 
    { 
        return engine_.elem_ptr(index);
    }


    // -- methods ----------------------------------------------------------
    int beginIndex() { return engine_.beginIndex; }

    int endIndex() { return engine_.endIndex; }

    int length() { return engine_.length; }

    int stride() { return engine_.stride; }

    Range range() { return Range(beginIndex(), endIndex()); }

    T *ptr() { return engine_.ptr; }

    alias ptr begin; // for STL compatibility -- remove?

    T * end()  // for STL compatibility -- remove?
    { return engine_.elem_ptr(endIndex()); }

    A engine() { return engine_; }

    A* engine_ptr() { return &engine_; }

    /** Resize vector -- for compatibility with D vectors */
    void length(int len) { resize(len,beginIndex()); }

    /** Resize vector */
    void resize(int len, int firstIndex=0) 
    {
        engine_.resize(len,firstIndex);
    }

    /** Resize vector to have begin/end given by Range */
    void resize(/*const*/ref Range r)
    {
        engine_.resize(r.length,r.begin);
    }

    char[] toString() {
        static if(is(typeof(A.toString))) {
            return engine_.toString();
        }
        else {
            return "[no toString]";
        }
    }

private:
    A engine_;
}

/+
template <A>
struct TypeInfo<DenseVector<A> >
{
    alias DenseVector<A> Impl;
    alias A::ElementType ElementType;
}
+/




//--- Emacs setup ---
// Local Variables:
// c-basic-offset: 4
// indent-tabs-mode: nil
// End: