#if !defined H_ARRAY_FUNCTIONS
#define H_ARRAY_FUNCTIONS
#include <iostream.h>
#include "harray.h"

template<class Type>
HArray<Type>::HArray(Type x, int n) {
	if (n > 0 ) {
		size=n;
		array= new Type [size];
		*this=x;
	}
	else errSize(n);
}
template<class Type>
HArray<Type>::HArray (const Type * anyArray, int n) {
	if (n > 0 ) {
		size=n;
		array= new Type [size];
		*this=anyArray;
	}
	else errSize(n);
}
template<class Type>
HArray<Type>& HArray<Type>::assign(int n) {
	if (n > 0 ) {
		delete [] array;
		size=n;
		array= new Type [size];
	}
	else errSize(n);
	return *this;
}
template<class Type>
HArray<Type>& HArray<Type>::assign(const HArray<Type>& x) {
	size=x.size;
	array=new Type [size];
	return *this=x;
}
template<class Type>
Type *  HArray<Type>::getPointer(int index) {
	if (index >=0 && index < size) return index+array;
	errIndex(index);
	return 0;
}
template<class Type>
HArray<Type>& HArray<Type>::operator = (const Type& value) {
	for(int i=size;i--;array[i]=value);
	return *this;
}
template<class Type>
HArray<Type>& HArray<Type>::operator = (const Type * anyArray) {
	for(int i=size;i--;array[i]=anyArray[i]);
	return *this;
}
template<class Type>
HArray<Type>& HArray<Type>::operator = (const HArray<Type>& x) {
	if(size!=x.size) {
		delete [] array;
		size=x.size;
		array= new Type [size];
	}
	for(int i=size;i--;array[i]=x.array[i]);
	return *this;
}
template<class Type>
HArray<Type> HArray<Type>::operator () (int pos, int nElements) {
	if (pos < 0 || pos >= size) {
		errIndex(pos);
		exit(EXIT_FAILURE);
	}
	int n=size-pos;
	if(n<nElements) nElements=n;
	HArray<Type> tmp(array+pos,nElements);
	return tmp;
}
template<class Type>
HArray<Type> HArray<Type>::operator () (const int * index, int n) {
	HArray<Type> x;
	x.size=n;
	x.array=new Type [n];
	register int i;
	while(n--) {
		i=index[n];
		if(i<0 || i>=size) {
			errIndex(i);
			exit(EXIT_FAILURE);
		}
		x.array[n]=array[i];
	}
	return x;
}
template<class Type>
HArray<Type>& HArray<Type>::insert(int pos, const Type& x) {
	if (pos >= 0 && pos <= size) {
		Type * tmp=array;
		array=new Type [++size];
		for(int i=size;--i > pos;array[i]=tmp[i-1]);
		array[pos]=x;
		while(pos--) array[pos]=tmp[pos];
		delete [] tmp;
	}
	else errIndex(pos);
	return *this;
}
template<class Type>
HArray<Type>& HArray<Type>::insert(int pos, const HArray<Type>& x) {
	if (pos >= 0 && pos <= size) {
		Type * tmp=array;
		int n=size;
		register int l=(size+=x.size);
		array=new Type [size];
		while(n > pos) array[--l]=tmp[--n];
		for(int i=x.size;i;array[--l]=x.array[--i]);
		while(l--) array[l]=tmp[l];
		delete [] tmp;
	}
	else errIndex(pos);
	return *this;
}
template <class Type>
HArray<Type>& HArray<Type>::replace(int pos, const HArray& x) {
	if(pos>=0 && pos<size) {
		int n=size-pos;
		if(n > x.size) n=x.size; 
		while(n--) array[n+pos]=x.array[n];
	}
	else errIndex(pos);
	return *this;
}
template <class Type>
HArray<Type>& HArray<Type>::append(const Type& x) {
	Type * tmp=array;
	array=new Type [++size];
	for(int i=size-1;i--;array[i]=tmp[i]);
	delete [] tmp;
	return *this;
}
template <class Type>
HArray<Type>& HArray<Type>::append(const HArray& x) {
	Type * tmp=array;
	int l=(size+=x.size);
	array=new Type [size];
	for(int i=x.size; i; array[--l]=x.array[--i]);
	while(l--) array[l]=tmp[l];
	delete [] tmp;
	return *this;
}
template <class Type>
HArray<Type>& HArray<Type>::remove(int pos, int nElements) {
	if(pos>=0 && pos<size) {
		int n=pos+nElements;
		int l= n>=size ? pos:size-nElements;
		if(l>0) {
			Type * tmp=array;
			array=new Type [l];
			for(int i=pos;i--;array[i]=tmp[i]);
			while(n<size) array[pos++]=tmp[n++];
		}
		else array=0;
		size=l;
	}
	else errIndex(pos);
	return *this;
}
template<class Type>
HArray<Type>& HArray<Type>::apply(Type func(Type)) {
	for(int i=size;i--;array[i]=func(array[i]));
	return *this;
}
template<class Type>
HArray<Type>& HArray<Type>::apply(Type* func(Type*)) {
	for(int i=size;i--;array[i]=*(func(array+i)));
	return *this;
}
template <class Type>
HArray<Type>& HArray<Type>::apply(Type func(Type),HArray & x) {
	if(size!=x.size) {
		delete [] array;
		size=x.size;
		array=new Type [size];
	}
	for(int i=size;i--;array[i]=func(x.array[i]));
	return *this;
}
template <class Type>
void HArray<Type>::errIndex(int index) {
	cerr<<"array index "<<index<<" out of range: 0-"<<size-1<<endl; 
}
template <class Type>
void HArray<Type>::errSize(int index) {
	cerr << "wrong array size: "<< index <<" ignored" << endl;
}

#endif