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/DataType.h>
#include <shogun/lib/SGReferencedData.h>


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

template<class T> class SGVector : public SGReferencedData
{
    public:
        SGVector();

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

        SGVector(index_t len, bool ref_counting=true);

        SGVector(const SGVector &orig);

        void set(SGVector<T> orig);

        virtual ~SGVector();

        inline int32_t size() const { return vlen; }

        operator T*() { return vector; };

        void zero();

        void set_const(T const_elem);

        void range_fill(T start=0);

        void random(T min_value, T max_value);

        void randperm();

        static SGVector<T> randperm_vec(int32_t n);

        static T* randperm(int32_t n);

        static SGVector<float64_t> linspace_vec(T start, T end, int32_t n);

        static float64_t* linspace(T start, T end, int32_t n);

        index_t find_position_to_insert(T element);

        void qsort();

        SGVector<index_t> argsort();

        bool is_sorted() const;

        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);

        static void randperm(T* perm, int32_t n);

        static void permute(T* vec, int32_t n);

        static void permute(T* vec, int32_t n, CRandom * rand);

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

        const T& get_element(index_t index);

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

        void resize_vector(int32_t n);

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

        inline T& operator[](index_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 void permute_vector(SGVector<T> vec);

        void permute();

        void permute(CRandom * rand);

        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 float64_t dot(const bool* v1, const bool* v2, int32_t n)
        {
            float64_t r=0;
            for (int32_t i=0; i<n; i++)
                r+=((v1[i]) ? 1 : 0) * ((v2[i]) ? 1 : 0);
            return r;
        }

        static inline floatmax_t dot(const floatmax_t* v1, const floatmax_t* v2, int32_t n)
        {
            floatmax_t r=0;
            for (int32_t i=0; i<n; i++)
                r+=v1[i]*v2[i];
            return r;
        }


        static float64_t dot(const float64_t* v1, const float64_t* v2, int32_t n);

        static float32_t dot(const float32_t* v1, const float32_t* v2, int32_t n);

        static inline float64_t dot(
            const uint64_t* v1, const uint64_t* v2, int32_t n)
        {
            float64_t r=0;
            for (int32_t i=0; i<n; i++)
                r+=((float64_t) v1[i])*v2[i];

            return r;
        }
        static inline float64_t dot(
            const int64_t* v1, const int64_t* v2, int32_t n)
        {
            float64_t r=0;
            for (int32_t i=0; i<n; i++)
                r+=((float64_t) v1[i])*v2[i];

            return r;
        }

        static inline float64_t dot(
            const int32_t* v1, const int32_t* v2, int32_t n)
        {
            float64_t r=0;
            for (int32_t i=0; i<n; i++)
                r+=((float64_t) v1[i])*v2[i];

            return r;
        }

        static inline float64_t dot(
            const uint32_t* v1, const uint32_t* v2, int32_t n)
        {
            float64_t r=0;
            for (int32_t i=0; i<n; i++)
                r+=((float64_t) v1[i])*v2[i];

            return r;
        }

        static inline float64_t dot(
            const uint16_t* v1, const uint16_t* v2, int32_t n)
        {
            float64_t r=0;
            for (int32_t i=0; i<n; i++)
                r+=((float64_t) v1[i])*v2[i];

            return r;
        }

        static inline float64_t dot(
            const int16_t* v1, const int16_t* v2, int32_t n)
        {
            float64_t r=0;
            for (int32_t i=0; i<n; i++)
                r+=((float64_t) v1[i])*v2[i];

            return r;
        }

        static inline float64_t dot(
            const char* v1, const char* v2, int32_t n)
        {
            float64_t r=0;
            for (int32_t i=0; i<n; i++)
                r+=((float64_t) v1[i])*v2[i];

            return r;
        }

        static inline float64_t dot(
            const uint8_t* v1, const uint8_t* v2, int32_t n)
        {
            float64_t r=0;
            for (int32_t i=0; i<n; i++)
                r+=((float64_t) v1[i])*v2[i];

            return r;
        }

        static inline float64_t dot(
            const int8_t* v1, const int8_t* v2, int32_t n)
        {
            float64_t r=0;
            for (int32_t i=0; i<n; i++)
                r+=((float64_t) v1[i])*v2[i];

            return r;
        }

        static inline float64_t dot(
            const float64_t* v1, const char* v2, int32_t n)
        {
            float64_t r=0;
            for (int32_t i=0; i<n; i++)
                r+=((float64_t) v1[i])*v2[i];

            return r;
        }

        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 min(T* vec, int32_t len);

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

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

        static int32_t arg_max(T * vec, int32_t inc, int32_t len, T * maxv_ptr = NULL);

        static int32_t arg_max_abs(T * vec, int32_t inc, int32_t len, T * maxv_ptr = NULL);

        static int32_t arg_min(T * vec, int32_t inc, int32_t len, T * minv_ptr = NULL);

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

        static bool fequal(T x, T y, float64_t precision=1e-6);

        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);

        float64_t mean() const;

        void load(CFile* loader);

        void save(CFile* saver);

        void abs();
        void acos();
        void asin();
        void atan();
        void atan2(T x);
        void cos();
        void cosh();
        void exp();
        void log();
        void log10();
        void pow(T q);
        void sin();
        void sinh();
        void sqrt();
        void tan();
        void tanh();

        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);

    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__