DynamicArray.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) 1999-2009 Soeren Sonnenburg
 * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef _DYNAMIC_ARRAY_H_
#define _DYNAMIC_ARRAY_H_

#include <shogun/lib/config.h>

#include <shogun/base/SGObject.h>
#include <shogun/base/DynArray.h>
#include <shogun/base/Parameter.h>

namespace shogun
{
template <class T> class CDynamicArray :public CSGObject
{
    public:
        CDynamicArray()
        : CSGObject(), m_array(), name("Array")
        {
            dim1_size=1;
            dim2_size=1;
            dim3_size=1;

            init();
        }

        CDynamicArray(int32_t p_dim1_size, int32_t p_dim2_size=1, int32_t p_dim3_size=1)
        : CSGObject(), m_array(p_dim1_size*p_dim2_size*p_dim3_size), name("Array")
        {
            dim1_size=p_dim1_size;
            dim2_size=p_dim2_size;
            dim3_size=p_dim3_size;

            init();
        }

        CDynamicArray(T* p_array, int32_t p_dim1_size, bool p_free_array, bool p_copy_array)
        : CSGObject(), m_array(p_array, p_dim1_size, p_free_array, p_copy_array), name("Array")
        {
            dim1_size=p_dim1_size;
            dim2_size=1;
            dim3_size=1;

            init();
        }

        CDynamicArray(T* p_array, int32_t p_dim1_size, int32_t p_dim2_size,
                        bool p_free_array, bool p_copy_array)
        : CSGObject(), m_array(p_array, p_dim1_size*p_dim2_size, p_free_array, p_copy_array), name("Array")
        {
            dim1_size=p_dim1_size;
            dim2_size=p_dim2_size;
            dim3_size=1;

            init();
        }

        CDynamicArray(T* p_array, int32_t p_dim1_size, int32_t p_dim2_size,
                        int32_t p_dim3_size, bool p_free_array, bool p_copy_array)
        : CSGObject(), m_array(p_array, p_dim1_size*p_dim2_size*p_dim3_size, p_free_array, p_copy_array), name("Array")
        {
            dim1_size=p_dim1_size;
            dim2_size=p_dim2_size;
            dim3_size=p_dim3_size;

            init();
        }

        CDynamicArray(const T* p_array, int32_t p_dim1_size=1, int32_t p_dim2_size=1, int32_t p_dim3_size=1)
        : CSGObject(), m_array(p_array, p_dim1_size*p_dim2_size*p_dim3_size), name("Array")
        {
            dim1_size=p_dim1_size;
            dim2_size=p_dim2_size;
            dim3_size=p_dim3_size;

            init();
        }

        virtual ~CDynamicArray() {}

        inline int32_t set_granularity(int32_t g)
        {
            return m_array.set_granularity(g);
        }

        inline int32_t get_array_size()
        {
            return m_array.get_array_size();
        }

        inline void get_array_size(int32_t& dim1, int32_t& dim2)
        {
            dim1=dim1_size;
            dim2=dim2_size;
        }

        inline void get_array_size(int32_t& dim1, int32_t& dim2, int32_t& dim3)
        {
            dim1=dim1_size;
            dim2=dim2_size;
            dim3=dim3_size;
        }

        inline int32_t get_dim1() { return dim1_size; }

        inline int32_t get_dim2() { return dim2_size; }

        inline int32_t get_dim3() { return dim3_size; }

        inline int32_t get_num_elements() const
        {
            return m_array.get_num_elements();
        }

        inline const T& get_element(int32_t idx1, int32_t idx2=0, int32_t idx3=0) const
        {
            return m_array.get_array()[idx1+dim1_size*(idx2+dim2_size*idx3)];
        }

        inline const T& element(int32_t idx1, int32_t idx2=0, int32_t idx3=0) const
        {
            return get_element(idx1, idx2, idx3);
        }

        inline T& element(int32_t idx1, int32_t idx2=0, int32_t idx3=0)
        {
            return m_array.get_array()[idx1+dim1_size*(idx2+dim2_size*idx3)];
        }

        inline T& element(T* p_array, int32_t idx1, int32_t idx2=0, int32_t idx3=0)
        {
            ASSERT(idx1>=0 && idx1<dim1_size)
            ASSERT(idx2>=0 && idx2<dim2_size)
            ASSERT(idx3>=0 && idx3<dim3_size)
            return p_array[idx1+dim1_size*(idx2+dim2_size*idx3)];
        }

        inline T& element(T* p_array, int32_t idx1, int32_t idx2, int32_t idx3, int32_t p_dim1_size, int32_t p_dim2_size)
        {
            ASSERT(p_dim1_size==dim1_size)
            ASSERT(p_dim2_size==dim2_size)
            ASSERT(idx1>=0 && idx1<p_dim1_size)
            ASSERT(idx2>=0 && idx2<p_dim2_size)
            ASSERT(idx3>=0 && idx3<dim3_size)
            return p_array[idx1+p_dim1_size*(idx2+p_dim2_size*idx3)];
        }

        inline T get_last_element() const
        {
            return m_array.get_last_element();
        }

        inline T get_element_safe(int32_t index) const
        {
            return m_array.get_element_safe(index);
        }

        inline bool set_element(T e, int32_t idx1, int32_t idx2=0, int32_t idx3=0)
        {
            return m_array.set_element(e, idx1+dim1_size*(idx2+dim2_size*idx3));
        }

        inline bool insert_element(T e, int32_t index)
        {
            return m_array.insert_element(e, index);
        }

        inline bool append_element(T e)
        {
            return m_array.append_element(e);
        }

        inline void push_back(T e)
        { m_array.push_back(e); }

        inline void pop_back()
        {
            m_array.pop_back();
        }

        inline T back()
        {
            return m_array.back();
        }

        inline int32_t find_element(T e)
        {
            return m_array.find_element(e);
        }

        inline bool delete_element(int32_t idx)
        {
            return m_array.delete_element(idx);
        }

        inline bool resize_array(int32_t ndim1, int32_t ndim2=1, int32_t ndim3=1)
        {
            dim1_size=ndim1;
            dim2_size=ndim2;
            dim3_size=ndim3;
            return m_array.resize_array(ndim1*ndim2*ndim3);
        }

        void set_const(const T& const_element)
        {
            m_array.set_const(const_element);
        }

        inline T* get_array() const
        {
            return m_array.get_array();
        }

        inline void set_array(T* p_array, int32_t p_num_elements,
                              int32_t array_size)
        {
            m_array.set_array(p_array, p_num_elements, array_size);
        }

        inline void set_array(T* p_array, int32_t dim1,
                        bool p_free_array, bool copy_array)
        {
            dim1_size=dim1;
            dim2_size=1;
            dim3_size=1;
            m_array.set_array(p_array, dim1, dim1, p_free_array, copy_array);
        }

        inline void set_array(T* p_array, int32_t dim1,
                        int32_t dim2, bool p_free_array, bool copy_array)
        {
            dim1_size=dim1;
            dim2_size=dim2;
            dim3_size=1;

            m_array.set_array(p_array, dim1*dim2, dim1*dim2, p_free_array, copy_array);
        }

        inline void set_array(T* p_array, int32_t dim1,
                        int32_t dim2, int32_t dim3, bool p_free_array, bool copy_array)
        {
            dim1_size=dim1;
            dim2_size=dim2;
            dim3_size=dim3;
            m_array.set_array(p_array, dim1*dim2*dim3, dim1*dim2*dim3, p_free_array, copy_array);
        }

        inline void set_array(const T* p_array, int32_t p_size)
        {
            m_array.set_array(p_array, p_size, p_size);
        }

        inline void clear_array(T value)
        {
            m_array.clear_array(value);
        }

        inline void reset_array()
        {
            m_array.reset((T) 0);
        }

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

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

        inline CDynamicArray<T>& operator=(CDynamicArray<T>& orig)
        {
            m_array=orig.m_array;
            dim1_size=orig.dim1_size;
            dim2_size=orig.dim2_size;
            dim3_size=orig.dim3_size;

            return *this;
        }

        inline void shuffle() { m_array.shuffle(); }

        inline void shuffle(CRandom * rand) { m_array.shuffle(rand); }

        inline void set_array_name(const char* p_name)
        {
            name=p_name;
        }

        inline const char* get_array_name() const { return name; }

        inline void display_array()
        {
            if (get_name())
                SG_PRINT("DynamicArray '%s' of size: %dx%dx%d\n", get_name(), dim1_size, dim2_size, dim3_size)
            else
                SG_PRINT("DynamicArray of size: %dx%dx%d\n",dim1_size, dim2_size, dim3_size)

            for (int32_t k=0; k<dim3_size; k++)
                for (int32_t i=0; i<dim1_size; i++)
                {
                    SG_PRINT("element(%d,:,%d) = [ ",i, k)
                    for (int32_t j=0; j<dim2_size; j++)
                        SG_PRINT("%1.1f,", (float32_t) element(i,j,k))
                    SG_PRINT(" ]\n")
                }
        }

        inline void display_size()
        {
            SG_PRINT("DynamicArray of size: %dx%dx%d\n",dim1_size, dim2_size, dim3_size)
        }

        virtual const char* get_name() const
        {
            return "DynamicArray";
        }

        virtual void load_serializable_pre() throw (ShogunException)
        {
            CSGObject::load_serializable_pre();

            m_array.resize_array(m_array.get_num_elements(), true);
        }

        virtual void save_serializable_pre() throw (ShogunException)
        {
            CSGObject::save_serializable_pre();
            m_array.resize_array(m_array.get_num_elements(), true);
        }


    private:

        virtual void init()
        {
            set_generic<T>();

            m_parameters->add_vector(&m_array.array,
                    &m_array.current_num_elements, "array",
                    "Memory for dynamic array.");
            SG_ADD(&m_array.num_elements,
                              "num_elements",
                              "Number of Elements.", MS_NOT_AVAILABLE);
            SG_ADD(&m_array.resize_granularity,
                              "resize_granularity",
                              "shrink/grow step size.", MS_NOT_AVAILABLE);
            SG_ADD(&m_array.use_sg_mallocs,
                              "use_sg_malloc",
                              "whether SG_MALLOC or malloc should be used",
                              MS_NOT_AVAILABLE);
            SG_ADD(&m_array.free_array,
                              "free_array",
                              "whether array must be freed",
                              MS_NOT_AVAILABLE);
        }

    protected:

        DynArray<T> m_array;

        int32_t dim1_size;

        int32_t dim2_size;

        int32_t dim3_size;

        const char* name;
};
}
#endif /* _DYNAMIC_ARRAY_H_  */