diff --git a/src/common/aka_array.hh b/src/common/aka_array.hh
index 46300822e..a2523289d 100644
--- a/src/common/aka_array.hh
+++ b/src/common/aka_array.hh
@@ -1,399 +1,363 @@
/**
* @file aka_array.hh
*
* @author Till Junge <till.junge@epfl.ch>
* @author Nicolas Richart <nicolas.richart@epfl.ch>
*
* @date creation: Fri Jun 18 2010
* @date last modification: Fri Jan 22 2016
*
* @brief Array container for Akantu
* This container differs from the std::vector from the fact it as 2 dimensions
* a main dimension and the size stored per entries
*
* @section LICENSE
*
* Copyright (©) 2010-2012, 2014, 2015 EPFL (Ecole Polytechnique Fédérale de
* Lausanne) Laboratory (LSMS - Laboratoire de Simulation en Mécanique des
* Solides)
*
* Akantu is free software: you can redistribute it and/or modify it under the
* terms of the GNU Lesser General Public License as published by the Free
* Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
* A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Akantu. If not, see <http://www.gnu.org/licenses/>.
*
*/
/* -------------------------------------------------------------------------- */
#ifndef __AKANTU_VECTOR_HH__
#define __AKANTU_VECTOR_HH__
/* -------------------------------------------------------------------------- */
#include "aka_common.hh"
/* -------------------------------------------------------------------------- */
#include <typeinfo>
#include <vector>
/* -------------------------------------------------------------------------- */
namespace akantu {
/// class that afford to store vectors in static memory
class ArrayBase {
/* ------------------------------------------------------------------------ */
/* Constructors/Destructors */
/* ------------------------------------------------------------------------ */
public:
explicit ArrayBase(ID id = "");
virtual ~ArrayBase();
/* ------------------------------------------------------------------------ */
/* Methods */
/* ------------------------------------------------------------------------ */
public:
/// get the amount of space allocated in bytes
inline UInt getMemorySize() const;
/// set the size to zero without freeing the allocated space
inline void empty();
/// function to print the containt of the class
virtual void printself(std::ostream & stream, int indent = 0) const;
/* ------------------------------------------------------------------------ */
/* Accessors */
/* ------------------------------------------------------------------------ */
public:
/// Get the real size allocated in memory
AKANTU_GET_MACRO(AllocatedSize, allocated_size, UInt);
/// Get the Size of the Array
UInt getsize() const __attribute__((deprecated)) { return size_; }
UInt size() const { return size_; }
/// Get the number of components
AKANTU_GET_MACRO(NbComponent, nb_component, UInt);
/// Get the name of th array
AKANTU_GET_MACRO(ID, id, const ID &);
/// Set the name of th array
AKANTU_SET_MACRO(ID, id, const ID &);
// AKANTU_GET_MACRO(Tag, tag, const std::string &);
// AKANTU_SET_MACRO(Tag, tag, const std::string &);
/* ------------------------------------------------------------------------ */
/* Class Members */
/* ------------------------------------------------------------------------ */
protected:
/// id of the vector
ID id;
/// the size allocated
UInt allocated_size{0};
/// the size used
UInt size_{0};
/// number of components
UInt nb_component{1};
/// size of the stored type
UInt size_of_type{0};
};
/* -------------------------------------------------------------------------- */
+namespace {
+ template <std::size_t dim, typename T> struct IteratorHelper {};
+
+ template <typename T> struct IteratorHelper<0, T> { using type = T; };
+ template <typename T> struct IteratorHelper<1, T> { using type = Vector<T>; };
+ template <typename T> struct IteratorHelper<2, T> { using type = Matrix<T>; };
+ template <typename T> struct IteratorHelper<3, T> {
+ using type = Tensor3<T>;
+ };
+
+ template <std::size_t dim, typename T>
+ using IteratorHelper_t = typename IteratorHelper<dim, T>::type;
+} // namespace
/* -------------------------------------------------------------------------- */
template <typename T, bool is_scal> class Array : public ArrayBase {
/* ------------------------------------------------------------------------ */
/* Constructors/Destructors */
/* ------------------------------------------------------------------------ */
public:
using value_type = T;
using reference = value_type &;
using pointer_type = value_type *;
using const_reference = const value_type &;
/// Allocation of a new vector
explicit inline Array(UInt size = 0, UInt nb_component = 1,
const ID & id = "");
/// Allocation of a new vector with a default value
Array(UInt size, UInt nb_component, const value_type def_values[],
const ID & id = "");
/// Allocation of a new vector with a default value
Array(UInt size, UInt nb_component, const_reference value,
const ID & id = "");
/// Copy constructor (deep copy if deep=true)
Array(const Array<value_type, is_scal> & vect, bool deep = true,
const ID & id = "");
#ifndef SWIG
/// Copy constructor (deep copy)
explicit Array(const std::vector<value_type> & vect);
#endif
inline ~Array() override;
Array & operator=(const Array & a) {
/// this is to let STL allocate and copy arrays in the case of
/// std::vector::resize
AKANTU_DEBUG_ASSERT(this->size == 0, "Cannot copy akantu::Array");
return const_cast<Array &>(a);
}
/* ------------------------------------------------------------------------ */
/* Iterator */
/* ------------------------------------------------------------------------ */
/// \todo protected: does not compile with intel check why
public:
template <class R, class IR = R, bool issame = is_same<IR, T>::value>
class iterator_internal;
public:
/* ------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------ */
template <typename R = T> class const_iterator;
template <typename R = T> class iterator;
/* ------------------------------------------------------------------------ */
/// iterator for Array of nb_component = 1
using scalar_iterator = iterator<T>;
/// const_iterator for Array of nb_component = 1
using const_scalar_iterator = const_iterator<T>;
- /// iterator rerturning Vectors of size n on entries of Array with
+ /// iterator returning Vectors of size n on entries of Array with
/// nb_component = n
using vector_iterator = iterator<Vector<T>>;
- /// const_iterator rerturning Vectors of n size on entries of Array with
+ /// const_iterator returning Vectors of n size on entries of Array with
/// nb_component = n
using const_vector_iterator = const_iterator<Vector<T>>;
- /// iterator rerturning Matrices of size (m, n) on entries of Array with
+ /// iterator returning Matrices of size (m, n) on entries of Array with
/// nb_component = m*n
using matrix_iterator = iterator<Matrix<T>>;
- /// const iterator rerturning Matrices of size (m, n) on entries of Array with
+ /// const iterator returning Matrices of size (m, n) on entries of Array with
/// nb_component = m*n
using const_matrix_iterator = const_iterator<Matrix<T>>;
- /* ------------------------------------------------------------------------ */
- /// Get an iterator that behaves like a pointer T * to the first entry
- inline scalar_iterator begin();
- /// Get an iterator that behaves like a pointer T * to the end of the Array
- inline scalar_iterator end();
- /// Get a const_iterator to the beginging of an Array of scalar
- inline const_scalar_iterator begin() const;
- /// Get a const_iterator to the end of an Array of scalar
- inline const_scalar_iterator end() const;
-
- /// Get a scalar_iterator on the beginning of the Array considered of shape
- /// (new_size)
- inline scalar_iterator begin_reinterpret(UInt new_size);
- /// Get a scalar_iterator on the end of the Array considered of shape
- /// (new_size)
- inline scalar_iterator end_reinterpret(UInt new_size);
- /// Get a const_scalar_iterator on the beginning of the Array considered of
- /// shape (new_size)
- inline const_scalar_iterator begin_reinterpret(UInt new_size) const;
- /// Get a const_scalar_iterator on the end of the Array considered of shape
- /// (new_size)
- inline const_scalar_iterator end_reinterpret(UInt new_size) const;
+ /// iterator returning Tensor3 of size (m, n, k) on entries of Array with
+ /// nb_component = m*n*k
+ using tensor3_iterator = iterator<Tensor3<T>>;
+ /// const iterator returning Tensor3 of size (m, n, k) on entries of Array
+ /// with nb_component = m*n*k
+ using const_tensor3_iterator = const_iterator<Tensor3<T>>;
/* ------------------------------------------------------------------------ */
- /// Get a vector_iterator on the beginning of the Array
- inline vector_iterator begin(UInt n);
- /// Get a vector_iterator on the end of the Array
- inline vector_iterator end(UInt n);
- /// Get a vector_iterator on the beginning of the Array
- inline const_vector_iterator begin(UInt n) const;
- /// Get a vector_iterator on the end of the Array
- inline const_vector_iterator end(UInt n) const;
-
- /// Get a vector_iterator on the begining of the Array considered of shape
- /// (new_size, n)
- inline vector_iterator begin_reinterpret(UInt n, UInt new_size);
- /// Get a vector_iterator on the end of the Array considered of shape
- /// (new_size, n)
- inline vector_iterator end_reinterpret(UInt n, UInt new_size);
- /// Get a const_vector_iterator on the begining of the Array considered of
- /// shape (new_size, n)
- inline const_vector_iterator begin_reinterpret(UInt n, UInt new_size) const;
- /// Get a const_vector_iterator on the end of the Array considered of shape
- /// (new_size, n)
- inline const_vector_iterator end_reinterpret(UInt n, UInt new_size) const;
+ template <typename... Ns> inline decltype(auto) begin(Ns... n);
+ template <typename... Ns> inline decltype(auto) end(Ns... n);
- /* ------------------------------------------------------------------------ */
- /// Get a matrix_iterator on the begining of the Array (Matrices of size (m,
- /// n))
- inline matrix_iterator begin(UInt m, UInt n);
- /// Get a matrix_iterator on the end of the Array (Matrices of size (m, n))
- inline matrix_iterator end(UInt m, UInt n);
- /// Get a const_matrix_iterator on the begining of the Array (Matrices of size
- /// (m, n))
- inline const_matrix_iterator begin(UInt m, UInt n) const;
- /// Get a const_matrix_iterator on the end of the Array (Matrices of size (m,
- /// n))
- inline const_matrix_iterator end(UInt m, UInt n) const;
-
- /// Get a matrix_iterator on the begining of the Array considered of shape
- /// (new_size, m*n)
- inline matrix_iterator begin_reinterpret(UInt m, UInt n, UInt size);
- /// Get a matrix_iterator on the end of the Array considered of shape
- /// (new_size, m*n)
- inline matrix_iterator end_reinterpret(UInt m, UInt n, UInt size);
- /// Get a const_matrix_iterator on the begining of the Array considered of
- /// shape (new_size, m*n)
- inline const_matrix_iterator begin_reinterpret(UInt m, UInt n,
- UInt size) const;
- /// Get a const_matrix_iterator on the end of the Array considered of shape
- /// (new_size, m*n)
- inline const_matrix_iterator end_reinterpret(UInt m, UInt n, UInt size) const;
+ template <typename... Ns> inline decltype(auto) begin(Ns... n) const;
+ template <typename... Ns> inline decltype(auto) end(Ns... n) const;
+
+ template <typename... Ns>
+ inline decltype(auto) begin_reinterpret(Ns... n);
+ template <typename... Ns>
+ inline decltype(auto) end_reinterpret(Ns... n);
+
+ template <typename... Ns>
+ inline decltype(auto) begin_reinterpret(Ns... n) const;
+ template <typename... Ns>
+ inline decltype(auto) end_reinterpret(Ns... n) const;
/* ------------------------------------------------------------------------ */
/* Methods */
/* ------------------------------------------------------------------------ */
public:
/// append a tuple of size nb_component containing value
inline void push_back(const_reference value);
/// append a vector
// inline void push_back(const value_type new_elem[]);
/// append a Vector or a Matrix
template <template <typename> class C>
inline void push_back(const C<T> & new_elem);
/// append the value of the iterator
template <typename Ret> inline void push_back(const iterator<Ret> & it);
/// erase the value at position i
inline void erase(UInt i);
/// ask Nico, clarify
template <typename R> inline iterator<R> erase(const iterator<R> & it);
/// changes the allocated size but not the size
virtual void reserve(UInt size);
/// change the size of the Array
virtual void resize(UInt size);
/// change the size of the Array and initialize the values
virtual void resize(UInt size, const T & val);
/// change the number of components by interlacing data
/// @param multiplicator number of interlaced components add
/// @param block_size blocks of data in the array
/// Examaple for block_size = 2, multiplicator = 2
/// array = oo oo oo -> new array = oo nn nn oo nn nn oo nn nn
void extendComponentsInterlaced(UInt multiplicator, UInt stride);
/// search elem in the vector, return the position of the first occurrence or
/// -1 if not found
UInt find(const_reference elem) const;
/// @see Array::find(const_reference elem) const
UInt find(T elem[]) const;
/// @see Array::find(const_reference elem) const
template <template <typename> class C> inline UInt find(const C<T> & elem);
/// set all entries of the array to 0
inline void clear() { std::fill_n(values, size_ * nb_component, T()); }
/// set all entries of the array to the value t
/// @param t value to fill the array with
inline void set(T t) { std::fill_n(values, size_ * nb_component, t); }
/// set all tuples of the array to a given vector or matrix
/// @param vm Matrix or Vector to fill the array with
template <template <typename> class C> inline void set(const C<T> & vm);
/// Append the content of the other array to the current one
void append(const Array<T> & other);
/// copy another Array in the current Array, the no_sanity_check allows you to
/// force the copy in cases where you know what you do with two non matching
/// Arrays in terms of n
void copy(const Array<T, is_scal> & other, bool no_sanity_check = false);
/// give the address of the memory allocated for this vector
T * storage() const { return values; };
/// function to print the containt of the class
void printself(std::ostream & stream, int indent = 0) const override;
protected:
/// perform the allocation for the constructors
void allocate(UInt size, UInt nb_component = 1);
/// resize initializing with uninitialized_fill if fill is set
void resizeUnitialized(UInt new_size, bool fill, const T & val = T());
/* ------------------------------------------------------------------------ */
/* Operators */
/* ------------------------------------------------------------------------ */
public:
/// substraction entry-wise
Array<T, is_scal> & operator-=(const Array<T, is_scal> & other);
/// addition entry-wise
Array<T, is_scal> & operator+=(const Array<T, is_scal> & other);
/// multiply evry entry by alpha
Array<T, is_scal> & operator*=(const T & alpha);
/// check if the array are identical entry-wise
bool operator==(const Array<T, is_scal> & other) const;
/// @see Array::operator==(const Array<T, is_scal> & other) const
bool operator!=(const Array<T, is_scal> & other) const;
/// return a reference to the j-th entry of the i-th tuple
inline reference operator()(UInt i, UInt j = 0);
/// return a const reference to the j-th entry of the i-th tuple
inline const_reference operator()(UInt i, UInt j = 0) const;
/// return a reference to the ith component of the 1D array
inline reference operator[](UInt i);
/// return a const reference to the ith component of the 1D array
inline const_reference operator[](UInt i) const;
/* ------------------------------------------------------------------------ */
/* Class Members */
/* ------------------------------------------------------------------------ */
protected:
/// array of values
T * values; // /!\ very dangerous
};
/* -------------------------------------------------------------------------- */
/* Inline Functions Array<T, is_scal> */
/* -------------------------------------------------------------------------- */
template <typename T, bool is_scal>
inline std::ostream & operator<<(std::ostream & stream,
const Array<T, is_scal> & _this) {
_this.printself(stream);
return stream;
}
/* -------------------------------------------------------------------------- */
/* Inline Functions ArrayBase */
/* -------------------------------------------------------------------------- */
inline std::ostream & operator<<(std::ostream & stream,
const ArrayBase & _this) {
_this.printself(stream);
return stream;
}
} // namespace akantu
#include "aka_array_tmpl.hh"
#include "aka_types.hh"
#endif /* __AKANTU_VECTOR_HH__ */
diff --git a/src/common/aka_array_tmpl.hh b/src/common/aka_array_tmpl.hh
index dcbbfffc0..5c3a508ea 100644
--- a/src/common/aka_array_tmpl.hh
+++ b/src/common/aka_array_tmpl.hh
@@ -1,1543 +1,1250 @@
/**
* @file aka_array_tmpl.hh
*
* @author Nicolas Richart <nicolas.richart@epfl.ch>
*
* @date creation: Thu Jul 15 2010
* @date last modification: Fri Jan 22 2016
*
* @brief Inline functions of the classes Array<T> and ArrayBase
*
* @section LICENSE
*
* Copyright (©) 2010-2012, 2014, 2015 EPFL (Ecole Polytechnique Fédérale de
* Lausanne) Laboratory (LSMS - Laboratoire de Simulation en Mécanique des
* Solides)
*
* Akantu is free software: you can redistribute it and/or modify it under the
* terms of the GNU Lesser General Public License as published by the Free
* Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
* A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Akantu. If not, see <http://www.gnu.org/licenses/>.
*
*/
/* -------------------------------------------------------------------------- */
/* Inline Functions Array<T> */
/* -------------------------------------------------------------------------- */
#include "aka_array.hh"
/* -------------------------------------------------------------------------- */
#include <memory>
/* -------------------------------------------------------------------------- */
#ifndef __AKANTU_AKA_ARRAY_TMPL_HH__
#define __AKANTU_AKA_ARRAY_TMPL_HH__
namespace akantu {
/* -------------------------------------------------------------------------- */
template <class T, bool is_scal>
inline T & Array<T, is_scal>::operator()(UInt i, UInt j) {
AKANTU_DEBUG_ASSERT(size_ > 0, "The array \"" << id << "\" is empty");
AKANTU_DEBUG_ASSERT((i < size_) && (j < nb_component),
"The value at position ["
<< i << "," << j << "] is out of range in array \""
<< id << "\"");
return values[i * nb_component + j];
}
/* -------------------------------------------------------------------------- */
template <class T, bool is_scal>
inline const T & Array<T, is_scal>::operator()(UInt i, UInt j) const {
AKANTU_DEBUG_ASSERT(size_ > 0, "The array \"" << id << "\" is empty");
AKANTU_DEBUG_ASSERT((i < size_) && (j < nb_component),
"The value at position ["
<< i << "," << j << "] is out of range in array \""
<< id << "\"");
return values[i * nb_component + j];
}
template <class T, bool is_scal>
inline T & Array<T, is_scal>::operator[](UInt i) {
AKANTU_DEBUG_ASSERT(size_ > 0, "The array \"" << id << "\" is empty");
AKANTU_DEBUG_ASSERT((i < size_ * nb_component),
"The value at position ["
<< i << "] is out of range in array \"" << id
<< "\"");
return values[i];
}
/* -------------------------------------------------------------------------- */
template <class T, bool is_scal>
inline const T & Array<T, is_scal>::operator[](UInt i) const {
AKANTU_DEBUG_ASSERT(size_ > 0, "The array \"" << id << "\" is empty");
AKANTU_DEBUG_ASSERT((i < size_ * nb_component),
"The value at position ["
<< i << "] is out of range in array \"" << id
<< "\"");
return values[i];
}
/* -------------------------------------------------------------------------- */
/**
* append a tuple to the array with the value value for all components
* @param value the new last tuple or the array will contain nb_component copies
* of value
*/
template <class T, bool is_scal>
inline void Array<T, is_scal>::push_back(const T & value) {
resizeUnitialized(size_ + 1, true, value);
}
/* -------------------------------------------------------------------------- */
/**
* append a tuple to the array
* @param new_elem a C-array containing the values to be copied to the end of
* the array */
// template <class T, bool is_scal>
// inline void Array<T, is_scal>::push_back(const T new_elem[]) {
// UInt pos = size_;
// resizeUnitialized(size_ + 1, false);
// T * tmp = values + nb_component * pos;
// std::uninitialized_copy(new_elem, new_elem + nb_component, tmp);
// }
/* -------------------------------------------------------------------------- */
/**
* append a matrix or a vector to the array
* @param new_elem a reference to a Matrix<T> or Vector<T> */
template <class T, bool is_scal>
template <template <typename> class C>
inline void Array<T, is_scal>::push_back(const C<T> & new_elem) {
AKANTU_DEBUG_ASSERT(
nb_component == new_elem.size(),
"The vector("
<< new_elem.size()
<< ") as not a size compatible with the Array (nb_component="
<< nb_component << ").");
UInt pos = size_;
resizeUnitialized(size_ + 1, false);
T * tmp = values + nb_component * pos;
std::uninitialized_copy(new_elem.storage(), new_elem.storage() + nb_component,
tmp);
}
/* -------------------------------------------------------------------------- */
/**
* append a tuple to the array
* @param it an iterator to the tuple to be copied to the end of the array */
template <class T, bool is_scal>
template <class Ret>
inline void
Array<T, is_scal>::push_back(const Array<T, is_scal>::iterator<Ret> & it) {
UInt pos = size_;
resizeUnitialized(size_ + 1, false);
T * tmp = values + nb_component * pos;
T * new_elem = it.data();
std::uninitialized_copy(new_elem, new_elem + nb_component, tmp);
}
/* -------------------------------------------------------------------------- */
/**
* erase an element. If the erased element is not the last of the array, the
* last element is moved into the hole in order to maintain contiguity. This
* may invalidate existing iterators (For instance an iterator obtained by
* Array::end() is no longer correct) and will change the order of the
* elements.
* @param i index of element to erase
*/
template <class T, bool is_scal> inline void Array<T, is_scal>::erase(UInt i) {
AKANTU_DEBUG_IN();
AKANTU_DEBUG_ASSERT((size_ > 0), "The array is empty");
AKANTU_DEBUG_ASSERT((i < size_), "The element at position ["
<< i << "] is out of range (" << i
<< ">=" << size_ << ")");
if (i != (size_ - 1)) {
for (UInt j = 0; j < nb_component; ++j) {
values[i * nb_component + j] = values[(size_ - 1) * nb_component + j];
}
}
resize(size_ - 1);
AKANTU_DEBUG_OUT();
}
/* -------------------------------------------------------------------------- */
/**
* Subtract another array entry by entry from this array in place. Both arrays
* must
* have the same size and nb_component. If the arrays have different shapes,
* code compiled in debug mode will throw an expeption and optimised code
* will behave in an unpredicted manner
* @param other array to subtract from this
* @return reference to modified this
*/
template <class T, bool is_scal>
Array<T, is_scal> & Array<T, is_scal>::
operator-=(const Array<T, is_scal> & vect) {
AKANTU_DEBUG_ASSERT((size_ == vect.size_) &&
(nb_component == vect.nb_component),
"The too array don't have the same sizes");
T * a = values;
T * b = vect.storage();
for (UInt i = 0; i < size_ * nb_component; ++i) {
*a -= *b;
++a;
++b;
}
return *this;
}
/* -------------------------------------------------------------------------- */
/**
* Add another array entry by entry to this array in place. Both arrays must
* have the same size and nb_component. If the arrays have different shapes,
* code compiled in debug mode will throw an expeption and optimised code
* will behave in an unpredicted manner
* @param other array to add to this
* @return reference to modified this
*/
template <class T, bool is_scal>
Array<T, is_scal> & Array<T, is_scal>::
operator+=(const Array<T, is_scal> & vect) {
AKANTU_DEBUG_ASSERT((size_ == vect.size) &&
(nb_component == vect.nb_component),
"The too array don't have the same sizes");
T * a = values;
T * b = vect.storage();
for (UInt i = 0; i < size_ * nb_component; ++i) {
*a++ += *b++;
}
return *this;
}
/* -------------------------------------------------------------------------- */
/**
* Multiply all entries of this array by a scalar in place
* @param alpha scalar multiplicant
* @return reference to modified this
*/
template <class T, bool is_scal>
Array<T, is_scal> & Array<T, is_scal>::operator*=(const T & alpha) {
T * a = values;
for (UInt i = 0; i < size_ * nb_component; ++i) {
*a++ *= alpha;
}
return *this;
}
/* -------------------------------------------------------------------------- */
/**
* Compare this array element by element to another.
* @param other array to compare to
* @return true it all element are equal and arrays have the same shape, else
* false
*/
template <class T, bool is_scal>
bool Array<T, is_scal>::operator==(const Array<T, is_scal> & array) const {
bool equal = nb_component == array.nb_component && size_ == array.size_ &&
id == array.id;
if (!equal)
return false;
if (values == array.storage())
return true;
else
return std::equal(values, values + size_ * nb_component, array.storage());
}
/* -------------------------------------------------------------------------- */
template <class T, bool is_scal>
bool Array<T, is_scal>::operator!=(const Array<T, is_scal> & array) const {
return !operator==(array);
}
/* -------------------------------------------------------------------------- */
/**
* set all tuples of the array to a given vector or matrix
* @param vm Matrix or Vector to fill the array with
*/
template <class T, bool is_scal>
template <template <typename> class C>
inline void Array<T, is_scal>::set(const C<T> & vm) {
AKANTU_DEBUG_ASSERT(
nb_component == vm.size(),
"The size of the object does not match the number of components");
for (T * it = values; it < values + nb_component * size_;
it += nb_component) {
std::copy(vm.storage(), vm.storage() + nb_component, it);
}
}
/* -------------------------------------------------------------------------- */
template <class T, bool is_scal>
void Array<T, is_scal>::append(const Array<T> & other) {
AKANTU_DEBUG_ASSERT(
nb_component == other.nb_component,
"Cannot append an array with a different number of component");
UInt old_size = this->size_;
this->resizeUnitialized(this->size_ + other.size(), false);
T * tmp = values + nb_component * old_size;
std::uninitialized_copy(other.storage(),
other.storage() + other.size() * nb_component, tmp);
}
/* -------------------------------------------------------------------------- */
/* Functions Array<T, is_scal> */
/* -------------------------------------------------------------------------- */
template <class T, bool is_scal>
Array<T, is_scal>::Array(UInt size, UInt nb_component, const ID & id)
: ArrayBase(id), values(NULL) {
AKANTU_DEBUG_IN();
allocate(size, nb_component);
if (!is_scal) {
T val = T();
std::uninitialized_fill(values, values + size * nb_component, val);
}
AKANTU_DEBUG_OUT();
}
/* -------------------------------------------------------------------------- */
template <class T, bool is_scal>
Array<T, is_scal>::Array(UInt size, UInt nb_component, const T def_values[],
const ID & id)
: ArrayBase(id), values(NULL) {
AKANTU_DEBUG_IN();
allocate(size, nb_component);
T * tmp = values;
for (UInt i = 0; i < size; ++i) {
tmp = values + nb_component * i;
std::uninitialized_copy(def_values, def_values + nb_component, tmp);
}
AKANTU_DEBUG_OUT();
}
/* -------------------------------------------------------------------------- */
template <class T, bool is_scal>
Array<T, is_scal>::Array(UInt size, UInt nb_component, const T & value,
const ID & id)
: ArrayBase(id), values(NULL) {
AKANTU_DEBUG_IN();
allocate(size, nb_component);
std::uninitialized_fill_n(values, size * nb_component, value);
AKANTU_DEBUG_OUT();
}
/* -------------------------------------------------------------------------- */
template <class T, bool is_scal>
Array<T, is_scal>::Array(const Array<T, is_scal> & vect, bool deep,
const ID & id)
: ArrayBase(vect) {
AKANTU_DEBUG_IN();
this->id = (id == "") ? vect.id : id;
if (deep) {
allocate(vect.size_, vect.nb_component);
T * tmp = values;
std::uninitialized_copy(vect.storage(),
vect.storage() + size_ * nb_component, tmp);
} else {
this->values = vect.storage();
this->size_ = vect.size_;
this->nb_component = vect.nb_component;
this->allocated_size = vect.allocated_size;
this->size_of_type = vect.size_of_type;
}
AKANTU_DEBUG_OUT();
}
/* -------------------------------------------------------------------------- */
#ifndef SWIG
template <class T, bool is_scal>
Array<T, is_scal>::Array(const std::vector<T> & vect) {
AKANTU_DEBUG_IN();
this->id = "";
allocate(vect.size(), 1);
T * tmp = values;
std::uninitialized_copy(&(vect[0]), &(vect[size_ - 1]), tmp);
AKANTU_DEBUG_OUT();
}
#endif
/* -------------------------------------------------------------------------- */
template <class T, bool is_scal> Array<T, is_scal>::~Array() {
AKANTU_DEBUG_IN();
AKANTU_DEBUG(dblAccessory,
"Freeing " << printMemorySize<T>(allocated_size * nb_component)
<< " (" << id << ")");
if (values) {
if (!is_scal)
for (UInt i = 0; i < size_ * nb_component; ++i) {
T * obj = values + i;
obj->~T();
}
free(values);
}
size_ = allocated_size = 0;
AKANTU_DEBUG_OUT();
}
/* -------------------------------------------------------------------------- */
/**
* perform the allocation for the constructors
* @param size is the size of the array
* @param nb_component is the number of component of the array
*/
template <class T, bool is_scal>
void Array<T, is_scal>::allocate(UInt size, UInt nb_component) {
AKANTU_DEBUG_IN();
if (size == 0) {
values = nullptr;
} else {
values = static_cast<T *>(malloc(nb_component * size * sizeof(T)));
AKANTU_DEBUG_ASSERT(values != nullptr,
"Cannot allocate "
<< printMemorySize<T>(size * nb_component) << " ("
<< id << ")");
}
if (values == NULL) {
this->size_ = this->allocated_size = 0;
} else {
AKANTU_DEBUG(dblAccessory, "Allocated "
<< printMemorySize<T>(size * nb_component)
<< " (" << id << ")");
this->size_ = this->allocated_size = size;
}
this->size_of_type = sizeof(T);
this->nb_component = nb_component;
AKANTU_DEBUG_OUT();
}
/* -------------------------------------------------------------------------- */
template <class T, bool is_scal>
void Array<T, is_scal>::reserve(UInt new_size) {
UInt tmp_size = this->size_;
resizeUnitialized(new_size, false);
this->size_ = tmp_size;
}
/* -------------------------------------------------------------------------- */
/**
* change the size of the array and allocate or free memory if needed. If the
* size increases, the new tuples are filled with zeros
* @param new_size new number of tuples contained in the array */
template <class T, bool is_scal> void Array<T, is_scal>::resize(UInt new_size) {
resizeUnitialized(new_size, !is_scal);
}
/* -------------------------------------------------------------------------- */
/**
* change the size of the array and allocate or free memory if needed. If the
* size increases, the new tuples are filled with zeros
* @param new_size new number of tuples contained in the array */
template <class T, bool is_scal>
void Array<T, is_scal>::resize(UInt new_size, const T & val) {
this->resizeUnitialized(new_size, true, val);
}
/* -------------------------------------------------------------------------- */
/**
* change the size of the array and allocate or free memory if needed.
* @param new_size new number of tuples contained in the array */
template <class T, bool is_scal>
void Array<T, is_scal>::resizeUnitialized(UInt new_size, bool fill,
const T & val) {
// AKANTU_DEBUG_IN();
// free some memory
if (new_size <= allocated_size) {
if (!is_scal) {
T * old_values = values;
if (new_size < size_) {
for (UInt i = new_size * nb_component; i < size_ * nb_component; ++i) {
T * obj = old_values + i;
obj->~T();
}
}
}
if (allocated_size - new_size > AKANTU_MIN_ALLOCATION) {
AKANTU_DEBUG(dblAccessory,
"Freeing " << printMemorySize<T>((allocated_size - size_) *
nb_component)
<< " (" << id << ")");
// Normally there are no allocation problem when reducing an array
if (new_size == 0) {
free(values);
values = NULL;
} else {
auto * tmp_ptr = static_cast<T *>(
realloc(values, new_size * nb_component * sizeof(T)));
if (tmp_ptr == NULL) {
AKANTU_EXCEPTION("Cannot free data ("
<< id << ")"
<< " [current allocated size : " << allocated_size
<< " | "
<< "requested size : " << new_size << "]");
}
values = tmp_ptr;
}
allocated_size = new_size;
}
} else {
// allocate more memory
UInt size_to_alloc = (new_size - allocated_size < AKANTU_MIN_ALLOCATION)
? allocated_size + AKANTU_MIN_ALLOCATION
: new_size;
auto * tmp_ptr = static_cast<T *>(
realloc(values, size_to_alloc * nb_component * sizeof(T)));
AKANTU_DEBUG_ASSERT(
tmp_ptr != NULL,
"Cannot allocate " << printMemorySize<T>(size_to_alloc * nb_component));
if (tmp_ptr == NULL) {
AKANTU_DEBUG_ERROR("Cannot allocate more data ("
<< id << ")"
<< " [current allocated size : " << allocated_size
<< " | "
<< "requested size : " << new_size << "]");
}
AKANTU_DEBUG(dblAccessory,
"Allocating " << printMemorySize<T>(
(size_to_alloc - allocated_size) * nb_component));
allocated_size = size_to_alloc;
values = tmp_ptr;
}
if (fill && this->size_ < new_size) {
std::uninitialized_fill(values + size_ * nb_component,
values + new_size * nb_component, val);
}
size_ = new_size;
// AKANTU_DEBUG_OUT();
}
/* -------------------------------------------------------------------------- */
/**
* change the number of components by interlacing data
* @param multiplicator number of interlaced components add
* @param block_size blocks of data in the array
* Examaple for block_size = 2, multiplicator = 2
* array = oo oo oo -> new array = oo nn nn oo nn nn oo nn nn */
template <class T, bool is_scal>
void Array<T, is_scal>::extendComponentsInterlaced(UInt multiplicator,
UInt block_size) {
AKANTU_DEBUG_IN();
if (multiplicator == 1)
return;
AKANTU_DEBUG_ASSERT(multiplicator > 1, "invalid multiplicator");
AKANTU_DEBUG_ASSERT(nb_component % block_size == 0,
"stride must divide actual number of components");
values = static_cast<T *>(
realloc(values, nb_component * multiplicator * size_ * sizeof(T)));
UInt new_component = nb_component / block_size * multiplicator;
for (UInt i = 0, k = size_ - 1; i < size_; ++i, --k) {
for (UInt j = 0; j < new_component; ++j) {
UInt m = new_component - j - 1;
UInt n = m / multiplicator;
for (UInt l = 0, p = block_size - 1; l < block_size; ++l, --p) {
values[k * nb_component * multiplicator + m * block_size + p] =
values[k * nb_component + n * block_size + p];
}
}
}
nb_component = nb_component * multiplicator;
AKANTU_DEBUG_OUT();
}
/* -------------------------------------------------------------------------- */
/**
* search elem in the array, return the position of the first occurrence or
* -1 if not found
* @param elem the element to look for
* @return index of the first occurrence of elem or -1 if elem is not present
*/
template <class T, bool is_scal>
UInt Array<T, is_scal>::find(const T & elem) const {
AKANTU_DEBUG_IN();
auto begin = this->begin();
auto end = this->end();
auto it = std::find(begin, end, elem);
AKANTU_DEBUG_OUT();
return (it != end) ? it - begin : UInt(-1);
}
/* -------------------------------------------------------------------------- */
template <class T, bool is_scal> UInt Array<T, is_scal>::find(T elem[]) const {
AKANTU_DEBUG_IN();
T * it = values;
UInt i = 0;
for (; i < size_; ++i) {
if (*it == elem[0]) {
T * cit = it;
UInt c = 0;
for (; (c < nb_component) && (*cit == elem[c]); ++c, ++cit)
;
if (c == nb_component) {
AKANTU_DEBUG_OUT();
return i;
}
}
it += nb_component;
}
return UInt(-1);
}
/* -------------------------------------------------------------------------- */
template <class T, bool is_scal>
template <template <typename> class C>
inline UInt Array<T, is_scal>::find(const C<T> & elem) {
AKANTU_DEBUG_ASSERT(elem.size() == nb_component,
"Cannot find an element with a wrong size ("
<< elem.size() << ") != " << nb_component);
return this->find(elem.storage());
}
/* -------------------------------------------------------------------------- */
/**
* copy the content of another array. This overwrites the current content.
* @param other Array to copy into this array. It has to have the same
* nb_component as this. If compiled in debug mode, an incorrect other will
* result in an exception being thrown. Optimised code may result in
* unpredicted behaviour.
*/
template <class T, bool is_scal>
void Array<T, is_scal>::copy(const Array<T, is_scal> & vect,
bool no_sanity_check) {
AKANTU_DEBUG_IN();
if (!no_sanity_check)
if (vect.nb_component != nb_component)
AKANTU_DEBUG_ERROR(
"The two arrays do not have the same number of components");
resize((vect.size_ * vect.nb_component) / nb_component);
T * tmp = values;
std::uninitialized_copy(vect.storage(), vect.storage() + size_ * nb_component,
tmp);
AKANTU_DEBUG_OUT();
}
/* -------------------------------------------------------------------------- */
template <bool is_scal> class ArrayPrintHelper {
public:
template <typename T>
static void print_content(const Array<T> & vect, std::ostream & stream,
int indent) {
if (AKANTU_DEBUG_TEST(dblDump) || AKANTU_DEBUG_LEVEL_IS_TEST()) {
std::string space;
for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
;
stream << space << " + values : {";
for (UInt i = 0; i < vect.size(); ++i) {
stream << "{";
for (UInt j = 0; j < vect.getNbComponent(); ++j) {
stream << vect(i, j);
if (j != vect.getNbComponent() - 1)
stream << ", ";
}
stream << "}";
if (i != vect.size() - 1)
stream << ", ";
}
stream << "}" << std::endl;
}
}
};
template <> class ArrayPrintHelper<false> {
public:
template <typename T>
static void print_content(__attribute__((unused)) const Array<T> & vect,
__attribute__((unused)) std::ostream & stream,
__attribute__((unused)) int indent) {}
};
/* -------------------------------------------------------------------------- */
template <class T, bool is_scal>
void Array<T, is_scal>::printself(std::ostream & stream, int indent) const {
std::string space;
for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
;
std::streamsize prec = stream.precision();
std::ios_base::fmtflags ff = stream.flags();
stream.setf(std::ios_base::showbase);
stream.precision(2);
stream << space << "Array<" << debug::demangle(typeid(T).name()) << "> ["
<< std::endl;
stream << space << " + id : " << this->id << std::endl;
stream << space << " + size : " << this->size_ << std::endl;
stream << space << " + nb_component : " << this->nb_component << std::endl;
stream << space << " + allocated size : " << this->allocated_size
<< std::endl;
stream << space << " + memory size : "
<< printMemorySize<T>(allocated_size * nb_component) << std::endl;
if (!AKANTU_DEBUG_LEVEL_IS_TEST())
stream << space << " + address : " << std::hex << this->values
<< std::dec << std::endl;
stream.precision(prec);
stream.flags(ff);
ArrayPrintHelper<is_scal>::print_content(*this, stream, indent);
stream << space << "]" << std::endl;
}
/* -------------------------------------------------------------------------- */
/* Inline Functions ArrayBase */
/* -------------------------------------------------------------------------- */
inline UInt ArrayBase::getMemorySize() const {
return allocated_size * nb_component * size_of_type;
}
inline void ArrayBase::empty() { size_ = 0; }
/* -------------------------------------------------------------------------- */
/* Iterators */
/* -------------------------------------------------------------------------- */
template <class T, bool is_scal>
template <class R, class IR, bool is_r_scal>
class Array<T, is_scal>::iterator_internal {
public:
using value_type = R;
using pointer = R *;
using reference = R &;
using proxy = typename R::proxy;
using const_proxy = const typename R::proxy;
using const_reference = const R &;
using internal_value_type = IR;
using internal_pointer = IR *;
using difference_type = std::ptrdiff_t;
using iterator_category = std::random_access_iterator_tag;
public:
iterator_internal() : initial(NULL), ret(NULL), ret_ptr(NULL){};
iterator_internal(pointer_type data, UInt _offset)
: _offset(_offset), initial(data), ret(NULL), ret_ptr(data) {
AKANTU_DEBUG_ERROR(
"The constructor should never be called it is just an ugly trick...");
}
iterator_internal(pointer wrapped)
: _offset(wrapped->size()), initial(wrapped->storage()),
ret(const_cast<internal_pointer>(wrapped)),
ret_ptr(wrapped->storage()) {}
iterator_internal(const iterator_internal & it) {
if (this != &it) {
this->_offset = it._offset;
this->initial = it.initial;
this->ret_ptr = it.ret_ptr;
this->ret = new internal_value_type(*it.ret, false);
}
}
virtual ~iterator_internal() { delete ret; };
inline iterator_internal & operator=(const iterator_internal & it) {
if (this != &it) {
this->_offset = it._offset;
this->initial = it.initial;
this->ret_ptr = it.ret_ptr;
if (this->ret)
this->ret->shallowCopy(*it.ret);
else
this->ret = new internal_value_type(*it.ret, false);
}
return *this;
}
UInt getCurrentIndex() {
return (this->ret_ptr - this->initial) / this->_offset;
};
inline reference operator*() {
ret->values = ret_ptr;
return *ret;
};
inline const_reference operator*() const {
ret->values = ret_ptr;
return *ret;
};
inline pointer operator->() {
ret->values = ret_ptr;
return ret;
};
inline iterator_internal & operator++() {
ret_ptr += _offset;
return *this;
};
inline iterator_internal & operator--() {
ret_ptr -= _offset;
return *this;
};
inline iterator_internal & operator+=(const UInt n) {
ret_ptr += _offset * n;
return *this;
}
inline iterator_internal & operator-=(const UInt n) {
ret_ptr -= _offset * n;
return *this;
}
inline proxy operator[](const UInt n) {
ret->values = ret_ptr + n * _offset;
return proxy(*ret);
}
inline const_proxy operator[](const UInt n) const {
ret->values = ret_ptr + n * _offset;
return const_proxy(*ret);
}
inline bool operator==(const iterator_internal & other) const {
return this->ret_ptr == other.ret_ptr;
}
inline bool operator!=(const iterator_internal & other) const {
return this->ret_ptr != other.ret_ptr;
}
inline bool operator<(const iterator_internal & other) const {
return this->ret_ptr < other.ret_ptr;
}
inline bool operator<=(const iterator_internal & other) const {
return this->ret_ptr <= other.ret_ptr;
}
inline bool operator>(const iterator_internal & other) const {
return this->ret_ptr > other.ret_ptr;
}
inline bool operator>=(const iterator_internal & other) const {
return this->ret_ptr >= other.ret_ptr;
}
inline iterator_internal operator+(difference_type n) {
iterator_internal tmp(*this);
tmp += n;
return tmp;
}
inline iterator_internal operator-(difference_type n) {
iterator_internal tmp(*this);
tmp -= n;
return tmp;
}
inline difference_type operator-(const iterator_internal & b) {
return (this->ret_ptr - b.ret_ptr) / _offset;
}
inline pointer_type data() const { return ret_ptr; }
inline difference_type offset() const { return _offset; }
protected:
UInt _offset{0};
pointer_type initial;
internal_pointer ret;
pointer_type ret_ptr;
};
/* -------------------------------------------------------------------------- */
/**
* Specialization for scalar types
*/
template <class T, bool is_scal>
template <class R, class IR>
class Array<T, is_scal>::iterator_internal<R, IR, true> {
public:
using value_type = R;
using pointer = R *;
using reference = R &;
using const_reference = const R &;
using internal_value_type = IR;
using internal_pointer = IR *;
using difference_type = std::ptrdiff_t;
using iterator_category = std::random_access_iterator_tag;
public:
iterator_internal(pointer data = nullptr, UInt _offset = 1)
: _offset(_offset), ret(data), initial(data){};
iterator_internal(const iterator_internal & it) = default;
iterator_internal(iterator_internal && it) = default;
virtual ~iterator_internal() = default;
inline iterator_internal & operator=(const iterator_internal & it) = default;
UInt getCurrentIndex() {
return (this->ret - this->initial) / this->_offset;
};
inline reference operator*() { return *ret; };
inline const_reference operator*() const { return *ret; };
inline pointer operator->() { return ret; };
inline iterator_internal & operator++() {
++ret;
return *this;
};
inline iterator_internal & operator--() {
--ret;
return *this;
};
inline iterator_internal & operator+=(const UInt n) {
ret += n;
return *this;
}
inline iterator_internal & operator-=(const UInt n) {
ret -= n;
return *this;
}
inline reference operator[](const UInt n) { return ret[n]; }
inline bool operator==(const iterator_internal & other) const {
return ret == other.ret;
}
inline bool operator!=(const iterator_internal & other) const {
return ret != other.ret;
}
inline bool operator<(const iterator_internal & other) const {
return ret < other.ret;
}
inline bool operator<=(const iterator_internal & other) const {
return ret <= other.ret;
}
inline bool operator>(const iterator_internal & other) const {
return ret > other.ret;
}
inline bool operator>=(const iterator_internal & other) const {
return ret >= other.ret;
}
inline iterator_internal operator-(difference_type n) {
return iterator_internal(ret - n);
}
inline iterator_internal operator+(difference_type n) {
return iterator_internal(ret + n);
}
inline difference_type operator-(const iterator_internal & b) {
return ret - b.ret;
}
inline pointer data() const { return ret; }
inline difference_type offset() const { return _offset; }
protected:
difference_type _offset;
pointer ret;
pointer initial;
};
/* -------------------------------------------------------------------------- */
/* Begin/End functions implementation */
/* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-/**
- * Get an iterator that behaves like a pointer akantu::Vector<T> * to the
- * first tuple of the array.
- * @param n vector size. Has to be equal to nb_component. This unfortunate
- * redundancy is necessary to distinguish it from ::begin() which it
- * overloads. If compiled in debug mode, an incorrect value of n will result
- * in an exception being thrown. Optimized code will fail in an unpredicted
- * manner.
- * @return a vector_iterator
- */
-template <class T, bool is_scal>
-inline typename Array<T, is_scal>::vector_iterator
-Array<T, is_scal>::begin(UInt n) {
- AKANTU_DEBUG_ASSERT(nb_component == n,
- "The iterator is not compatible with the type Array("
- << n << ")");
- return vector_iterator(new Vector<T>(values, n));
-}
-
-/* -------------------------------------------------------------------------- */
-/**
- * Get an iterator that behaves like a pointer akantu::Vector<T> * pointing
- * *past* the last tuple of the array.
- * @param n vector size. see Array::begin(UInt n) for more
- * @return a vector_iterator
- */
-template <class T, bool is_scal>
-inline typename Array<T, is_scal>::vector_iterator
-Array<T, is_scal>::end(UInt n) {
- AKANTU_DEBUG_ASSERT(nb_component == n,
- "The iterator is not compatible with the type Array("
- << n << ")");
- return vector_iterator(new Vector<T>(values + nb_component * size_, n));
-}
-
-/* -------------------------------------------------------------------------- */
-/**
- * Get a const iterator that behaves like a pointer akantu::Vector<T> * to the
- * first tuple of the array.
- * @param n vector size. see Array::begin(UInt n) for more
- * @return a vector_iterator
- */
-template <class T, bool is_scal>
-inline typename Array<T, is_scal>::const_vector_iterator
-Array<T, is_scal>::begin(UInt n) const {
- AKANTU_DEBUG_ASSERT(nb_component == n,
- "The iterator is not compatible with the type Array("
- << n << ")");
- return const_vector_iterator(new Vector<T>(values, n));
-}
-
-/* -------------------------------------------------------------------------- */
-/**
- * Get a const iterator that behaves like a pointer akantu::Vector<T> * pointing
- * *past* the last tuple of the array.
- * @param n vector size. see Array::begin(UInt n) for more
- * @return a const_vector_iterator
- */
-template <class T, bool is_scal>
-inline typename Array<T, is_scal>::const_vector_iterator
-Array<T, is_scal>::end(UInt n) const {
- AKANTU_DEBUG_ASSERT(nb_component == n,
- "The iterator is not compatible with the type Array("
- << n << ")");
- return const_vector_iterator(new Vector<T>(values + nb_component * size_, n));
-}
-
-/* -------------------------------------------------------------------------- */
-/**
- * Get an iterator that behaves like a pointer akantu::Vector<T> * to the
- * first tuple of the array.
- *
- * The reinterpret iterators allow to iterate over an array in any way that
- * preserves the number of entries of the array. This can for instance be use
- * full if the shape of the data in an array is not initially known.
- * @param n vector size.
- * @param size number of tuples in array. n times size must match the number
- * of entries of the array. If compiled in debug mode, an incorrect
- * combination of n and size will result
- * in an exception being thrown. Optimized code will fail in an unpredicted
- * manner.
- * @return a vector_iterator
- */
-template <class T, bool is_scal>
-inline typename Array<T, is_scal>::vector_iterator
-Array<T, is_scal>::begin_reinterpret(UInt n,
- __attribute__((unused)) UInt size) {
- AKANTU_DEBUG_ASSERT(n * size == this->nb_component * this->size_,
- "The new values for size ("
- << size << ") and nb_component (" << n
- << ") are not compatible with the one of this array("
- << this->size_ << "," << this->nb_component << ")");
- return vector_iterator(new Vector<T>(values, n));
-}
-
-/* -------------------------------------------------------------------------- */
-/**
- * Get an iterator that behaves like a pointer akantu::Vector<T> * pointing
- * *past* the last tuple of the array.
- * @param n vector size.
- * @param size number of tuples in array. See Array::begin_reinterpret(UInt n,
- * UInt size)
- * @return a vector_iterator
- */
-template <class T, bool is_scal>
-inline typename Array<T, is_scal>::vector_iterator
-Array<T, is_scal>::end_reinterpret(UInt n, UInt size) {
- AKANTU_DEBUG_ASSERT(n * size == this->nb_component * this->size_,
- "The new values for size ("
- << size << ") and nb_component (" << n
- << ") are not compatible with the one of this array("
- << this->size_ << "," << this->nb_component << ")");
- return vector_iterator(new Vector<T>(values + n * size, n));
-}
-
-/* -------------------------------------------------------------------------- */
-/**
- * Get a const iterator that behaves like a pointer akantu::Vector<T> * to the
- * first tuple of the array.
- * @param n vector size.
- * @param size number of tuples in array. See Array::begin_reinterpret(UInt n,
- * UInt size)
- * @return a const_vector_iterator
- */
-template <class T, bool is_scal>
-inline typename Array<T, is_scal>::const_vector_iterator
-Array<T, is_scal>::begin_reinterpret(UInt n,
- __attribute__((unused)) UInt size) const {
- AKANTU_DEBUG_ASSERT(n * size == this->nb_component * this->size_,
- "The new values for size ("
- << size << ") and nb_component (" << n
- << ") are not compatible with the one of this array("
- << this->size_ << "," << this->nb_component << ")");
- return const_vector_iterator(new Vector<T>(values, n));
-}
-
-/* -------------------------------------------------------------------------- */
-/**
- * Get a const iterator that behaves like a pointer akantu::Vector<T> * pointing
- * *past* the last tuple of the array.
- * @param n vector size.
- * @param size number of tuples in array. See Array::begin_reinterpret(UInt n,
- * UInt size)
- * @return a const_vector_iterator
- */
-template <class T, bool is_scal>
-inline typename Array<T, is_scal>::const_vector_iterator
-Array<T, is_scal>::end_reinterpret(UInt n, UInt size) const {
- AKANTU_DEBUG_ASSERT(n * size == this->nb_component * this->size_,
- "The new values for size ("
- << size << ") and nb_component (" << n
- << ") are not compatible with the one of this array("
- << this->size_ << "," << this->nb_component << ")");
- return const_vector_iterator(new Vector<T>(values + n * size, n));
-}
-
-/* -------------------------------------------------------------------------- */
-/**
- * Get an iterator that behaves like a pointer akantu::Matrix<T> * to the
- * first tuple of the array.
- * @param m number of rows
- * @param n number of columns. m times n has to equal nb_component.
- * If compiled in debug mode, an incorrect combination of m and n will result
- * in an exception being thrown. Optimized code will fail in an unpredicted
- * manner.
- * @return a matrix_iterator
- */
-template <class T, bool is_scal>
-inline typename Array<T, is_scal>::matrix_iterator
-Array<T, is_scal>::begin(UInt m, UInt n) {
- AKANTU_DEBUG_ASSERT(nb_component == n * m,
- "The iterator is not compatible with the type Matrix("
- << m << "," << n << ")");
- return matrix_iterator(new Matrix<T>(values, m, n));
-}
-
-/* -------------------------------------------------------------------------- */
-/**
- * Get an iterator that behaves like a pointer akantu::Matrix<T> * pointing
- * *past* the last tuple of the array.
- * @param m number of rows
- * @param n number of columns. See Array::begin(UInt m, UInt n)
- * @return a matrix_iterator
- */
-template <class T, bool is_scal>
-inline typename Array<T, is_scal>::matrix_iterator
-Array<T, is_scal>::end(UInt m, UInt n) {
- AKANTU_DEBUG_ASSERT(nb_component == n * m,
- "The iterator is not compatible with the type Matrix("
- << m << "," << n << ")");
- return matrix_iterator(new Matrix<T>(values + nb_component * size_, m, n));
-}
+namespace {
+ template <std::size_t N> struct extract_last {
+ template <typename F, typename... T, typename... Arg>
+ static decltype(auto) extract(F && func, std::tuple<T...> && t,
+ Arg... args) {
+ return extract_last<N - 1>::extract(
+ std::forward<F>(func), std::forward<decltype(t)>(t),
+ std::get<sizeof...(T) - N>(std::forward<decltype(t)>(t)), args...);
+ }
+ };
-/* -------------------------------------------------------------------------- */
-/**
- * Get a const iterator that behaves like a pointer akantu::Matrix<T> * to the
- * first tuple of the array.
- * @param m number of rows
- * @param n number of columns. See Array::begin(UInt m, UInt n)
- * @return a matrix_iterator
- */
-template <class T, bool is_scal>
-inline typename Array<T, is_scal>::const_matrix_iterator
-Array<T, is_scal>::begin(UInt m, UInt n) const {
- AKANTU_DEBUG_ASSERT(nb_component == n * m,
- "The iterator is not compatible with the type Matrix("
- << m << "," << n << ")");
- return const_matrix_iterator(new Matrix<T>(values, m, n));
-}
+ template <> struct extract_last<1> {
+ template <typename F, typename... T, typename... Arg>
+ static decltype(auto) extract(F && func, std::tuple<T...> && /*unused*/,
+ Arg... args) {
+ return std::forward<F>(func)(args...);
+ }
+ };
-/* -------------------------------------------------------------------------- */
-/**
- * Get a const iterator that behaves like a pointer akantu::Matrix<T> * pointing
- * *past* the last tuple of the array.
- * @param m number of rows
- * @param n number of columns. See Array::begin(UInt m, UInt n)
- * @return a const_matrix_iterator
- */
-template <class T, bool is_scal>
-inline typename Array<T, is_scal>::const_matrix_iterator
-Array<T, is_scal>::end(UInt m, UInt n) const {
- AKANTU_DEBUG_ASSERT(nb_component == n * m,
- "The iterator is not compatible with the type Matrix("
- << m << "," << n << ")");
- return const_matrix_iterator(
- new Matrix<T>(values + nb_component * size_, m, n));
-}
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnarrowing"
+ template <std::size_t N> struct InstantiationHelper {
+ template <typename... Ns> static constexpr std::size_t product(Ns... ns) {
+ std::size_t p = 1;
+ for (auto n : std::array<std::size_t, sizeof...(Ns)>{ns...})
+ p *= n;
+ return p;
+ }
-/* -------------------------------------------------------------------------- */
-/**
- * Get an iterator that behaves like a pointer akantu::Matrix<T> * to the
- * first tuple of the array.
- *
- * The reinterpret iterators allow to iterate over an array in any way that
- * preserves the number of entries of the array. This can for instance be use
- * full if the shape of the data in an array is not initially known.
- * @param m number of rows
- * @param n number of columns
- * @param size number of tuples in array. m times n times size must match the
- *number
- * of entries of the array. If compiled in debug mode, an incorrect
- * combination of m, n and size will result
- * in an exception being thrown. Optimized code will fail in an unpredicted
- * manner.
- * @return a matrix_iterator
- */
-template <class T, bool is_scal>
-inline typename Array<T, is_scal>::matrix_iterator
-Array<T, is_scal>::begin_reinterpret(UInt m, UInt n,
- __attribute__((unused)) UInt size) {
- AKANTU_DEBUG_ASSERT(n * m * size == this->nb_component * this->size_,
- "The new values for size ("
- << size << ") and nb_component (" << m << "," << n
- << " = " << n * m
- << ") are not compatible with the one of this array("
- << this->size_ << "," << this->nb_component << ")");
- return matrix_iterator(new Matrix<T>(values, m, n));
-}
+ template <typename... Ns> static std::string to_string(Ns... ns) {
+ std::stringstream sstr;
+ bool first = true;
+ sstr << "(";
+ for (auto n : std::array<std::size_t, sizeof...(Ns)>{ns...}) {
+ if (!first) {
+ sstr << ", ";
+ }
+ sstr << n;
+ first = false;
+ }
+ sstr << ")";
+ return sstr.str();
+ }
+#pragma GCC diagnostic pop
+ template <typename type, typename T, typename... Ns>
+ static auto instantiate(T && data, Ns... ns) {
+ return new type(data, ns...);
+ }
+ };
-/* -------------------------------------------------------------------------- */
-/**
- * Get an iterator that behaves like a pointer akantu::Matrix<T> * pointing
- * *past* the last tuple of the array.
- * @param m number of rows
- * @param n number of columns
- * @param size number of tuples in array. See Array::begin_reinterpret(UInt m,
- * UInt n, UInt size)
- * @return a matrix_iterator
- */
-template <class T, bool is_scal>
-inline typename Array<T, is_scal>::matrix_iterator
-Array<T, is_scal>::end_reinterpret(UInt m, UInt n, UInt size) {
- AKANTU_DEBUG_ASSERT(n * m * size == this->nb_component * this->size_,
- "The new values for size ("
- << size << ") and nb_component (" << m << "," << n
- << " = " << n * m
- << ") are not compatible with the one of this array("
- << this->size_ << "," << this->nb_component << ")");
- return matrix_iterator(new Matrix<T>(values + n * m * size, m, n));
-}
+ template <> struct InstantiationHelper<0> {
+ template <typename type, typename T> static auto instantiate(T && data) {
+ return data;
+ }
-/* -------------------------------------------------------------------------- */
-/**
- * Get a const iterator that behaves like a pointer akantu::Matrix<T> * to the
- * first tuple of the array.
- * @param m number of rows
- * @param n number of columns
- * @param size number of tuples in array. See Array::begin_reinterpret(UInt m,
- * UInt n, UInt size)
- * @return a const_matrix_iterator
- */
-template <class T, bool is_scal>
-inline typename Array<T, is_scal>::const_matrix_iterator
-Array<T, is_scal>::begin_reinterpret(UInt m, UInt n,
- __attribute__((unused)) UInt size) const {
- AKANTU_DEBUG_ASSERT(n * m * size == this->nb_component * this->size_,
- "The new values for size ("
- << size << ") and nb_component (" << m << "," << n
- << " = " << n * m
- << ") are not compatible with the one of this array("
- << this->size_ << "," << this->nb_component << ")");
- return const_matrix_iterator(new Matrix<T>(values, m, n));
-}
+ static constexpr std::size_t product() { return 1; }
+ static std::string to_string() { return ""; }
+ };
-/* -------------------------------------------------------------------------- */
-/**
- * Get a const iterator that behaves like a pointer akantu::Matrix<T> * pointing
- * *past* the last tuple of the array.
- * @param m number of rows
- * @param n number of columns
- * @param size number of tuples in array. See Array::begin_reinterpret(UInt m,
- * UInt n, UInt size)
- * @return a const_matrix_iterator
- */
-template <class T, bool is_scal>
-inline typename Array<T, is_scal>::const_matrix_iterator
-Array<T, is_scal>::end_reinterpret(UInt m, UInt n, UInt size) const {
- AKANTU_DEBUG_ASSERT(n * m * size == this->nb_component * this->size_,
- "The new values for size ("
- << size << ") and nb_component (" << m << "," << n
- << " = " << n * m
- << ") are not compatible with the one of this array("
- << this->size_ << "," << this->nb_component << ")");
- return const_matrix_iterator(new Matrix<T>(values + n * m * size, m, n));
-}
+ template <typename Arr, typename T, typename... Ns>
+ decltype(auto) get_iterator(Arr && array, T * data, Ns... ns) {
+ using type = IteratorHelper_t<sizeof...(Ns) -1, T>;
+ using array_type = std::decay_t<Arr>;
+ using iterator =
+ std::conditional_t<std::is_const<Arr>::value,
+ typename array_type::template const_iterator<type>,
+ typename array_type::template iterator<type>>;
+ AKANTU_DEBUG_ASSERT(
+ array.getNbComponent() * array.size() ==
+ InstantiationHelper<sizeof...(Ns)>::product(ns...),
+ "The iterator is not compatible with the type "
+ << debug::demangle(typeid(type).name())
+ << InstantiationHelper<sizeof...(Ns)>::to_string(ns...));
+ auto && wrapped = extract_last<sizeof...(Ns)>::extract(
+ [&](auto... n) {
+ return InstantiationHelper<sizeof...(n)>::template instantiate<type>(
+ data, n...);
+ },
+ std::make_tuple(ns...));
+
+ return iterator{wrapped};
+ }
+} // namespace
/* -------------------------------------------------------------------------- */
-/** Get an iterator that behaves like a pointer T * to the
- * first entry in the member array values
- * @return a scalar_iterator
- */
template <class T, bool is_scal>
-inline typename Array<T, is_scal>::scalar_iterator Array<T, is_scal>::begin() {
- AKANTU_DEBUG_ASSERT(
- nb_component == 1,
- "this iterator cannot be used on a vector which has nb_component != 1");
- return scalar_iterator(values);
+template <typename... Ns>
+inline decltype(auto) Array<T, is_scal>::begin(Ns... ns) {
+ return get_iterator(*this, values, ns..., size_);
}
-/* -------------------------------------------------------------------------- */
-/*! Get an iterator that behaves like a pointer T * that points *past* the
- * last entry in the member array values
- * @return a scalar_iterator
- */
template <class T, bool is_scal>
-inline typename Array<T, is_scal>::scalar_iterator Array<T, is_scal>::end() {
- AKANTU_DEBUG_ASSERT(
- nb_component == 1,
- "this iterator cannot be used on a array which has nb_component != 1");
- return scalar_iterator(values + size_);
+template <typename... Ns>
+inline decltype(auto) Array<T, is_scal>::end(Ns... ns) {
+ return get_iterator(*this, values + nb_component * size_, ns..., size_);
}
-/* -------------------------------------------------------------------------- */
-/*! Get a const iterator that behaves like a pointer T * to the
- * first entry in the member array values
- * @return a const_scalar_iterator
- */
template <class T, bool is_scal>
-inline typename Array<T, is_scal>::const_scalar_iterator
-Array<T, is_scal>::begin() const {
- AKANTU_DEBUG_ASSERT(
- nb_component == 1,
- "this iterator cannot be used on a array which has nb_component != 1");
- return const_scalar_iterator(values);
+template <typename... Ns>
+inline decltype(auto) Array<T, is_scal>::begin(Ns... ns) const {
+ return get_iterator(*this, values, ns..., size_);
}
-/* -------------------------------------------------------------------------- */
-/*! Get a const iterator that behaves like a pointer T * that points *past* the
- * last entry in the member array values
- * @return a const_scalar_iterator
- */
template <class T, bool is_scal>
-inline typename Array<T, is_scal>::const_scalar_iterator
-Array<T, is_scal>::end() const {
- AKANTU_DEBUG_ASSERT(
- nb_component == 1,
- "this iterator cannot be used on a array which has nb_component != 1");
- return const_scalar_iterator(values + size_);
+template <typename... Ns>
+inline decltype(auto) Array<T, is_scal>::end(Ns... ns) const {
+ return get_iterator(*this, values + nb_component * size_, ns..., size_);
}
-/* -------------------------------------------------------------------------- */
template <class T, bool is_scal>
-inline typename Array<T, is_scal>::scalar_iterator
-Array<T, is_scal>::begin_reinterpret(__attribute__((unused)) UInt new_size) {
- AKANTU_DEBUG_ASSERT(new_size == this->nb_component * this->size_,
- "The new values for size ("
- << new_size
- << ") is not compatible with the one of this array("
- << this->size_ << "," << this->nb_component << ")");
- return scalar_iterator(values);
+template <typename... Ns>
+inline decltype(auto) Array<T, is_scal>::begin_reinterpret(Ns... ns) {
+ return get_iterator(*this, values, ns...);
}
-/* -------------------------------------------------------------------------- */
template <class T, bool is_scal>
-inline typename Array<T, is_scal>::scalar_iterator
-Array<T, is_scal>::end_reinterpret(UInt new_size) {
- AKANTU_DEBUG_ASSERT(new_size == this->nb_component * this->size_,
- "The new values for size ("
- << new_size
- << ") is not compatible with the one of this array("
- << this->size_ << "," << this->nb_component << ")");
- return scalar_iterator(values + new_size);
+template <typename... Ns>
+inline decltype(auto) Array<T, is_scal>::end_reinterpret(Ns... ns) {
+ return get_iterator(
+ *this, values + InstantiationHelper<sizeof...(Ns)>::product(ns...),
+ ns...);
}
-/* -------------------------------------------------------------------------- */
template <class T, bool is_scal>
-inline typename Array<T, is_scal>::const_scalar_iterator
-Array<T, is_scal>::begin_reinterpret(__attribute__((unused))
- UInt new_size) const {
- AKANTU_DEBUG_ASSERT(new_size == this->nb_component * this->size_,
- "The new values for size ("
- << new_size
- << ") is not compatible with the one of this array("
- << this->size_ << "," << this->nb_component << ")");
- return const_scalar_iterator(values);
+template <typename... Ns>
+inline decltype(auto) Array<T, is_scal>::begin_reinterpret(Ns... ns) const {
+ return get_iterator(*this, values, ns...);
}
-/* -------------------------------------------------------------------------- */
template <class T, bool is_scal>
-inline typename Array<T, is_scal>::const_scalar_iterator
-Array<T, is_scal>::end_reinterpret(UInt new_size) const {
- AKANTU_DEBUG_ASSERT(new_size == this->nb_component * this->size_,
- "The new values for size ("
- << new_size
- << ") is not compatible with the one of this array("
- << this->size_ << "," << this->nb_component << ")");
- return const_scalar_iterator(values + new_size);
+template <typename... Ns>
+inline decltype(auto) Array<T, is_scal>::end_reinterpret(Ns... ns) const {
+ return get_iterator(
+ *this, values + InstantiationHelper<sizeof...(Ns)>::product(ns...),
+ ns...);
}
/* -------------------------------------------------------------------------- */
template <class T, bool is_scal>
template <typename R>
class Array<T, is_scal>::const_iterator : public iterator_internal<const R, R> {
public:
typedef iterator_internal<const R, R> parent;
using value_type = typename parent::value_type;
using pointer = typename parent::pointer;
using reference = typename parent::reference;
using difference_type = typename parent::difference_type;
using iterator_category = typename parent::iterator_category;
public:
const_iterator() : parent(){};
const_iterator(pointer_type data, UInt offset) : parent(data, offset) {}
const_iterator(pointer warped) : parent(warped) {}
const_iterator(const parent & it) : parent(it) {}
// const_iterator(const const_iterator<R> & it) : parent(it) {}
inline const_iterator operator+(difference_type n) {
return parent::operator+(n);
}
inline const_iterator operator-(difference_type n) {
return parent::operator-(n);
}
inline difference_type operator-(const const_iterator & b) {
return parent::operator-(b);
}
inline const_iterator & operator++() {
parent::operator++();
return *this;
};
inline const_iterator & operator--() {
parent::operator--();
return *this;
};
inline const_iterator & operator+=(const UInt n) {
parent::operator+=(n);
return *this;
}
};
// #endif
// #if defined(AKANTU_CORE_CXX11)
// template<class R> using iterator = iterator_internal<R>;
// #else
template <class T, class R, bool issame = is_same<T, R>::value>
struct ConstConverterIteratorHelper {
using const_iterator = typename Array<T>::template const_iterator<R>;
using iterator = typename Array<T>::template iterator<R>;
static inline const_iterator convert(const iterator & it) {
return const_iterator(new R(*it, false));
}
};
template <class T, class R> struct ConstConverterIteratorHelper<T, R, true> {
using const_iterator = typename Array<T>::template const_iterator<R>;
using iterator = typename Array<T>::template iterator<R>;
static inline const_iterator convert(const iterator & it) {
return const_iterator(it.data(), it.offset());
}
};
template <class T, bool is_scal>
template <typename R>
class Array<T, is_scal>::iterator : public iterator_internal<R> {
public:
using parent = iterator_internal<R>;
using value_type = typename parent::value_type;
using pointer = typename parent::pointer;
using reference = typename parent::reference;
using difference_type = typename parent::difference_type;
using iterator_category = typename parent::iterator_category;
public:
iterator() : parent(){};
iterator(pointer_type data, UInt offset) : parent(data, offset){};
iterator(pointer warped) : parent(warped) {}
iterator(const parent & it) : parent(it) {}
// iterator(const iterator<R> & it) : parent(it) {}
operator const_iterator<R>() {
return ConstConverterIteratorHelper<T, R>::convert(*this);
}
inline iterator operator+(difference_type n) {
return parent::operator+(n);
;
}
inline iterator operator-(difference_type n) {
return parent::operator-(n);
;
}
inline difference_type operator-(const iterator & b) {
return parent::operator-(b);
}
inline iterator & operator++() {
parent::operator++();
return *this;
};
inline iterator & operator--() {
parent::operator--();
return *this;
};
inline iterator & operator+=(const UInt n) {
parent::operator+=(n);
return *this;
}
};
/* -------------------------------------------------------------------------- */
template <class T, bool is_scal>
template <typename R>
inline typename Array<T, is_scal>::template iterator<R>
Array<T, is_scal>::erase(const iterator<R> & it) {
T * curr = it.data();
UInt pos = (curr - values) / nb_component;
erase(pos);
iterator<R> rit = it;
return --rit;
}
} // namespace akantu
#endif /* __AKANTU_AKA_ARRAY_TMPL_HH__ */