l_int_matrix.h

Go to the documentation of this file.

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

/* $Id: l_int_matrix.h 18296 2014-11-26 03:09:46Z qtung $ */

#ifndef L_CPP_INT_MATRIX_WRAP_H
#define L_CPP_INT_MATRIX_WRAP_H

#include "l/l_int_matrix.h"
#include "l/l_int_mat_io.h"
#include "l_cpp/l_exception.h"
#include "l_cpp/l_int_vector.h"
#include <vector>
#include <ostream>

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


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


namespace kjb {

class Matrix;

class Int_matrix
{
#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 int                 Size_type;   
    typedef kjb_c::Int_matrix   Impl_type;  
    typedef Int_matrix          Mat_type;   
    typedef Int_vector          Vec_type;   
    typedef Value_type (*Mapper)(Value_type);   

private:

    Impl_type* m_matrix;

    void compute_row_col(
        int  index, 
        int* row,   
        int* col    
    ) const
    {
        // Test program was HERE.
        *row = index / get_num_cols();
        *col = index - *row * get_num_cols();
    }

    void compute_row_col_carefully(
        int  index, 
        int* row,   
        int* col    
    ) const
    {
        if ( 0 == get_num_cols() )
        {
            // Test program was HERE.
            *row = *col = 0;
        }
        else
        {
            // Test program was HERE.
            compute_row_col( index, row, col );
        }
    }

    void throw_bad_bounds( int row_ix, int col_ix ) const;

public:

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

    Int_matrix()
        : m_matrix( 0 )
    {
        // Test program was HERE.
        ETX( kjb_c::get_target_int_matrix( &m_matrix, 0, 0 ) );
    }

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

    Int_matrix(int rows, int cols)
        : m_matrix( 0 )
    {
        // Test program was HERE.
        ETX( kjb_c::get_target_int_matrix( &m_matrix, rows, cols ) );
    }

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

    Int_matrix(unsigned rows, unsigned cols)
        : m_matrix( 0 )
    {
        // Test program was HERE.
        Int_matrix m( static_cast<int>( rows ), static_cast<int>( cols ) );
        swap( m );
    }

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

    Int_matrix(unsigned rows, unsigned cols, Value_type val)
        : m_matrix( 0 )
    {
        // Test program was HERE.
        Int_matrix m( static_cast<int>( rows ), static_cast<int>( cols ), val );
        swap( m );
    }

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

    Int_matrix(unsigned long rows, unsigned long cols)
        : m_matrix( 0 )
    {
        // Test program was HERE.
        Int_matrix m( static_cast<int>( rows ), static_cast<int>( cols ) );
        swap( m );
    }

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

    Int_matrix(unsigned long rows, unsigned long cols, Value_type val)
        : m_matrix( 0 )
    {
        // Test program was HERE.
        Int_matrix m( static_cast<int>( rows ), static_cast<int>( cols ), val );
        swap( m );
    }

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

    Int_matrix(int rows, int cols, Value_type num)
        : m_matrix( 0 )
    {
        // Test program was HERE.
        ETX( kjb_c::get_initialized_int_matrix( &m_matrix, rows, cols, num ) );
    }

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

    Int_matrix(int rows, int cols, const Value_type* data);

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


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

    Int_matrix(Impl_type* mat_ptr)
        : m_matrix( mat_ptr )
    {
        if ( 0 == mat_ptr )
        {
            // Test program was HERE.
            ETX( kjb_c::get_target_int_matrix( &m_matrix, 0, 0 ) );
        }
        //else
        //{
        //    // Test program was HERE.
        //}
    }

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

    explicit Int_matrix(const Impl_type& mat_ref)
        : m_matrix( 0 )
    {
        // Test program was HERE.
        ETX( kjb_c::copy_int_matrix( &m_matrix, &mat_ref ) );
    }

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

    Int_matrix(const std::string& file_name);

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

    Int_matrix(const Int_matrix& mat_ref)
        : m_matrix( 0 )
    {
        // Test program was HERE.
        ETX( kjb_c::copy_int_matrix( &m_matrix, mat_ref.m_matrix ) );
    }

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


    ~Int_matrix()
    {
        // Test program was HERE.
        kjb_c::free_int_matrix( m_matrix );
    }


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


    /* Int_matrix& init_identity( int rank )
    {
        // Test program was HERE.
        ETX( kjb_c::get_int_identity_matrix( &m_matrix, rank ) );
        return *this;
    } */

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


    Int_matrix& zero_out( int num_rows, int num_cols )
    {
        // Test program was HERE.
        ETX( kjb_c::get_zero_int_matrix( &m_matrix, num_rows, num_cols ) );
        return *this;
    }

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

    Int_matrix& zero_out( int rows )
    {
        // Test program was HERE.
        return zero_out( rows, rows );
    }

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

    Int_matrix& zero_out()
    {
        // Test program was HERE.
        return zero_out( get_num_rows(), get_num_cols() );
    }

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

    /* Int_matrix& init_zero(int num_rows, int num_cols)
    {
        // Test program was HERE.
        return zero_out( num_rows, num_cols );
    } */


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


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

    Int_matrix& operator=(const Impl_type& mat_ref)
    {
        if ( m_matrix != &mat_ref )
        {
            // Test program was HERE.
            ETX( kjb_c::copy_int_matrix( &m_matrix, &mat_ref ) );
        }
        //else
        //{
        //    // Test program was HERE.
        //}
        return *this;
    }

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

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


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

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

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

    int get_num_rows() const
    {
        // Test program was HERE.
        return m_matrix -> num_rows;
    }

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

    int get_num_cols() const
    {
        // Test program was HERE.
        return m_matrix -> num_cols;
    }

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

    int get_length() const // rows * cols
    {
        // Test program was HERE.
        return get_num_rows() * get_num_cols();
    }

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

    const Impl_type* get_c_matrix() const
    {
        // Test program was HERE.
        return m_matrix;
    }

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

    Impl_type* get_underlying_representation_with_guilt()
    {
        return m_matrix;
    }

    Value_type** ptr_to_storage_area() const
    {
        if(!m_matrix)
        {
            KJB_THROW_2(KJB_error,"Trying to access an integer matrix that has not been allocated");
        }
        return m_matrix->elements;
    }

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

    Int_matrix& resize(
        int new_rows,
        int new_cols,
        Value_type pad = Value_type(0)
    );

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

    Int_matrix& realloc(
        int new_rows,
        int new_cols)
    {
        ETX(kjb_c::get_target_int_matrix(&m_matrix, new_rows, new_cols));

        return *this;
    }
    /* /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\ */

    Int_matrix transpose()
    {
        // Test program was HERE.
        kjb_c::Int_matrix* result = 0;
        ETX(kjb_c::get_int_transpose( &result, m_matrix ) );
        return Int_matrix(result);
    }

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

    /* (Inverse is not supported for Int_matrix, although with "big integers"
     * one could make a Rational_matrix class, and perform potentially exact
     * inversion.  But would anyone use it?
     */

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

    void check_bounds( int row, int col ) const
    {
        if(     row < 0 || get_num_rows() <= row
            ||  col < 0 || get_num_cols() <= col )
        {
            // Test program was HERE.
            throw_bad_bounds( row, col );
        }
        //else
        //{
        //  // Test program was HERE.
        //}
    }

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

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

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

    Value_type& operator()(int i)
    {
        // Test program was HERE.
        int row, col;
        compute_row_col( i, &row, &col );
        return operator()( row, col );
    }

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

    Value_type operator()(int i) const
    {
        // Test program was HERE.
        int row, col;
        compute_row_col( i, &row, &col );
        return operator()( row, col );
    }

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

    Value_type& operator()(int row, int col)
    {
        // Test program was HERE.
        return m_matrix -> elements[ row ][ col ];
    }

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

    Value_type operator()(int row, int col) const
    {
        // Test program was HERE.
        return m_matrix -> elements[ row ][ col ];
    }

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

    Value_type& at(int i)
    {
        // Test program was HERE.
        int row, col;
        compute_row_col_carefully( i, &row, &col );
        check_bounds( row, col );
        return operator()( row, col );
    }

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

    Value_type at(int i) const
    {
        // Test program was HERE.
        int row, col;
        compute_row_col_carefully( i, &row, &col );
        check_bounds( row, col );
        return operator()( row, col );
    }

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

    Value_type& at(int row, int col)
    {
        // Test program was HERE.
        check_bounds( row, col );
        return operator()(row, col);
    }

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

    Value_type at(int row, int col) const
    {
        // Test program was HERE.
        check_bounds( row, col );
        return operator()(row, col);
    }


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


    /* ------------------------------------------------------------------
     * EXTRACTION ROUTINES
     * ------------------------------------------------------------------ */

    Vec_type get_row(int row) const;

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

    Vec_type get_col(int col) const;

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

    template <class Generic_vector>
    void set_row(int row, const Generic_vector& v);

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

    template <class Iterator>
    void set_row(int row, Iterator begin, Iterator end);

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

    template <class Generic_vector>
    void set_col(int col, const Generic_vector& v);

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

    template <class Iterator>
    void set_col(int col, Iterator begin, Iterator end);

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


    int write( const char* filename = 0 ) const
    {
        // Test program was HERE.
        return kjb_c::write_int_matrix( m_matrix, filename );
    }


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

    /* ------------------------------------------------------------------
     * ARITHMETIC OPERATORS
     * Modifying arithmetic operators. That is, operators that modify
     * this matrix when applied. The non-modifying arithmetic operators
     * are non-member functions (and are below).
     * ------------------------------------------------------------------ */

    Int_matrix& operator*=(const Int_matrix& op2)
    {
        // Test program was HERE.
        ETX(multiply_int_matrices(&m_matrix, m_matrix, op2.m_matrix));
        return *this;
    }

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

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

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

    Int_matrix& operator*= (Value_type op2)
    {
        // Test program was HERE.
        ETX(kjb_c::ow_multiply_int_matrix_by_int_scalar(m_matrix, op2));
        return *this;
    }

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

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


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

    Int_matrix& operator/= (Int_matrix::Value_type op2);

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

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

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

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

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

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

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

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

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

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

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

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

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

    Mat_type& mapcar( Mapper );

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



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

/* ------------------------------------------------------------------
 * TEMPLATE MEMBERS  
 * ------------------------------------------------------------------ */

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

template <class Generic_vector>
void Int_matrix::set_row( int row, const Generic_vector& v )
{
    // Test program was HERE.
    using namespace boost;
    BOOST_CONCEPT_ASSERT((Container<Generic_vector>));

    typedef typename Generic_vector::value_type Vector_value_type;
    BOOST_CONCEPT_ASSERT((Convertible<Vector_value_type, Value_type>));

    set_row(row, v.begin(), v.end());
}

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

template <class Iterator>
void Int_matrix::set_row( int row, Iterator begin, Iterator end )
{
    Iterator it = begin;
    for ( int col = 0; col < get_num_cols(); ++col )
    {
        if(it == end)
        {
            // range too short
            KJB_THROW(Dimension_mismatch);
        }

        operator()(row, col) = *it;
        it++;
    }

    if(it != end)
    {
        // range too long 
        KJB_THROW(Dimension_mismatch);
    }
}


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


template <class Generic_vector>
void Int_matrix::set_col(int col, const Generic_vector& v)
{
    // Test program was HERE.
    using namespace boost;
    BOOST_CONCEPT_ASSERT((Container<Generic_vector>));

    typedef typename Generic_vector::value_type Vector_value_type;
    BOOST_CONCEPT_ASSERT((Convertible<Vector_value_type, Value_type>));

    set_col(col, v.begin(), v.end());
}

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

template <class Iterator>
void Int_matrix::set_col(int col, Iterator begin, Iterator end)
{
    Iterator it = begin;
    for ( int row = 0; row < get_num_rows(); ++row )
    {
        if(it == end)
        {
            // range is too short
            KJB_THROW(Dimension_mismatch);
        }

        operator()(row, col) = *it;
        it++;
    }

    if(it != end)
    {
        // range is too short
        KJB_THROW(Dimension_mismatch);
    }

}

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

/* ------------------------------------------------------------------
 * "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_matrix create_identity_int_matrix( int rank )
{
    // Test program was HERE.
    kjb_c::Int_matrix* result = 0;
    ETX( kjb_c::get_int_identity_matrix( &result, rank ) );
    return Int_matrix(result);
}

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

inline
Int_matrix create_zero_int_matrix( int rows, int columns )
{
    // Test program was HERE.
    kjb_c::Int_matrix* result = 0;
    ETX( kjb_c::get_zero_int_matrix( &result, rows, columns ) );
    return Int_matrix(result);
}

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

inline
Int_matrix create_zero_int_matrix( int rows )
{
    // Test program was HERE.
    return create_zero_int_matrix( rows, rows );
}

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

Int_matrix create_diagonal_matrix( const Int_matrix::Vec_type& diagnoal );

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

Int_matrix create_row_matrix( const Int_matrix::Vec_type& );

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

Int_matrix create_column_matrix( const Int_matrix::Vec_type& );

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

/* ------------------------------------------------------------------
 * ARITHMETIC OPERATORS
 * Non-modifying arithmetic operators. That is, operators that do not
 * modify the operators when applied. The modifying arithmetic operators
 * are member functions.
 * ------------------------------------------------------------------ */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* ------------------------------------------------------------------
 * COMPARISON OPERATORS
 * Comparison operators -- i.e., == and !=.
 * ------------------------------------------------------------------ */

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

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

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

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

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

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

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

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

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

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

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

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

/* ------------------------------------------------------------------
 * OTHER STUFF
 * Other stuff =)
 * ------------------------------------------------------------------ */

inline
Int_matrix matrix_transpose( const Int_matrix& op1 )
{
    kjb_c::Int_matrix* kjb_matrix = 0;
    ETX( kjb_c::get_int_transpose( &kjb_matrix, op1.get_c_matrix() ) );
    return Int_matrix(kjb_matrix);
}

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

inline
Int_matrix abs(const Int_matrix& mat)
{
    // Test program was HERE.
    kjb_c::Int_matrix* result = 0;
    ETX( kjb_c::get_abs_of_int_matrix( &result, mat.get_c_matrix() ) );
    return Int_matrix(result);
}

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

inline
Int_matrix::Value_type max_abs_difference( const Int_matrix& op1, const Int_matrix& op2 )
{
    if (    op1.get_num_rows() != op2.get_num_rows()
         || op1.get_num_cols() != op2.get_num_cols() )
    {
        // Test program was HERE.
        KJB_THROW( Dimension_mismatch );
    }
    //else
    //{
    //    // Test program was HERE.
    //}
    return kjb_c::max_abs_int_matrix_difference( op1.get_c_matrix(), op2.get_c_matrix() );
}

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

inline
Int_matrix::Value_type min(const Int_matrix& mat)
{
    // Test program was HERE.
    return kjb_c::min_int_matrix_element(mat.get_c_matrix());
}

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

inline
Int_matrix::Value_type max(const Int_matrix& mat)
{
    // Test program was HERE.
    return kjb_c::max_int_matrix_element(mat.get_c_matrix());
}



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

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


} // namespace kjb
#endif