SGVector.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 2011-2013 Heiko Strathmann
 * Written (W) 2013 Soumyajit De
 * Written (W) 2012 Fernando Jose Iglesias Garcia
 * Written (W) 2010,2012 Soeren Sonnenburg
 * Copyright (C) 2010 Berlin Institute of Technology
 * Copyright (C) 2012 Soeren Sonnenburg
 */
#ifndef __SGVECTOR_H__
#define __SGVECTOR_H__

#include <shogun/lib/config.h>

#include <shogun/lib/common.h>
#include <shogun/lib/SGReferencedData.h>

namespace Eigen
{
    template <class, int, int, int, int, int> class Matrix;
    template<int, int> class Stride;
    template <class, int, class> class Map;
}

namespace shogun
{
    template <class T> class SGSparseVector;
    template <class T> class SGMatrix;
    class CFile;
    class CRandom;

template<class T> class SGVector : public SGReferencedData
{
    public:
        typedef Eigen::Matrix<T,-1,1,0,-1,1> EigenVectorXt;
        typedef Eigen::Matrix<T,1,-1,0x1,1,-1> EigenRowVectorXt;

        typedef Eigen::Map<EigenVectorXt,0,Eigen::Stride<0,0> > EigenVectorXtMap;
        typedef Eigen::Map<EigenRowVectorXt,0,Eigen::Stride<0,0> > EigenRowVectorXtMap;
    
        typedef T Scalar;

        SGVector();

        SGVector(T* v, index_t len, bool ref_counting=true);

        SGVector(T* m, index_t len, index_t offset)
            : SGReferencedData(false), vector(m+offset), vlen(len) { }

        SGVector(index_t len, bool ref_counting=true);

        SGVector(const SGVector &orig);

#ifndef SWIG // SWIG should skip this part
#if defined(HAVE_CXX0X) || defined(HAVE_CXX11)

        template <typename ST> using container_type = SGVector<ST>;

#endif // define (HAVE_CXX0X) || defined(HAVE_CXX11)

        SGVector(EigenVectorXt& vec);

        SGVector(EigenRowVectorXt& vec);

        operator EigenVectorXtMap() const;

        operator EigenRowVectorXtMap() const;
#endif // SWIG

        void set_const(T const_elem);

        SGVector<T> get()
        {
            return *this;
        }

#ifndef SWIG // SWIG should skip this part

        void set(SGVector<T> orig);

        virtual ~SGVector();

        inline int32_t size() const { return vlen; }

        inline T* data() const
        {
            return vector;
        }

        operator T*() { return vector; }

        void zero();

        void range_fill(T start=0);

        void random(T min_value, T max_value);

        index_t find_position_to_insert(T element);

        SGVector<T> clone() const;

        static T* clone_vector(const T* vec, int32_t len);

        static void fill_vector(T* vec, int32_t len, T value);

        static void range_fill_vector(T* vec, int32_t len, T start=0);

        static void random_vector(T* vec, int32_t len, T min_value, T max_value);
#endif // SWIG // SWIG should skip this part

        const T& get_element(index_t index);

        void set_element(const T& p_element, index_t index);

#ifndef SWIG // SWIG should skip this part

        void resize_vector(int32_t n);

        inline const T& operator[](uint64_t index) const
        {
            return vector[index];
        }

        inline const T& operator[](int64_t index) const
        {
            return vector[index];
        }

        inline const T& operator[](uint32_t index) const
        {
            return vector[index];
        }

        inline const T& operator[](int32_t index) const
        {
            return vector[index];
        }

        inline T& operator[](uint64_t index)
        {
            return vector[index];
        }

        inline T& operator[](int64_t index)
        {
            return vector[index];
        }

        inline T& operator[](uint32_t index)
        {
            return vector[index];
        }

        inline T& operator[](int32_t index)
        {
            return vector[index];
        }

        void add(const SGVector<T> x);

        void add(const SGSparseVector<T>& x);

        void add(const T x);

        SGVector<T> operator+ (SGVector<T> x);

        SGVector<T> operator+= (SGVector<T> x)
        {
            add(x);
            return *this;
        }

        SGVector<T> operator+= (SGSparseVector<T>& x)
        {
            add(x);
            return *this;
        }

        bool equals(SGVector<T>& other);

        static T twonorm(const T* x, int32_t len);

        static float64_t onenorm(T* x, int32_t len);

        static T qsq(T* x, int32_t len, float64_t q);

        static T qnorm(T* x, int32_t len, float64_t q);

        static void vec1_plus_scalar_times_vec2(T* vec1,
                const T scalar, const T* vec2, int32_t n);

        static inline void vector_multiply(
                T* target, const T* v1, const T* v2,int32_t len)
            {
                for (int32_t i=0; i<len; i++)
                    target[i]=v1[i]*v2[i];
            }


        static inline void add(
            T* target, T alpha, const T* v1, T beta, const T* v2,
            int32_t len)
        {
            for (int32_t i=0; i<len; i++)
                target[i]=alpha*v1[i]+beta*v2[i];
        }

        static inline void add_scalar(T alpha, T* vec, int32_t len)
        {
            for (int32_t i=0; i<len; i++)
                vec[i]+=alpha;
        }

        static void scale_vector(T alpha, T* vec, int32_t len);

        static inline T sum(T* vec, int32_t len)
        {
            T result=0;
            for (int32_t i=0; i<len; i++)
                result+=vec[i];

            return result;
        }

        static inline T sum(SGVector<T> vec)
        {
            return sum(vec.vector, vec.vlen);
        }

        static inline T product(T* vec, int32_t len)
        {
            T result=1;
            for (int32_t i=0; i<len; i++)
                result*=vec[i];

            return result;
        }

        inline T product()
        {
            return product(vector, vlen);
        }

        static T sum_abs(T* vec, int32_t len);

        static int32_t unique(T* output, int32_t size);

        void display_size() const;

        void display_vector(const char* name="vector",
                const char* prefix="") const;

        static void display_vector(
            const T* vector, int32_t n, const char* name="vector",
            const char* prefix="");

        static void display_vector(
            const SGVector<T>, const char* name="vector",
            const char* prefix="");

        SGVector<index_t> find(T elem);

        template <typename Predicate>
        SGVector<index_t> find_if(Predicate p)
        {
            SGVector<index_t> idx(vlen);
            index_t k=0;

            for (index_t i=0; i < vlen; ++i)
                if (p(vector[i]))
                    idx[k++] = i;

            idx.vlen = k;
            return idx;
        }

        void scale(T alpha);

        void load(CFile* loader);

        void save(CFile* saver);

        SGVector<float64_t> get_real();

        SGVector<float64_t> get_imag();

        static SGMatrix<T> convert_to_matrix(SGVector<T> vector, index_t nrows, index_t ncols, bool fortran_order);


        static void convert_to_matrix(T*& matrix, index_t nrows, index_t ncols, const T* vector, int32_t vlen, bool fortran_order);
#endif // #ifndef SWIG // SWIG should skip this part
    protected:
        virtual void copy_data(const SGReferencedData &orig);

        virtual void init_data();

        virtual void free_data();

    public:
        T* vector;
        index_t vlen;
};

#ifndef DOXYGEN_SHOULD_SKIP_THIS
template<> void SGVector<float64_t>::vec1_plus_scalar_times_vec2(float64_t* vec1,
                const float64_t scalar, const float64_t* vec2, int32_t n);

template<> void SGVector<float32_t>::vec1_plus_scalar_times_vec2(float32_t* vec1,
                const float32_t scalar, const float32_t* vec2, int32_t n);
#endif // DOXYGEN_SHOULD_SKIP_THIS
}
#endif // __SGVECTOR_H__