m_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, Kyle Simek, Andrew Predoehl.                        |
 |                                                                          |
 | For use outside the University of Arizona Computer Vision group please   |
 | contact Kobus Barnard.                                                   |
 |                                                                          |
 * ======================================================================== */

/* $Id: m_vector.h 18301 2014-11-26 19:17:13Z ksimek $ */

#ifndef VECTOR_WRAP_H
#define VECTOR_WRAP_H

#include "m/m_vector.h"
#include "m/m_vec_norm.h"
#include "m/m_vec_metric.h"
#include "m_cpp/m_serialization.h"
#include "l_cpp/l_exception.h"

#include <algorithm>
#include <iterator>
#include <vector>

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

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

namespace kjb {

class Matrix;
class Vector;
class Int_vector;

class Index_range;

template <class V>
class Generic_vector_view;

typedef Generic_vector_view<Vector> Vector_view;
typedef const Generic_vector_view<const Vector> Const_vector_view;

template <class T>
class Generic_matrix_view;

class 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 double          Value_type; 
    typedef kjb_c::Vector   Impl_type;  
    typedef Matrix          Mat_type;   
    typedef Generic_matrix_view<Matrix> Mat_view_type;   
    typedef Vector          Vec_type;   
    typedef Value_type (*Mapper)(Value_type);   

    // Below are typdefs required to adhere to the stl Container concept
    typedef double          value_type;
    typedef double*         pointer;
    typedef const double*   const_pointer;
    typedef double&         reference;
    typedef double          const_reference;
//    typedef __gnu_cxx::__normal_iterator<value_type*, Vector> iterator;
//    typedef __gnu_cxx::__normal_iterator<const value_type*, 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;

    static const char* const BAD_SEGMENT;

    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 Vector(int length = 0)
        : m_vector(0)
    {
        // Test program was HERE.
        ETX( kjb_c::get_target_vector(&m_vector, length) );
    }

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

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

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

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

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

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

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

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

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

    Vector( const Int_vector& );

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

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

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

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

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

    Vector(const std::vector<double>& src);

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

    explicit Vector(Value_type val)
        : m_vector(0)
    {
        // Test program was HERE.
        ETX( kjb_c::get_initialized_vector(&m_vector, 1, val) );
    }

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

    Vector (const Vector_view& view);

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

    Vector (const Const_vector_view& view);

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

    Vector(Value_type val1, Value_type val2)
        : m_vector(0)
    {
        // Test program was HERE.
        ETX( kjb_c::get_target_vector(&m_vector, 2) );
        m_vector->elements[0] = val1;
        m_vector->elements[1] = val2;
    }

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

    Vector(Value_type val1, Value_type val2, Value_type val3)
        : m_vector(0)
    {
        // Test program was HERE.
        ETX( kjb_c::get_target_vector(&m_vector, 3) );
        m_vector->elements[0] = val1;
        m_vector->elements[1] = val2;
        m_vector->elements[2] = val3;
    }

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

    Vector(Value_type val1, Value_type val2, Value_type val3, Value_type val4)
        : m_vector(0)
    {
        // Test program was HERE.
        ETX( kjb_c::get_target_vector(&m_vector, 4) );
        m_vector->elements[0] = val1;
        m_vector->elements[1] = val2;
        m_vector->elements[2] = val3;
        m_vector->elements[3] = val4;
    }

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

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

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

    explicit Vector(const Mat_type& src);

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

    explicit Vector(const Mat_view_type& src);

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

    Vector(const std::string& file_name);

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

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

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

#ifdef KJB_HAVE_CXX11

    Vector(Vector&& vec_ref)
        : m_vector( nullptr )
    {
        m_vector = vec_ref.m_vector;
        vec_ref.m_vector = 0;
    }
#endif /* KJB_HAVE_CXX11 */

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

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

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

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


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

    ~Vector()
    {
        // Test program was HERE.
        kjb_c::free_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);
    }
    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */

    Vector& randomize(int length)
    {
        // Test program was HERE.
        ETX( kjb_c::get_random_vector(&m_vector, length) );
        return *this;
    }

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

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

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

     //* @brief  Clone of randomize(int)
     //* @deprecated The name is misleading -- do not use in new code.
     //*/
    //Vector& init_random( int length )
    //{
        //return randomize( length );
    //}

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

    Vector& zero_out(int length)
    {
        // Test program was HERE.
        ETX( kjb_c::get_zero_vector(&m_vector, length) );
        return *this;
    }

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

    Vector& zero_out()
    {
        // Test program was HERE.
        return zero_out( get_length() );
    }

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

     //* @brief  Clone of zero_out(int)
     //* @deprecated The name is misleading -- do not use in new code.
     //*/
    //Vector& init_zero( int length )
    //{
        //return zero_out( length );
    //}

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

    Vector& set(Value_type val)
    {
        get_target_vector(&m_vector, 1);
        this->operator[](0) = val;

        return *this;
    }

    Vector& set(Value_type val1, Value_type val2)
    {
        get_target_vector(&m_vector, 2);
        this->operator[](0) = val1;
        this->operator[](1) = val2;

        return *this;
    }

    Vector& set(Value_type val1, Value_type val2, Value_type val3)
    {
        get_target_vector(&m_vector, 3);
        this->operator[](0) = val1;
        this->operator[](1) = val2;
        this->operator[](2) = val3;

        return *this;
    }

    Vector& set(Value_type val1, Value_type val2, Value_type val3, Value_type val4)
    {
        get_target_vector(&m_vector, 4);
        this->operator[](0) = val1;
        this->operator[](1) = val2;
        this->operator[](2) = val3;
        this->operator[](3) = val4;

        return *this;
    }

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

    Vector& operator=(const Mat_view_type& vec_ref);

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

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

#ifdef KJB_HAVE_CXX11

    Vector& operator=(Vector&& other)
    {
        if(this == &other)
            return *this;

        kjb_c::free_vector( m_vector );
        m_vector = other.m_vector;
        other.m_vector = 0;
        return *this;
    }
#endif /* KJB_HAVE_CXX11 */

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

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


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

    Vector& replace(const Vector& iv, int offset, int begin, int length);

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

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

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

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

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

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

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

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

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

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

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

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

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

    Vector_view operator[](const Index_range& idx);

    Const_vector_view operator[](const Index_range& idx) const;

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

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

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

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

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

    void assign(size_type N, value_type t);

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

    template<typename InputIterator>
    void assign(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++;
        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_vector_full_precision( m_vector, filename ));
    }

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

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

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */
    void read( const char* filename = 0 )
    {
        // Test program was HERE.
        ETX(kjb_c::read_vector( &m_vector, filename ));
    }

    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  */
    void write( const char* filename = 0 ) const
    {
        // Test program was HERE.
        write_col(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).
     * ------------------------------------------------------------------- */

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

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

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

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

    Vector& ew_multiply(const Vector & op2)
    {
        ETX( kjb_c::ow_multiply_vectors(m_vector, op2.m_vector) );
        return *this;
    }


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

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

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

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

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

    Vector& ew_divide(const Vector & op2)
    {
        ETX( kjb_c::ow_divide_vectors(m_vector, op2.m_vector) );
        return *this;
    }

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

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

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

    Vector& operator+= (double x);;

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

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

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

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

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

    Vector& operator-= (double x);

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

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

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

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

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

    Vec_type& mapcar( Mapper );

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

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

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

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

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

    double get_max_abs_difference(const Vector & op2) const;

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



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

    kjb::Matrix hat() const;

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

    Vector& cross_with(const Vector& op2);

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

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

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

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

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

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

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

    Vector& normalize(kjb_c::Norm_method method =kjb_c::NORMALIZE_BY_MAGNITUDE)
    {
        // Test program was HERE.
        kjb_c::normalize_vector(&m_vector, m_vector, method);
        return *this;
    }

    Vector normalized(kjb_c::Norm_method method =kjb_c::NORMALIZE_BY_MAGNITUDE) const
    {
        Vector tmp(*this);
        tmp.normalize(method);
        return tmp;
    }

private:
    template <class View_type>
    void init_from_view_(const View_type& vec_view);

    template<class Archive>
    void serialize(Archive &ar, const unsigned int version)
    {
        return kjb_serialize(ar, *this, version);
    }

};


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

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

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

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

template<typename InputIterator>
void Vector::insert
(
    iterator        position,
    InputIterator   begin_,
    InputIterator   end_
)
{
    const size_type N = end_ - begin_;
    const size_type offset = position - begin();
    assert(offset <= size());

    m_ensure_capacity(m_vector->length + N);
    position = begin() + offset;

    iterator old_end = this->end();

    m_vector->length += N;

    // corner case: empty vector.  in this case, position=0 is a valid 
    // iterator, but needs to be handled specially.
    if(position == 0 && m_vector->length == N)
    {
        position = m_vector->elements;
    }

    // shift old data
    std::copy(position, old_end, position + N);

    // copy new data
    std::copy(begin_, end_, position);
}

template<typename InputIterator>
void Vector::assign(InputIterator begin_, InputIterator end_)
{
    resize(0);
    insert(begin(), begin_, end_);
}

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

template <class View_type>
void Vector::init_from_view_(const View_type& vec_view)
{
    Vector result(vec_view.size());
    for( int i = 0; i < vec_view.size(); ++i)
    {
        result[i] = vec_view[i];
    }
    swap( result );
}

/* ---------------------------------------------------------------------
 * "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
Vector create_random_vector(int length)
{
    // Test program was HERE.
    kjb_c::Vector* result = 0;
    ETX( kjb_c::get_random_vector( &result, length ) );
    return Vector(result);
}


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

Vector create_gauss_random_vector(int length);

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

inline
Vector create_zero_vector(int length)
{
    // Test program was HERE.
    return Vector(length, 0.0);
}

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

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

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

/* ---------------------------------------------------------------------
 * ARITHMETIC OPERATORS
 *
 * Non-modifying operators. These were members before, but I think most of us
 * agree that they should be non-members. The only members are the
 * modifying operators, such as +=, *=, /=, etc.
 * ------------------------------------------------------------------- */

Vector operator*(const Vector& op1, const Matrix& op2);

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

Vector operator*( const Matrix& op1, const Vector& op2 );

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

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

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

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

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

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

}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* ---------------------------------------------------------------------
 * ORDERING OPERATORS
 * These seem silly, but they're required to comply with the 
 * stl "Forward container" concept. [I can easily think of
 * situations where this is necessary. Silly? I think not!]
 * ------------------------------------------------------------------- */

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

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

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

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

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

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

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

std::ostream& stream_write_vector(std::ostream& ost, const Vector& m);

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

std::istream& stream_read_vector(std::istream& ist, Vector& m);


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

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

inline
Vector::Value_type max_abs_difference( const Vector& op1, const 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_vector_difference( op1.get_c_vector(), op2.get_c_vector() );
}

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

inline
Vector::Value_type dot(const Vector& op1, const Vector& op2)
{
    // Test program was HERE.
    Vector::Value_type result;
    ETX( kjb_c::get_dot_product(op1.get_c_vector(), op2.get_c_vector(), &result) );
    return result;
}

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

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

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

inline
double norm1(const Vector& op)
{
    double total = 0;

    for(Vector::const_iterator it = op.begin(); it != op.end(); ++it)
        total += fabs(*it);

    return total;
}

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

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

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

inline
double vector_distance(const Vector& op1, const Vector& op2)
{
    return kjb_c::vector_distance(op1.get_c_vector(), op2.get_c_vector());
}

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

inline
double vector_distance_squared(const Vector& op1, const Vector& op2)
{
    return kjb_c::vector_distance_sqrd(op1.get_c_vector(), op2.get_c_vector());
}

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

inline
Vector::Value_type max(const Vector& vec)
{
    // Test program was HERE.
    return kjb_c::max_vector_element(vec.get_c_vector());
}

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

inline
Vector::Value_type min(const Vector& vec)
{
    // Test program was HERE.
    return kjb_c::min_vector_element(vec.get_c_vector());
}

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

inline Vector cat_vectors(const Vector& first, const Vector& second)
{
    Vector result = first;
    result.resize(first.size() + second.size());
    std::copy(second.begin(), second.end(), result.begin() + first.size());
    return result;
}

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

template<class InputIterator>
Vector cat_vectors(InputIterator first, InputIterator last)
{
    int size = 0;

    for(InputIterator p = first; p != last; p++)
    {
        size += p->get_length();
    }

    Vector ret(size);

    size = 0;
    for(InputIterator p = first; p != last; p++)
    {
        for(int i = 0; i < p->get_length(); i++)
        {
            ret[size + i] = (*p)[i];
        }
        size += p->get_length();
    }

    return ret;
}

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

template<class OutputIterator>
OutputIterator separate_vector(const Vector& vec, int sz, OutputIterator result)
{
    int n = vec.get_length() / sz;

    if(n == 0)
    {
        KJB_THROW_2(Illegal_argument, "separate_vectors: cannot desired vector size is too large.");
    }

    for(int i = 0; i < n; i++)
    {
        *result++ = create_vector_from_vector_section(vec, i * sz, sz);
    }

    return result;
}

std::vector<Vector> get_transpose(const std::vector<Vector>& m);

Int_vector floor( const Vector& realv );

/*
 * @brief generates a Vector of uniformly spaced points along a vector (including endpoints)
 * Ideally it should be matlab's "linspace"
 * @param  double a - start point, double b - end point, double n - number of points
 * @author Josh Bowdish
 */
kjb::Vector create_uniformly_spaced_vector(double a,double b, unsigned n);


inline void swap(Vector& v1, Vector& v2) { v1.swap(v2); }

} 

//namespace kjb


#endif /*VECTOR_WRAP_H */