array.h

crack modeling with xfem

/* 2008 (c) Dorival M. Pedroso */

#ifndef MPM_ARRAY_H
#define MPM_ARRAY_H

// STL
#include <algorithm> // for std::find, std::min_element, and std::max_element

// MechSys
#include "fatal.h"
#include "fmtnum.h"

template<typename Value_T>
class Array
{
public:
	// Constructors
	Array ()            : _values(NULL), _fn(&_8s) { Resize(0, 2); } ///< Constructor
	Array (size_t Size) : _values(NULL), _fn(&_8s) { Resize(Size); } ///< Alternative constructor
	Array (Array<Value_T> const & Other);                            ///< Copy constructor (needed when using Array< Array<...> >)

	/** Destructor. */
	~Array() { if (_values!=NULL) delete [] _values; }

	// Methods
	void            SetFN  (FmtNum & FN)                  { _fn = &FN; } ///< Set the FmtNum, a structure to aid format output of numbers
	FmtNum const  & FN     () const                   { return (*_fn); } ///< Return the FmtNum, a structure to aid format output of numbers
	size_t          Size   () const                    { return _size; } ///< Returns the size
	Value_T *       GetPtr ()                        { return _values; } ///< Returns a pointer to the values (write)
	Value_T const * GetPtr () const                  { return _values; } ///< Returns a pointer to the values (read)
	void            Resize (size_t  Size,  double SzFactor=1.2);         ///< Resize the array
	void            Push   (Value_T const & Value, double SzFactor=1.2); ///< Add a new entry increasing the size if necessary
	void            Remove (size_t i, size_t Length=1);                  ///< Remove item i from the array
	long            Find   (Value_T const & Value) const;                ///< Find a value: returns -1 if not found, otherwise, returns the index of the element found
	long            Min    () const;                                     ///< Find the minimum value: returns the index of the minimum element
	long            Max    () const;                                     ///< Find the maximum value: returns the index of the maximum element

	// Operators
	Value_T       & operator[] (size_t i);                 ///< Access operator (write)
	Value_T const & operator[] (size_t i) const;           ///< Access operator (read)
	void            operator=  (Array<Value_T> const & R); ///< Assignment operator (needed when using Array< Array<...> >)
	void            operator+= (Array<Value_T> const & R); ///< Plus-assignment operator
	void            operator-= (Array<Value_T> const & R); ///< Minus-assignment operator
	void            operator=  (Value_T        const & V); ///< Set all values equal to V

private:
	// Variables
	size_t    _size;   ///< Current number of components
	size_t    _space;  ///< Available space
	Value_T * _values; ///< Space to hold all values
	FmtNum  * _fn;     ///< Structure to aid format output of numbers

}; // class Array


/////////////////////////////////////////////////////////////////////////////////////////// Implementation /////


// Constructors

template<typename Value_T>
inline Array<Value_T>::Array(Array<Value_T> const & Other)
	: _values(NULL)
{
	Resize(Other.Size());
	for (size_t i=0; i<_size; ++i)
		_values[i] = Other[i];
}


// Methods

template<typename Value_T>
inline void Array<Value_T>::Resize(size_t Size, double SzFactor)
{
#ifndef NDEBUG
	// Check
	if (Size<0) throw new Fatal("Array::Resize size==%d must be positive", Size);
#endif

	// Clear previous memory
	if (_values!=NULL) delete [] _values;

	// Allocate new memory
	_size   = Size;
	_space  = static_cast<size_t>((_size+1)*SzFactor);
	_values = new Value_T [_space];
}

template<typename Value_T>
inline void Array<Value_T>::Push(Value_T const & Value, double SzFactor)
{
	if (_size==_space)
	{
		size_t oldsz = _size;
		Value_T * tmp = new Value_T [oldsz];
		for (size_t i=0; i<oldsz; ++i) tmp[i] = _values[i];
		Resize(oldsz+1, SzFactor);
		for (size_t i=0; i<oldsz; ++i) _values[i] = tmp[i];
		delete [] tmp;
	}
	else _size++;
	_values[_size-1] = Value;
}

template<typename Value_T>
inline void Array<Value_T>::Remove(size_t i, size_t Length)
{
	size_t oldsz = _size;
	Value_T * tmp = new Value_T [oldsz];
	for (size_t j=0; j<oldsz; ++j) tmp[j] = _values[j];
	Resize(_size-Length);
	size_t k = 0;
	for (size_t j=0;        j<i;      ++j) { _values[k]=tmp[j]; k++; }
	for (size_t j=i+Length; j<oldsz;  ++j) { _values[k]=tmp[j]; k++; }
	delete [] tmp;
}

template<typename Value_T>
inline long Array<Value_T>::Find(Value_T const & Value) const
{
	Value_T * res = std::find(_values, _values+_size, Value);
	if (res==_values+_size) return -1;
	else return res-_values;
}

template<typename Value_T>
inline long Array<Value_T>::Min() const
{
	Value_T * res = std::min_element(_values, _values+_size);
	return res-_values;
}

template<typename Value_T>
inline long Array<Value_T>::Max() const
{
	Value_T * res = std::max_element(_values, _values+_size);
	return res-_values;
}


// Operators
template<typename Value_T>
inline Value_T & Array<Value_T>::operator[] (size_t i)
{
#ifndef NDEBUG
	if (i<0 || i>=_size)
		throw new Fatal("Array::operator[] (write) Subscript==%d (size==%d) is out of range.", i, _size);
#endif
	return _values[i];
}

template<typename Value_T>
inline Value_T const & Array<Value_T>::operator[] (size_t i) const
{
#ifndef NDEBUG
	if (i<0 || i>=_size)
		throw new Fatal("Array::operator[] (read) Subscript==%d (size==%d) is out of range.", i, _size);
#endif
	return _values[i];
}

template<typename Value_T>
inline void Array<Value_T>::operator= (Array<Value_T> const & R)
{
#ifndef DNDEBUG
	if (&R==this)
		throw new Fatal("Array::operator= The right-hand-size of this operation (LHS = RHS) must not be equal to the LHS.");
#endif
	// Reallocate if they are different (LHS != RHS)
	if (_size!=R.Size()) Resize(R.Size());
	
	// Copy values
	for (size_t i=0; i<_size; ++i) _values[i] = R[i];
}

template<typename Value_T>
inline void Array<Value_T>::operator+= (Array<Value_T> const & R)
{
#ifndef DNDEBUG
	if (_size!=R.Size())
		throw new Fatal("Array::operator+= The number of components of the LHS (%d) must be equal to the number of components of the RHS (%d).",_size,R.Size());
#endif
	// Add values
	for (int i=0; i<_size; ++i) _values[i] += R[i];
}

template<typename Value_T>
inline void Array<Value_T>::operator-= (Array<Value_T> const & R)
{
#ifndef DNDEBUG
	if (_size!=R.Size())
		throw new Fatal("Array::operator-= The number of components of the LHS (%d) must be equal to the number of components of the RHS (%d).",_size,R.Size());
#endif
	// Subtract values
	for (int i=0; i<_size; ++i) _values[i] -= R[i];
}

template<typename Value_T>
inline void Array<Value_T>::operator= (Value_T const & V)
{
	// Set all values equal to V
	for (size_t i=0; i<_size; ++i) _values[i] = V;
}


/** Outputs an array. */
template<typename Value_T>
std::ostream & operator<< (std::ostream & os, const Array<Value_T> & V)
{
	for (size_t i=0; i<V.Size(); ++i)
		os << V.FN()<< V[i];
	os << std::endl;
	return os;
}


#endif // MPM_ARRAY_H

/* 2008 (c) Dorival M. Pedroso */