249 lines
6.5 KiB
C++
249 lines
6.5 KiB
C++
/* -*- C++ -*- ------------------------------------------------------------
|
|
|
|
Copyright (c) 2007 Jesse Anders and Demian Nave http://cmldev.net/
|
|
|
|
The Configurable Math Library (CML) is distributed under the terms of the
|
|
Boost Software License, v1.0 (see cml/LICENSE for details).
|
|
|
|
*-----------------------------------------------------------------------*/
|
|
/** @file
|
|
* @brief
|
|
*/
|
|
|
|
#ifndef dynamic_2D_h
|
|
#define dynamic_2D_h
|
|
|
|
#include <memory>
|
|
#include <cml/core/common.h>
|
|
#include <cml/core/dynamic_1D.h>
|
|
#include <cml/dynamic.h>
|
|
|
|
namespace cml {
|
|
|
|
/** Dynamically-sized and allocated 2D array.
|
|
*
|
|
* @note The allocator should be an STL-compatible allocator.
|
|
*
|
|
* @internal The internal array type <em>must</em> have the proper copy
|
|
* semantics, otherwise copy construction will fail.
|
|
*
|
|
* @internal This class does not need a destructor.
|
|
*/
|
|
template<typename Element, typename Layout, class Alloc>
|
|
class dynamic_2D
|
|
{
|
|
public:
|
|
|
|
/* Record the allocator type: */
|
|
typedef typename Alloc::template rebind<Element>::other allocator_type;
|
|
|
|
/* Record the generator: */
|
|
typedef dynamic<Alloc> generator_type;
|
|
|
|
/* Standard: */
|
|
typedef typename allocator_type::value_type value_type;
|
|
typedef typename allocator_type::pointer pointer;
|
|
typedef typename allocator_type::reference reference;
|
|
typedef typename allocator_type::const_reference const_reference;
|
|
typedef typename allocator_type::const_pointer const_pointer;
|
|
|
|
/* For matching by memory layout: */
|
|
typedef Layout layout;
|
|
|
|
/* For matching by memory type: */
|
|
typedef dynamic_memory_tag memory_tag;
|
|
|
|
/* For matching by size type: */
|
|
typedef dynamic_size_tag size_tag;
|
|
|
|
/* For matching by resizability: */
|
|
typedef resizable_tag resizing_tag;
|
|
|
|
/* For matching by dimensions: */
|
|
typedef twod_tag dimension_tag;
|
|
|
|
/* To simplify the matrix transpose operator: */
|
|
typedef dynamic_2D<typename cml::remove_const<Element>::type,
|
|
Layout,Alloc> transposed_type;
|
|
|
|
/* To simplify the matrix row and column operators: */
|
|
typedef dynamic_1D<Element,Alloc> row_array_type;
|
|
typedef dynamic_1D<Element,Alloc> col_array_type;
|
|
|
|
|
|
protected:
|
|
|
|
/** Construct a dynamic array with no size. */
|
|
dynamic_2D() : m_rows(0), m_cols(0), m_data(0), m_alloc() {}
|
|
|
|
/** Construct a dynamic matrix given the dimensions. */
|
|
explicit dynamic_2D(size_t rows, size_t cols)
|
|
: m_rows(0), m_cols(0), m_data(0), m_alloc()
|
|
{
|
|
this->resize(rows, cols);
|
|
}
|
|
|
|
/** Copy construct a dynamic matrix. */
|
|
dynamic_2D(const dynamic_2D& other)
|
|
: m_rows(0), m_cols(0), m_data(0), m_alloc()
|
|
{
|
|
this->copy(other);
|
|
}
|
|
|
|
~dynamic_2D() {
|
|
this->destroy();
|
|
}
|
|
|
|
|
|
public:
|
|
|
|
enum { array_rows = -1, array_cols = -1 };
|
|
|
|
|
|
public:
|
|
|
|
/** Return the number of rows in the array. */
|
|
size_t rows() const { return m_rows; }
|
|
|
|
/** Return the number of cols in the array. */
|
|
size_t cols() const { return m_cols; }
|
|
|
|
|
|
public:
|
|
|
|
/** Access the given element of the matrix.
|
|
*
|
|
* @param row row of element.
|
|
* @param col column of element.
|
|
* @returns mutable reference.
|
|
*/
|
|
reference operator()(size_t row, size_t col) {
|
|
return this->get_element(row, col, layout());
|
|
}
|
|
|
|
/** Access the given element of the matrix.
|
|
*
|
|
* @param row row of element.
|
|
* @param col column of element.
|
|
* @returns const reference.
|
|
*/
|
|
const_reference operator()(size_t row, size_t col) const {
|
|
return this->get_element(row, col, layout());
|
|
}
|
|
|
|
/** Return access to the data as a raw pointer. */
|
|
pointer data() { return &m_data[0]; }
|
|
|
|
/** Return access to the data as a raw pointer. */
|
|
const_pointer data() const { return &m_data[0]; }
|
|
|
|
|
|
public:
|
|
|
|
/** Set the array dimensions. The previous contents are destroyed
|
|
* before reallocating the array. If the number of rows and columns
|
|
* isn't changing, nothing happens. Also, if either rows or cols is 0,
|
|
* the array is cleared.
|
|
*
|
|
* @warning This is not guaranteed to preserve the original data.
|
|
*/
|
|
void resize(size_t rows, size_t cols) {
|
|
|
|
/* Nothing to do if the size isn't changing: */
|
|
if(rows == m_rows && cols == m_cols) return;
|
|
|
|
/* Destroy the current array contents: */
|
|
this->destroy();
|
|
|
|
/* Set the new size if non-zero: */
|
|
if(rows*cols > 0) {
|
|
value_type* data = m_alloc.allocate(rows*cols);
|
|
for(size_t i = 0; i < rows*cols; ++ i)
|
|
m_alloc.construct(&data[i], value_type());
|
|
|
|
/* Success, so save the new array and the dimensions: */
|
|
m_rows = rows;
|
|
m_cols = cols;
|
|
m_data = data;
|
|
}
|
|
}
|
|
|
|
/** Copy the other array. The previous contents are destroyed before
|
|
* reallocating the array. If other == *this, nothing happens. Also,
|
|
* if either other.rows() or other.cols() is 0, the array is cleared.
|
|
*/
|
|
void copy(const dynamic_2D& other) {
|
|
|
|
/* Nothing to do if it's the same array: */
|
|
if(&other == this) return;
|
|
|
|
/* Destroy the current array contents: */
|
|
this->destroy();
|
|
|
|
/* Set the new size if non-zero: */
|
|
size_t rows = other.rows(), cols = other.cols();
|
|
if(rows*cols > 0) {
|
|
value_type* data = m_alloc.allocate(rows*cols);
|
|
for(size_t i = 0; i < rows*cols; ++ i)
|
|
m_alloc.construct(&data[i], other[i]);
|
|
|
|
/* Success, so save the new array and the dimensions: */
|
|
m_rows = rows;
|
|
m_cols = cols;
|
|
m_data = data;
|
|
}
|
|
}
|
|
|
|
|
|
protected:
|
|
|
|
reference get_element(size_t row, size_t col, row_major) {
|
|
return m_data[row*m_cols + col];
|
|
}
|
|
|
|
const_reference get_element(size_t row, size_t col, row_major) const {
|
|
return m_data[row*m_cols + col];
|
|
}
|
|
|
|
reference get_element(size_t row, size_t col, col_major) {
|
|
return m_data[col*m_rows + row];
|
|
}
|
|
|
|
const_reference get_element(size_t row, size_t col, col_major) const {
|
|
return m_data[col*m_rows + row];
|
|
}
|
|
|
|
|
|
protected:
|
|
|
|
/** Destroy the current contents of the array. */
|
|
void destroy() {
|
|
if(m_data) {
|
|
for(size_t i = 0; i < m_rows*m_cols; ++ i)
|
|
m_alloc.destroy(&m_data[i]);
|
|
m_alloc.deallocate(m_data, m_rows*m_cols);
|
|
m_rows = m_cols = 0;
|
|
m_data = 0;
|
|
}
|
|
}
|
|
|
|
|
|
protected:
|
|
|
|
/** Current array dimensions (may be 0,0). */
|
|
size_t m_rows, m_cols;
|
|
|
|
/** Array data (may be NULL). */
|
|
value_type* m_data;
|
|
|
|
/** Allocator for the array. */
|
|
allocator_type m_alloc;
|
|
};
|
|
|
|
} // namespace cml
|
|
|
|
#endif
|
|
|
|
// -------------------------------------------------------------------------
|
|
// vim:ft=cpp
|