l_int_vector.h

Go to the documentation of this file.

/* ======================================================================== *
 |                                                                          |
 | Copyright (c) 2007-2010, by members of University of Arizona Computer    |
 | Vision group (the authors) including                                     |
 |       Kobus Barnard, Luca Del Pero, Kyle Simek, Andrew Predoehl.         |
 |                                                                          |
 | For use outside the University of Arizona Computer Vision group please   |
 | contact Kobus Barnard.                                                   |
 |                                                                          |
 * ======================================================================== */

/* $Id: l_int_vector.h 18278 2014-11-25 01:42:10Z ksimek $ */

#ifndef L_CPP_INT_VECTOR_WRAP_H
#define L_CPP_INT_VECTOR_WRAP_H

#include "l/l_debug.h"
#include "l/l_int_vector.h"
#include "l/l_sys_io.h"
#include "l/l_sys_lib.h"

#include "l_cpp/l_util.h"
#include "l_cpp/l_exception.h"
#include <vector>


#ifdef KJB_HAVE_BST_SERIAL
#include <boost/serialization/access.hpp>
#endif

#include <boost/concept_check.hpp>


// forward declarations
namespace boost {
namespace archive {
    class text_iarchive;
    class text_oarchive;
} // namespace archive
} // namespace boost

namespace kjb {

class Int_matrix;

class Int_vector
{
#ifdef KJB_HAVE_BST_SERIAL
    friend class boost::serialization::access;
#endif

public:


    /* Class users:  to make your code as maintanable as possible, use the
     * *_type typedefs below instead of directly referencing the specific
     * type.
     */

    typedef int                 Value_type; 
    typedef kjb_c::Int_vector   Impl_type;  
    typedef Int_matrix          Mat_type;   
    typedef Int_vector          Vec_type;   
    typedef Value_type (*Mapper)(Value_type);   

    // Below are typdefs required to adhere to the stl Container concept
    typedef int             value_type;
    typedef int*            pointer;
    typedef const int*      const_pointer;
    typedef int&            reference;
    typedef int           const_reference;
    //typedef __gnu_cxx::__normal_iterator<value_type*, Int_vector> iterator;
    //typedef __gnu_cxx::__normal_iterator<const value_type*, Int_vector> 
    //    const_iterator;
    typedef value_type* iterator;
    typedef const value_type* const_iterator;
    typedef std::reverse_iterator<iterator>       reverse_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator; 
    typedef int             size_type;
    typedef int             difference_type;


private:
    Impl_type* m_vector;



    void throw_bad_bounds( int ) const;

    void m_ensure_capacity(size_type c);

    template<typename InputIterator_>
    void m_initialize_dispatch(InputIterator_ begin_,
                InputIterator_ end_, std::input_iterator_tag);

    template<typename ForwardIterator_>
    void m_initialize_dispatch(ForwardIterator_ begin_, ForwardIterator_ end_, std::forward_iterator_tag)
    {
        const size_type n = std::distance(begin_, end_);
        m_ensure_capacity(n);
        
        m_vector->length = n;

        std::copy(begin_, end_, this->begin());
    }
public:

    /* -------------------------------------------------------------------
     * CONSTRUCTORS
     * ------------------------------------------------------------------- */

    explicit Int_vector(int length = 0)
        : m_vector(0)
    {
        // Test program was HERE.
        ETX( kjb_c::get_target_int_vector(&m_vector, length) );
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    explicit Int_vector(unsigned length)
        : m_vector(0)
    {
        // Test program was HERE.
        ETX( kjb_c::get_target_int_vector(&m_vector, static_cast<int>(length)) );
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    explicit Int_vector(unsigned long length)
        : m_vector(0)
    {
        // Test program was HERE.
        ETX( kjb_c::get_target_int_vector(&m_vector, static_cast<int>(length)) );
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Int_vector(int length, Value_type num)
        : m_vector(0)
    {
        // Test program was HERE.
        ETX( kjb_c::get_initialized_int_vector(&m_vector, length, num) );
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Int_vector(int length, const Value_type* data)
        : m_vector(0)
    {
        // Test program was HERE.
        ETX( kjb_c::get_target_int_vector(&m_vector, length) );
        std::copy( data, data + length, m_vector -> elements );
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */


    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */


    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Int_vector(Impl_type* vec_ptr)
        : m_vector( vec_ptr )
    {
        if ( 0 == vec_ptr )
        {
            // Test program was HERE.
            ETX( kjb_c::get_target_int_vector(&m_vector, 0) );
        }
        //else
        //{
        //    // Test program was HERE.
        //}
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Int_vector(const std::vector<int>& src)
        : m_vector( NULL )
    {
        Int_vector result(src.begin(), src.end());
        swap(result);
    }


    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    explicit Int_vector(const Impl_type& vec_ref)
        : m_vector(0)
    {
        // Test program was HERE.
        ETX( kjb_c::copy_int_vector(&m_vector, &vec_ref) );
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    explicit Int_vector(const Mat_type& src);

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Int_vector(const std::string& file_name);

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Int_vector( const Int_vector& vec_ref )
        : m_vector(0)
    {
        // Test program was HERE.
        ETX( kjb_c::copy_int_vector(&m_vector, vec_ref.m_vector) );
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    /* ---------------------------------------------------------------------
     * "STL CONSTRUCTORS"
     *
     * These constructors are required for compliance with STL's 
     * "Sequence" concept
     *
     * ------------------------------------------------------------------- */

    template<typename InputIterator_>
    Int_vector(InputIterator_ begin_, InputIterator_ end_)
        : m_vector(0)
    {
        ETX( kjb_c::get_target_int_vector(&m_vector, 8) );
        m_vector->length = 0;

        typedef typename std::iterator_traits<InputIterator_>::
            iterator_category IterCategory_;
        m_initialize_dispatch(begin_, end_, IterCategory_());
    }


    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    ~Int_vector()
    {
        // Test program was HERE.
        kjb_c::free_int_vector(m_vector);
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    int get_length() const
    {
        // Test program was HERE.
        return m_vector -> length;
    }

    size_type size() const
    {
        return get_length();
    }

    size_type max_size() const
    {
        return INT_MAX;
    }

    bool empty() const
    {
        return size() == 0;
    }

  // iterators
    iterator begin()
    {
        return iterator(m_vector->elements);
    }

    const_iterator begin() const
    {
        return const_iterator(m_vector->elements);
    }

    iterator end()
    {
        return iterator(m_vector->elements + m_vector->length);
    }

    const_iterator end() const
    {
        return const_iterator(m_vector->elements + m_vector->length);
    }

    reverse_iterator rbegin()
    {
        return reverse_iterator(end());
    }

    const_reverse_iterator rbegin() const
    {
        return const_reverse_iterator(end());
    }

    reverse_iterator rend()
    {
        return reverse_iterator(begin());
    }

    const_reverse_iterator rend() const
    {
        return const_reverse_iterator(begin());
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    void reserve(int capacity)
    {
        m_ensure_capacity(capacity);
    }
    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Int_vector& randomize(int length);

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Int_vector& randomize()
    {
        // Test program was HERE.
        return randomize( get_length() );
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */


    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */


    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */


    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */


    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */


    /* -------------------------------------------------------------------
     * ASSIGNMENT OPERATORS
     * ------------------------------------------------------------------- */

    Int_vector& operator=(const Impl_type& vec_ref)
    {
        if ( m_vector != &vec_ref )
        {
            // Test program was HERE.
            ETX( kjb_c::copy_int_vector(&m_vector, &vec_ref) );
        }
        //else
        //{
        //    // Test program was HERE.
        //}
        return *this;
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Int_vector& operator=(const Int_vector& src)
    {
        // Test program was HERE.
        // call assignment operator for kjb_c::Int_vector
        return operator=( *src.m_vector );
    }


    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */


    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    const Impl_type* get_c_vector() const
    {
        // Test program was HERE.
        return m_vector;
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Impl_type* get_underlying_representation_with_guilt()
    {
        // Test program was HERE.
        return m_vector;
    }
    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    void swap( Int_vector& other )
    {
        // Test program was HERE.
        std::swap( m_vector, other.m_vector );
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Int_vector& resize(int new_length, Value_type pad = Value_type(0) );

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Value_type& operator[](int i)
    {
        // Test program was HERE.
        return m_vector -> elements[ i ];
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Value_type operator[](int i) const
    {
        // Test program was HERE.
        return m_vector -> elements[ i ];
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Value_type& operator()(int i)
    {
        // Test program was HERE.
        return operator[]( i );
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Value_type operator()(int i) const
    {
        // Test program was HERE.
        return operator[]( i );
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    void check_bounds( int i ) const
    {
        // Test program was HERE.
        if ( i < 0 || get_length() <= i )
        {
            throw_bad_bounds( i );
        }
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Value_type& at( int i )
    {
        // Test program was HERE.
        check_bounds( i );
        return operator[]( i );
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Value_type at( int i ) const
    {
        // Test program was HERE.
        check_bounds( i );
        return operator[]( i );
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    iterator insert(iterator position, value_type t);

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    void insert(iterator position, size_type N, value_type t);

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    template<typename InputIterator>
    void insert(iterator position, InputIterator begin_, InputIterator end_);

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    iterator erase(iterator position);

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    void erase(iterator begin_, iterator end_);

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    void clear()
    {
        m_vector->length = 0;
    }


    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */
    reference front()
    {
        return operator[](0);
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    const_reference front() const
    {
        return operator[](0);
    }
    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    reference back()
    {
        return operator[](size() - 1);
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    const_reference back() const
    {
        return operator[](size() - 1);
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    void push_back(Value_type x)
    {
        m_ensure_capacity(m_vector->length + 1);

        m_vector->length++;
        KJB(ASSERT(m_vector->length <= m_vector->max_length));
        m_vector->elements[m_vector->length - 1] = x;
    }

    void pop_back()
    {
        m_vector->length--;
    }

    void write_row( const char* filename = 0 ) const
    {
        // Test program was HERE.
        ETX(kjb_c::write_row_int_vector( m_vector, filename ));
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    void write_col( const char* filename = 0 ) const
    {
        // Test program was HERE.
        ETX(kjb_c::write_col_int_vector_with_header( m_vector, filename ));
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    void write( const char* filename = 0 ) const
    {
        // Test program was HERE.
        write_row( filename );
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    /* ---------------------------------------------------------------------
     * ARITHMETIC OPERATORS
     *
     * Modifying operators; i.e., operators that modify the object. These
     * are member functions, as per the standard implementation. Operators
     * that do not modify the vector are non-members. Also, their corresponding
     * named methods (subtract, add, etc).
     * ------------------------------------------------------------------- */

    Int_vector& operator*= (Value_type op2)
    {
        // Test program was HERE.
        ETX( kjb_c::ow_multiply_int_vector_by_int_scalar(m_vector, op2) );
        return *this;
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Int_vector& multiply(Value_type op2)
    {
        // Test program was HERE.
        return operator*=( op2 );
    }


    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Int_vector& operator/= (Value_type op2);

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Int_vector& divide (Value_type op2)
    {
        // Test program was HERE.
        return operator/=( op2 );
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Int_vector& operator+= (const Int_vector& op2)
    {
        // Test program was HERE.
        ETX( kjb_c::ow_add_int_vectors(m_vector, op2.m_vector) );
        return *this;
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Int_vector& add (const Int_vector& op2)
    {
        // Test program was HERE.
        return operator+=( op2 );
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Int_vector& operator-= (const Int_vector& op2)
    {
        // Test program was HERE.
        ETX( kjb_c::ow_subtract_int_vectors(m_vector, op2.m_vector) );
        return *this;
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Int_vector& subtract (const Int_vector& op2)
    {
        // Test program was HERE.
        return operator-=( op2 );
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Int_vector& negate()
    {
        // Test program was HERE.
        return operator*=( -1 );
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Vec_type& mapcar( Mapper );

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Value_type min() const
    {
        // Test program was HERE.
        return kjb_c::min_int_vector_element(m_vector);
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Value_type min( int* min_index ) const
    {
        if ( 0 == get_length() )
        {
            // Test program was HERE.
            KJB_THROW_2( Result_error,
                                "Int_vector is empty; min is undefined" );
        }
        if ( 0 == min_index )
        {
            // Test program was HERE.
            return min();
        }
        // Test program was HERE.
        Value_type min_val;
        *min_index = kjb_c::get_min_int_vector_element(m_vector, &min_val);
        return min_val;
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Value_type max() const
    {
        // Test program was HERE.
        return kjb_c::max_int_vector_element(m_vector);
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Value_type max( int* max_index ) const
    {
        if ( 0 == get_length() )
        {
            // Test program was HERE.
            KJB_THROW_2( Result_error,
                                "Int_vector is empty; max is undefined" );
        }
        if ( 0 == max_index )
        {
            // Test program was HERE.
            return max();
        }
        // Test program was HERE.
        Value_type max_val;
        *max_index = kjb_c::get_max_int_vector_element(m_vector, &max_val);
        return max_val;
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */



    /* -------------------------------------------------------------------
     * VECTOR-SPECIFIC METHODS
     * ------------------------------------------------------------------- */

    Int_vector& cross_with(const Int_vector& op2);

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    kjb::Int_matrix hat() const;

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    double magnitude() const
    {
        // Test program was HERE.
        return kjb_c::int_vector_magnitude(m_vector);
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    long int magnitude_squared() const
    {
        // Test program was HERE.
        return kjb_c::sum_int_vector_squared_elements(m_vector);
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

private:
    void serialize(boost::archive::text_iarchive &ar, const unsigned int version);
    void serialize(boost::archive::text_oarchive &ar, const unsigned int version);
};

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

/* ---------------------------------------------------------------------
 * TEMPLATE MEMBER FUNCTIONS
 *
 * Template member function definitions go here.
 * ------------------------------------------------------------------- */

template<typename InputIterator_>
void Int_vector::m_initialize_dispatch
(
    InputIterator_          begin_,
    InputIterator_          end_,
    std::input_iterator_tag
)
{
    for(; begin_ != end_; ++begin_)
    {
        push_back(*begin_);
    }
}

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

template<typename InputIterator>
void Int_vector::insert
(
    iterator        position,
    InputIterator   begin_,
    InputIterator   end_
)
{
    const size_type N = end_ - begin_;

    m_ensure_capacity(m_vector->length + N);

    m_vector->length += N;

    reverse_iterator rit;
    for(rit = rbegin(); rit.base() != position; rit++)
    {
        *rit = *rit + N; // 
    }

    iterator dest_it = position; 
    InputIterator src_it = begin_;
    for(; src_it != end_; src_it++)
    {
        *dest_it++ = *src_it;
    }
}

/* ---------------------------------------------------------------------
 * "NAMED CONSTRUCTORS"
 *
 * The "named constructor idiom" is when we use functions to create
 * objects.  The benefit is that the names indicate the purpose of the
 * method.  The following functions act as named constructors.
 * ------------------------------------------------------------------- */

inline
Int_vector create_random_int_vector(int length)
{
    // Test program was HERE.
    Int_vector result( length );
    result.randomize();
    return result;
}

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

inline
Int_vector create_vector_from_vector_section(const Int_vector& iv, int begin, int length)
{
    // Test program was HERE.
    kjb_c::Int_vector* outvec = 0;
    ETX_2( kjb_c::copy_int_vector_section(&outvec,
                       iv.get_c_vector(), begin, length), "Failure in create_vector_from_vector_section : allocation error or bad indices");
    return Int_vector(outvec);
}

/* ---------------------------------------------------------------------
 * ARITHMETIC OPERATORS
 *
 * Modifying operators; i.e., operators that modify the object. These
 * are member functions, as per the standard implementation. Operators
 * that do not modify the vector are non-members. Also, their corresponding
 * named methods (subtract, add, etc).
 * ------------------------------------------------------------------- */

Int_vector operator*(const Int_vector& op1, const Int_matrix& op2);

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\ */

Int_vector operator*( const Int_matrix& op1, const Int_vector& op2 );

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

inline
Int_vector operator* (const Int_vector& op1, Int_vector::Value_type op2)
{
    // Test program was HERE.
    return Int_vector(op1) *= op2;
}

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

inline
Int_vector operator*( Int_vector::Value_type op1, const Int_vector& op2 )
{
    // Test program was HERE.
    return op2 * op1;
}

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

inline
Int_vector operator/(const Int_vector& op1, Int_vector::Value_type op2)
{
    // Test program was HERE.
    return Int_vector(op1) /= op2;
}

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

inline
Int_vector operator+ (const Int_vector& op1, const Int_vector& op2)
{
    // Test program was HERE.
    return Int_vector(op1) += op2;
}

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

inline
Int_vector operator- (const Int_vector& op1, const Int_vector& op2)
{
    // Test program was HERE.
    return Int_vector(op1) -= op2;
}

inline
Int_vector operator- (const Int_vector& op1)
{
    // Test program was HERE.
    return op1 * (-1);
}

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

std::ostream& operator<<(std::ostream& out, const Int_vector& m);

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

/* ---------------------------------------------------------------------
 * COMPARISON OPERATORS
 *
 * Comparison operators (==, !=).
 * ------------------------------------------------------------------- */

bool operator==(const Int_vector& op1, const Int_vector::Impl_type& op2);

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

inline
bool operator==(const Int_vector::Impl_type& op1, const Int_vector& op2)
{
    // Test program was HERE.
    return op2 == op1;
}

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

inline
bool operator!=(const Int_vector& op1, const Int_vector::Impl_type &op2)
{
    // Test program was HERE.
    return !(op1 == op2);
}

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

inline
bool operator!=(const Int_vector::Impl_type& op1, const Int_vector& op2)
{
    // Test program was HERE.
    return op2 != op1;
}

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

inline
bool operator==(const Int_vector& op1, const Int_vector& op2)
{
    // Test program was HERE.
    return op1 == *op2.get_c_vector();
}

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

inline
bool operator!=(const Int_vector& op1, const Int_vector &op2)
{
    // Test program was HERE.
    return op1 != *op2.get_c_vector();
}

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

/* ---------------------------------------------------------------------
 * ORDERING OPERATORS
 * Ordering operators (<, >=, etc).
 * ------------------------------------------------------------------- */

bool operator<(const Int_vector& op1, const Int_vector &op2);

inline
bool operator<=(const Int_vector& op1, const Int_vector& op2)
{
    return (op1 < op2) || (op1 == op2);
}

inline
bool operator>(const Int_vector& op1, const Int_vector& op2)
{
    return !(op1 < op2) && !(op1 == op2); 
}

inline
bool operator>=(const Int_vector& op1, const Int_vector& op2)
{
    return !(op1 < op2);
}

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\ */

/* ---------------------------------------------------------------------
 * OTHER STUFF
 * ------------------------------------------------------------------- */

inline
Int_vector::Value_type max_abs_difference( const Int_vector& op1, const Int_vector& op2 )
{
    if ( op1.get_length() != op2.get_length() )
    {
        // Test program was HERE.
        KJB_THROW( Dimension_mismatch );
    }
    //else
    //{
    //    // Test program was HERE.
    //}
    return kjb_c::max_abs_int_vector_difference( op1.get_c_vector(), op2.get_c_vector() );
}

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

inline
long int dot(const Int_vector& op1, const Int_vector& op2)
{
    // Test program was HERE.
    long int result;
    ETX( kjb_c::get_int_dot_product(op1.get_c_vector(), op2.get_c_vector(), &result) );
    return result;
}

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

Int_vector cross(const Int_vector& op1, const Int_vector& op2);

/* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

inline
double norm2(const Int_vector& op1)
{
    return op1.magnitude();
}

inline
double vector_distance(const Int_vector& op1, const Int_vector& op2)
{
    Int_vector temp = op1 - op2;
    return temp.magnitude();
}

inline
double vector_distance_squared(const Int_vector& op1, const Int_vector& op2)
{
    Int_vector temp = op1 - op2;
    return temp.magnitude_squared();
}

} //namespace

#endif