// array.h

#ifndef array_H
#define array_H

#undef  trf_error
#define trf_error
 
#include <iostream>
#include <cassert>
#include <vector>

template <class T>
class array {
private:
  int size;
protected:
  T *data;
  void allocate(int N);
  virtual void ostr(std::ostream& stream) const;
public:
  void fill(const T& value);
  array(int N);
  array(const array<T>& arr);
  virtual ~array(void);
  void fill(const T* arr);
  T min( ) const;
  T max( ) const;
  T amin( ) const;
  T amax( ) const;
  int get_size( ) const { return size; };
  // Return an STL vector.
  std::vector<T> get_std_vector() const {
    return std::vector<T>( data, data+get_size() );
  }
  array<T> &operator=(const array<T>& arr);
  T& operator()( int i ) const { return data[i]; };
  array<T> operator-( );
  array<T> &operator+=(const array<T>& arr);
  array<T> &operator-=(const array<T>& arr);
  array<T> &operator*=(const T& tval);
#if defined(DEFECT_GUIDING_DECLS)
  friend array<T> operator+(const array<T>& arr1, const array<T>& arr2);
  friend array<T> operator-(const array<T>& arr1, const array<T>& arr2);
  friend std::ostream& operator<<(std::ostream& stream, const array<T>& arr);
  friend bool operator==(const array<T>& arr1, const array<T>& arr2);
  friend bool operator!=(const array<T>& arr1, const array<T>& arr2);
  friend bool is_equal(const array<T>& arr1, const array<T>& arr2);
#elif defined(DEFECT_NO_EXPLICIT_QUALIFICATION)
  template<class S>
  friend array<S> operator+(const array<S>& arr1, const array<S>& arr2);
  template<class S>
  friend array<S> operator-(const array<S>& arr1, const array<S>& arr2);
  template<class S>
  friend std::ostream& operator<<(std::ostream& stream, const array<S>& arr);
  template<class S>
  friend bool operator==(const array<S>& arr1, const array<S>& arr2);
  template<class S>
  friend bool operator!=(const array<S>& arr1, const array<S>& arr2);
  template<class S>
  friend bool is_equal(const array<S>& arr1, const array<S>& arr2);
#else
  friend array<T> operator+ <> (const array<T>& arr1, const array<T>& arr2);
  friend array<T> operator- <> (const array<T>& arr1, const array<T>& arr2);
  friend std::ostream& operator<< <> (std::ostream& stream, const array<T>& arr);
  friend bool operator== <> (const array<T>& arr1, const array<T>& arr2);
  friend bool operator!= <> (const array<T>& arr1, const array<T>& arr2);
  friend bool is_equal <> (const array<T>& arr1, const array<T>& arr2);
#endif
};

template <class T>
inline array<T>::array(int N)
{
  allocate(N);
}

template <class T>
inline array<T>::array(const array<T>& arr)
{
#ifdef trf_info
  std::cout << "copying an array\n";
#endif
  allocate(arr.size); 
  for ( int i=0; i<size; i++ ) data[i] = arr.data[i];
}


template <class T>
inline array<T>::~array(void)
{
#ifdef trf_info
  std::cout << size*sizeof(T) << " bytes deallocated [" << &data[0] << "]\n";
#endif
  delete [] data;
}

template <class T>
inline void array<T>::allocate(int N)
{
  size = N;
  data = new T[size];
#ifdef trf_info
  std::cout << size*sizeof(T) << " bytes allocated [" << &data[0] << "]\n";
#endif
}

template <class T>
inline void array<T>::ostr(std::ostream& stream) const {
  stream << "{";
  for ( int i=0; i<size; i++ ) stream << ' ' << data[i];
  stream << " }";
}

template <class T>
inline void array<T>::fill(const T* arr)
{
  for ( int i=0; i<size; i++ ) data[i]=arr[i];
}

template <class T>
inline void array<T>::fill(const T& value)
{
  for ( int i=0; i<size; i++ ) data[i]=value; 
}

template <class T>
inline array<T> &array<T>::operator=(const array<T>& arr)
{
  assert( size == arr.size );
#ifdef trf_error
  if ( size != arr.size ) {
    std::cerr << "copy_data:invalid array equality\n";
    std::cerr << arr << '\n' << *this << std::endl;
  }
#endif
  else {
    for ( int i=0; i<arr.size; i++ ) data[i] = arr.data[i];
  }
  return *this;
}

template <class T>
inline array<T> &array<T>::operator+=(const array<T>& arr)
{
  assert( size == arr.size );
#ifdef trf_error
  if ( size != arr.size ) {
    std::cerr << "operator+=: invalid array equality" << std::endl;
  }
#endif
  else {
    for ( int i=0; i<arr.size; i++ ) data[i] += arr.data[i];
  }
  return *this;
}

template <class T>
inline array<T> &array<T>::operator-=(const array<T>& arr)
{
  assert( size == arr.size );
#ifdef trf_error
  if ( size != arr.size ) {
    std::cerr << "operator-=: invalid array equality" << std::endl;
  }
#endif
  else {
    for ( int i=0; i<arr.size; i++ ) data[i] -= arr.data[i];
  }
  return *this;
}

template <class T>
inline array<T> &array<T>::operator*=(const T& tval)
{
  for ( int i=0; i<size; i++ ) data[i] *= tval;
  return *this;
}

template <class T>
inline array<T> operator*(const T& val,const array<T>& arr)
{
 array<T> lhs = arr;
 lhs *= val;
 return lhs;
}

template <class T>
inline array<T> operator*(const array<T>& arr,const T& val)
{
 array<T> lhs = arr;
 lhs *= val;
 return lhs;
}

template <class T>
inline array<T> operator+(const array<T>& arr1,const array<T>& arr2)
{
  array<T> sum = arr1;
  sum += arr2;
  return sum;
}

template <class T>
inline array<T> operator-(const array<T>& arr1,const array<T>& arr2)
{
  array<T> sum = arr1;
  sum -= arr2;
  return sum;
}

#ifndef __xlC__
#include "array.c"
#endif

#endif