Homec4science
Diffusion LibMultiScale (features/components) Browse

libmultiscale/src/container/container_array.hh
b05d5f2aba78features/components

Last Change
Raw File

container_array.hh
View Options

/**
* @file container_array.hh
*
* @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
*
* @date Thu Jul 24 14:21:58 2014
*
* @brief This is the contiguous array-like container for LM
*
* @section LICENSE
*
* Copyright INRIA and CEA
*
* The LibMultiScale is a C++ parallel framework for the multiscale
* coupling methods dedicated to material simulations. This framework
* provides an API which makes it possible to program coupled simulations
* and integration of already existing codes.
*
* This Project was initiated in a collaboration between INRIA Futurs Bordeaux
* within ScAlApplix team and CEA/DPTA Ile de France.
* The project is now continued at the Ecole Polytechnique Fédérale de Lausanne
* within the LSMS/ENAC laboratory.
*
* This software is governed by the CeCILL-C license under French law and
* abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL-C
* license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
*
* As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
* liability.
*
* In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
*
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL-C license and that you accept its terms.
*
*/
#ifndef __LIBMULTISCALE_CONTAINER_ARRAY_HH__
#define __LIBMULTISCALE_CONTAINER_ARRAY_HH__
/* -------------------------------------------------------------------------- */
#include <vector>
#include <algorithm>
#include "container.hh"
/* -------------------------------------------------------------------------- */
#ifdef TRACE_ATOM
#include "trace_atom.hh"
#include "lammps/ref_atom_lammps.hh"
#endif
/* -------------------------------------------------------------------------- */
__BEGIN_LIBMULTISCALE__
/**
* Class ContainerArray<T>
* array implementation of a generic container
*/
/* -------------------------------------------------------------------------- */
template <class T> class GetDim{
public:
static const UInt Dim = T::Dim;
};
template <> class GetDim<Real>{
public:
static const UInt Dim = 1;
};
template <> class GetDim<UInt>{
public:
static const UInt Dim = 1;
};
/* -------------------------------------------------------------------------- */
template <class T>
class ContainerArray : public Container_base<T>
{
/* ------------------------------------------------------------------------ */
/* Typedefs */
/* ------------------------------------------------------------------------ */
public:
class iterator;
static const UInt Dim = GetDim<T>::Dim;
/* ------------------------------------------------------------------------ */
/* Constructors/Destructors */
/* ------------------------------------------------------------------------ */
ContainerArray();
~ContainerArray();
/* ------------------------------------------------------------------------ */
/* Methods */
/* ------------------------------------------------------------------------ */
//! return an associated iterator
virtual iterator getIterator(DOFType dt = dt_local, UInt stride = 1);
//! sort items
virtual void sort();
//! search for a given item
virtual UInt search(T & el);
//! add a particular item
virtual void add(const T & el);
//! add a particular item
virtual void push_back(const T & el);
//! search for a given item in a previously sorted array
UInt searchInSorted(T & el);
//! add an entry in a sorted array
void addInSorted(T & el);
//! resize the container (by clearing the additional values)
virtual void resize(UInt size);
//! resize the container (by clearing the additional values)
virtual void assign(UInt size,T val);
//! get an item from its index
virtual T & get (UInt index);
//! get an item from its index
virtual T & operator[](UInt index);
//! return the number of contained items
virtual UInt nbElem(DOFType dt = dt_local);
//! function that clear the container
virtual void empty();
//! function that clear the container
virtual void clear();
//! get internal array
virtual std::vector<T> & getArray(){return array;};
//! implicit cast to std array
operator std::vector<T>&(){
return array;
};
protected:
//! resize the array
virtual void reserve(UInt taille);
/* ------------------------------------------------------------------------ */
/* Class Members */
/* ------------------------------------------------------------------------ */
protected:
//! internal array
std::vector<T> array;
//! minimal allocation size
static const UInt MIN_SIZE = 100;
};
/* -------------------------------------------------------------------------- */
#include "iterator_array.hh"
/* -------------------------------------------------------------------------- */
template <typename T>
ContainerArray<T>::ContainerArray():Container_base<T>(){
array.reserve(MIN_SIZE);
}
/* -------------------------------------------------------------------------- */
template <typename T>
ContainerArray<T>::~ContainerArray(){
empty();
}
/* -------------------------------------------------------------------------- */
template <class T>
void ContainerArray<T>::sort(){
//std::sort(array.begin(),array.end());
LM_TOIMPLEMENT;
}
/* -------------------------------------------------------------------------- */
template <class T>
inline UInt ContainerArray<T>::nbElem(DOFType dt){
return array.size();
}
/* -------------------------------------------------------------------------- */
template <class T>
inline void ContainerArray<T>::empty(){
this->clear();
}
/* -------------------------------------------------------------------------- */
template <class T>
inline void ContainerArray<T>::clear(){
array.clear();
}
/* -------------------------------------------------------------------------- */
template <class T>
inline void ContainerArray<T>::reserve(UInt t){
array.reserve(t);
}
/* -------------------------------------------------------------------------- */
template <class T>
inline void ContainerArray<T>::resize(UInt size){
array.resize(size);
}
/* -------------------------------------------------------------------------- */
template <class T>
inline void ContainerArray<T>::assign(UInt size, T val){
array.assign(size,val);
}
/* -------------------------------------------------------------------------- */
template <class T>
inline void ContainerArray<T>::push_back(const T & el){
array.push_back(el);
}
/* -------------------------------------------------------------------------- */
template <class T>
inline void ContainerArray<T>::add(const T & el){
if (array.capacity() == array.size()) reserve(array.size()*2);
array.push_back(el);
}
/* -------------------------------------------------------------------------- */
// #ifdef TRACE_ATOM
// template <>
// inline void ContainerArray<RefLammps>::add(RefLammps & el){
// IF_REF_TRACED(el,"traced atom added at position "
// << array.size() << " in container "
// << this);
// if (array.capacity() == array.size()) reserve(array.size()*2);
// RefLammps * temp = new RefLammps(el);
// array.push_back(temp);
// }
// #endif
/* -------------------------------------------------------------------------- */
template <class T>
inline T & ContainerArray<T>::get(UInt index){
LM_ASSERT(index < nbElem(),
"out of range access : " << index << " over " << nbElem());
return array[index];
}
/* -------------------------------------------------------------------------- */
template <class T>
inline T & ContainerArray<T>::operator[](UInt index){
LM_ASSERT(index < nbElem(),
"out of range access : " << index << " over " << nbElem());
return array[index];
}
/* -------------------------------------------------------------------------- */
template <class T>
UInt ContainerArray<T>::search(T & el){
for (UInt i = 0 ; i < nbElem() ; ++i)
{
T & e = array[i];
if (el == e)
return i;
}
return UINT_MAX;
}
/* -------------------------------------------------------------------------- */
template <class T>
typename ContainerArray<T>::iterator ContainerArray<T>::getIterator(DOFType dt,
UInt stride){
typename ContainerArray<T>::iterator it(*this,stride);
return it;
}
/* -------------------------------------------------------------------------- */
template <class T>
inline void ContainerArray<T>::addInSorted(T & el){
// array.push_back(el);
UInt N = array.size();
UInt low = 0;
UInt high = N - 1;
UInt mid=0;
UInt i = 0;
if (N == 0){
array.push_back(el);
return;
}
while (low <= high)
{
mid = (low + high) / 2;
if (array[mid] > el){
if (mid == 0) break;
else high = mid-1;
}
else if (array[mid] < el){
low = mid + 1;
}
else return; // such element as already been inserted
}
mid = (low + high) / 2;
if (array[mid]<el)
++mid;
/* DUMP("low = " << low << " high = " << high << " mid = " << mid,DBG_MESSAGE); */
//shift all elements to insert at the right place the element we want
array.push_back(array[N-1]);
for (i = 0; i < N - mid ; ++i)
array[N-i] = array[N-1-i];
// for (i = N-1; i >= mid ; --i)
// array[i+1] = array[i];
/* DUMP("last decal : " << i << " -> " << i+1,DBG_MESSAGE); */
/* if (mid == 0){ */
/* DUMP("inserting " << el << " before " << array[mid+1] << "-" << mid,DBG_MESSAGE); */
/* } */
/* else if (mid == N){ */
/* DUMP("inserting " << el << " after " << array[mid] << "-" << mid,DBG_MESSAGE); */
/* } */
/* else */
/* DUMP("inserting " << el << " between " << array[mid-1] << " and " << array[mid+1] << "-" << mid,DBG_MESSAGE); */
array[mid] = el;
/* DUMP("now list look like",DBG_MESSAGE); */
/* for (UInt i = 0 ; i < nbElem() ; ++i) */
/* { */
/* DUMP("array[" << i << "]=" << array[i],DBG_MESSAGE); */
/* } */
}
/* -------------------------------------------------------------------------- */
template <class T>
UInt ContainerArray<T>::searchInSorted(T & el){
UInt N = array.size();
UInt low = 0;
UInt high = N - 1;
UInt mid=0;
while (low <= high && high != UINT_MAX)
{
mid = (low + high) / 2;
if (array[mid] > el) high = mid - 1;
else if (array[mid] < el)low = mid + 1;
else
return mid; // found
}
return UINT_MAX; // not found
}
/* -------------------------------------------------------------------------- */
__END_LIBMULTISCALE__
#endif /* __LIBMULTISCALE_CONTAINER_ARRAY_HH__ */
c4science · Help