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) 2012 Fernando José Iglesias García
 * 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 <algorithm>

#include <shogun/io/SGIO.h>
#include <shogun/lib/DataType.h>
#include <shogun/lib/SGSparseVector.h>
#include <shogun/lib/SGReferencedData.h>


namespace shogun
{
    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);

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

        SGVector<T> clone() const;

        static T* clone_vector(const T* vec, int32_t len)
        {
            T* result = SG_MALLOC(T, len);
            memcpy(result, vec, sizeof(T)*len);
            return result;
        }

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

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

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

        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)
        {
            ASSERT(x.vector && vector);
            ASSERT(x.vlen == vlen);

            SGVector<T> result=clone();
            result.add(x);
            return result;
        }

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

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

        static void permute_vector(SGVector<T> vec);

        void permute();

        static inline void resize(T* &data, int64_t old_size, int64_t new_size)
        {
            if (old_size==new_size)
                return;

            data = SG_REALLOC(T, data, new_size);
        }

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

//      /// x=x+alpha*y
//      static inline void vec1_plus_scalar_times_vec2(T* vec1,
//              T scalar, const T* vec2, int32_t n)
//      {
//          for (int32_t i=0; i<n; i++)
//              vec1[i]+=scalar*vec2[i];
//      }

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

        static void vec1_plus_scalar_times_vec2(float32_t* vec1,
                const float32_t scalar, const float32_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 inline void scale_vector(T alpha, T* vec, int32_t len)
        {
            for (int32_t i=0; i<len; i++)
                vec[i]*=alpha;
        }

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

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

        static inline int32_t arg_max(T * vec, int32_t inc, int32_t len, T * maxv_ptr = NULL)
        {
            ASSERT(len > 0 || inc > 0);

            T maxv = vec[0];
            int32_t maxIdx = 0;

            for (int32_t i = 1, j = inc ; i < len ; i++, j += inc)
            {
                if (vec[j] > maxv)
                    maxv = vec[j], maxIdx = i;
            }

            if (maxv_ptr != NULL)
                *maxv_ptr = maxv;

            return maxIdx;
        }

        static inline int32_t arg_min(T * vec, int32_t inc, int32_t len, T * minv_ptr = NULL)
        {
            ASSERT(len > 0 || inc > 0);

            T minv = vec[0];
            int32_t minIdx = 0;

            for (int32_t i = 1, j = inc ; i < len ; i++, j += inc)
            {
                if (vec[j] < minv)
                    minv = vec[j], minIdx = i;
            }

            if (minv_ptr != NULL)
                *minv_ptr = minv;

            return minIdx;
        }

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

        struct IndexSorter
        {
            IndexSorter(const SGVector<T> *vec) { data = vec->vector; }

            bool operator() (index_t i, index_t j) const
            {
                return data[i] < data[j];
            }

            const T* data;
        };
        SGVector<index_t> sorted_index()
        {
            IndexSorter cmp(this);
            SGVector<index_t> idx(vlen);
            for (index_t i=0; i < vlen; ++i)
                idx[i] = i;

            std::sort(idx.vector, idx.vector+vlen, cmp);

            return idx;
        }

        void scale(T alpha);

        float64_t mean() const;

        void load(CFile* loader);

        void save(CFile* saver);

    protected:
        virtual void copy_data(const SGReferencedData &orig);

        virtual void init_data();

        virtual void free_data();

    public:
        T* vector;
        index_t vlen;
};
}
#endif // __SGVECTOR_H__