Array.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, Gunnar Raetsch, Andre Noll
 * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef _ARRAY_H_
#define _ARRAY_H_

//#define ARRAY_STATISTICS

//#define ARRAY_ASSERT(x) {if ((x)==0) {*((int*)0)=0;}}
//#define ARRAY_ASSERT(x) ASSERT(x)
#define ARRAY_ASSERT(x)

#include "lib/common.h"
#include "base/SGObject.h"

namespace shogun
{
#ifdef ARRAY_STATISTICS
struct array_statistics {
    int32_t const_element;
    int32_t element;
    int32_t set_element;
    int32_t get_element;
    int32_t operator_overload;
    int32_t const_operator_overload;
    int32_t set_array;
    int32_t get_array;
    int32_t resize_array;
    int32_t array_element;
};

#define DECLARE_ARRAY_STATISTICS struct array_statistics as
#define INIT_ARRAY_STATISTICS memset(&as, 0, sizeof(as))
#define PRINT_ARRAY_STATISTICS \
    SG_DEBUG("access statistics:\n" \
            "const element    %i\n" \
            "element    %i\n" \
            "set_element    %i\n" \
            "get_element    %i\n" \
            "operator_overload[]    %i\n" \
            "const_operator_overload[]    %i\n" \
            "set_array    %i\n" \
            "get_array    %i\n" \
            "resize_array    %i\n" \
            "array_element    %i\n", \
            as.const_element, \
            as.element, \
            as.set_element, \
            as.get_element, \
            as.operator_overload, \
            as.const_operator_overload, \
            as.set_array, \
            as.get_array, \
            as.resize_array, \
            as.array_element \
);

#define INCREMENT_ARRAY_STATISTICS_VALUE(_val_) ((CArray<T>*)this)->as._val_++

#else /* ARRAY_STATISTICS */
#define DECLARE_ARRAY_STATISTICS
#define INIT_ARRAY_STATISTICS
#define PRINT_ARRAY_STATISTICS
#define INCREMENT_ARRAY_STATISTICS_VALUE(_val_)
#endif /* ARRAY_STATISTICS */

template <class T> class CArray : public CSGObject
{
    public:
        CArray(int32_t initial_size = 1)
        : CSGObject(), free_array(true), name("Array")
        {
            INIT_ARRAY_STATISTICS;
            array_size = initial_size;
            array = (T*) calloc(array_size, sizeof(T));
            ARRAY_ASSERT(array);
        }

        CArray(T* p_array, int32_t p_array_size, bool p_free_array=true,
            bool p_copy_array=false)
        : CSGObject(), array(NULL), free_array(false), name("Array")
        {
            INIT_ARRAY_STATISTICS;
            set_array(p_array, p_array_size, p_free_array, p_copy_array);
        }

        CArray(const T* p_array, int32_t p_array_size)
        : CSGObject(), array(NULL), free_array(false), name("Array")
        {
            INIT_ARRAY_STATISTICS;
            set_array(p_array, p_array_size);
        }

        virtual ~CArray()
        {
            //SG_DEBUG( "destroying CArray array '%s' of size %i\n", name? name : "unnamed", array_size);
            PRINT_ARRAY_STATISTICS;
            if (free_array)
                free(array);
        }

        inline virtual const char* get_name() const { return name; }

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

        inline int32_t get_array_size() const
        {
            return array_size;
        }

        inline int32_t get_dim1()
        {
            return array_size;
        }

        inline void zero()
        {
            for (int32_t i=0; i< array_size; i++)
                array[i]=0;
        }

        inline void set_const(T const_elem)
        {
            for (int32_t i=0; i< array_size; i++)
                array[i]=const_elem ;
        }

        inline const T& get_element(int32_t index) const
        {
            ARRAY_ASSERT(array && (index>=0) && (index<array_size));
            INCREMENT_ARRAY_STATISTICS_VALUE(get_element);
            return array[index];
        }

        inline bool set_element(const T& p_element, int32_t index)
        {
            ARRAY_ASSERT(array && (index>=0) && (index<array_size));
            INCREMENT_ARRAY_STATISTICS_VALUE(set_element);
            array[index]=p_element;
            return true;
        }

        inline const T& element(int32_t idx1) const
        {
            INCREMENT_ARRAY_STATISTICS_VALUE(const_element);
            return get_element(idx1);
        }

        inline T& element(int32_t index)
        {
            ARRAY_ASSERT(array);
            ARRAY_ASSERT(index>=0);
            ARRAY_ASSERT(index<array_size);
            INCREMENT_ARRAY_STATISTICS_VALUE(element);
            return array[index];
        }

        inline T& element(T* p_array, int32_t index)
        {
            ARRAY_ASSERT(array && (index>=0) && (index<array_size));
            ARRAY_ASSERT(array == p_array);
            INCREMENT_ARRAY_STATISTICS_VALUE(array_element);
            return p_array[index];
        }

        bool resize_array(int32_t n)
        {
            INCREMENT_ARRAY_STATISTICS_VALUE(resize_array);
            ARRAY_ASSERT(free_array);

            T* p= (T*) realloc(array, sizeof(T)*n);
            if (!p)
                return false;
            array=p;
            if (n > array_size)
                memset(&array[array_size], 0, (n-array_size)*sizeof(T));
            array_size=n;
            return true;
        }

        inline T* get_array()
        {
            INCREMENT_ARRAY_STATISTICS_VALUE(get_array);
            return array;
        }

        inline void set_array(T* p_array, int32_t p_array_size, bool p_free_array=true,
                bool copy_array=false)
        {
            INCREMENT_ARRAY_STATISTICS_VALUE(set_array);
            if (this->free_array)
                free(this->array);
            if (copy_array)
            {
                this->array=(T*)malloc(p_array_size*sizeof(T));
                memcpy(this->array, p_array, p_array_size*sizeof(T));
            }
            else
                this->array=p_array;
            this->array_size=p_array_size;
            this->free_array=p_free_array;
        }

        inline void set_array(const T* p_array, int32_t p_array_size)
        {
            INCREMENT_ARRAY_STATISTICS_VALUE(set_array);
            free(this->array);
            this->array=(T*)malloc(p_array_size*sizeof(T));
            memcpy(this->array, p_array, p_array_size*sizeof(T));
            this->array_size=p_array_size;
            this->free_array=true;
        }

        inline void clear_array()
        {
            memset(array, 0, array_size*sizeof(T));
        }


        inline const T& operator[](int32_t index) const
        {
            INCREMENT_ARRAY_STATISTICS_VALUE(const_operator_overload);
            return array[index];
        }

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

        CArray<T>& operator=(const CArray<T>& orig)
        {
            memcpy(array, orig.array, sizeof(T)*orig.array_size);
            array_size=orig.array_size;

            return *this;
        }

        void display_size() const
        {
            SG_PRINT( "Array '%s' of size: %d\n", name? name : "unnamed",
                    array_size);
        }

        void display_array() const
        {
            display_size();
            for (int32_t i=0; i<array_size; i++)
                SG_PRINT("%1.1f,", (float32_t)array[i]);
            SG_PRINT("\n");
        }

    protected:
        T* array;
        int32_t array_size;
        bool free_array;
        const char* name;
        DECLARE_ARRAY_STATISTICS;

};
}
#endif /* _ARRAY_H_ */