// array.cc -- array template classes
// $Id$
//
// array1d::array1d - 1D array template constructor
// array1d::~array1d - 1D array template destructor
//
// array2d::array2d - 2D array template constructor
// array2d::~array2d - 2D array template destructor
//
// array3d::array3d - 3D array template constructor
// array3d::~array3d - 3D array template destructor
//
// array4d::array4d - 4D array template constructor
// array4d::~array4d - 4D array template destructor
//
// *** template instantiations: array[12]d<int>, array[1234]d<{float,double}>
//

#include <assert.h>
#include "jt/stdc.h"
#include "jt/util++.hh"
#include "jt/array.hh"

//*****************************************************************************
// array1d - 1D array template
//*****************************************************************************

//
// This function constructs an  array1d  object.
//
template <class fpt>
array1d<fpt>::array1d(int min_i_in, int max_i_in)
	: min_i_(min_i_in), max_i_(max_i_in)
{
array_ = new fpt[N_i()];

// need to explicitly initialize -- new[] *doesn't* do this automagically
	for (int i = 0 ; i < N_array() ; ++i)
	{
	array_[i] = fpt(0);
	}
}

//*****************************************************************************

//
// This function destroys an  array1d  object.
//
template <class fpt>
array1d<fpt>::~array1d()
{
delete[] array_;
}

//*****************************************************************************
// array2d - 2D array template
//*****************************************************************************

//
// This function constructs an  array2d  object.
//
template <class fpt>
array2d<fpt>::array2d(int min_i_in, int max_i_in,
		     int min_j_in, int max_j_in)
	: min_i_(min_i_in), max_i_(max_i_in),
	  min_j_(min_j_in), max_j_(max_j_in)
{
stride_i_ = N_j();
N_array_ = N_i() * stride_i_;
array_ = new fpt[N_array_];

// need to explicitly initialize -- new[] *doesn't* do this automagically
	for (int i = 0 ; i < N_array() ; ++i)
	{
	array_[i] = fpt(0);
	}

offset_ = 0;	// temp value, needed for following  subscript()  call
offset_ = - subscript_unchecked(min_i_, min_j_);
		// must use unchecked form here since setup isn't done yet
}

//*****************************************************************************

//
// This function destroys an  array2d  object.
//
template <class fpt>
array2d<fpt>::~array2d()
{
delete[] array_;
}

//*****************************************************************************
// array3d - 3D array template
//*****************************************************************************

//
// This function constructs an  array3d  object.
//
template <class fpt>
array3d<fpt>::array3d(int min_i_in, int max_i_in,
		     int min_j_in, int max_j_in,
		     int min_k_in, int max_k_in)
	: min_i_(min_i_in), max_i_(max_i_in),
	  min_j_(min_j_in), max_j_(max_j_in),
	  min_k_(min_k_in), max_k_(max_k_in)
{
stride_j_ = N_k();
stride_i_ = N_j() * stride_j_;
N_array_ = N_i() * stride_i_;
array_ = new fpt[N_array_];

// need to explicitly initialize -- new[] *doesn't* do this automagically
	for (int i = 0 ; i < N_array() ; ++i)
	{
	array_[i] = fpt(0);
	}

offset_ = 0;	// temp value, needed for following  subscript()  call
offset_ = - subscript_unchecked(min_i_, min_j_, min_k_);
		// must use unchecked form here since setup isn't done yet
}

//*****************************************************************************

//
// This function destroys an  array3d  object.
//
template <class fpt>
array3d<fpt>::~array3d()
{
delete[] array_;
}

//*****************************************************************************
// array4d - 4D array template
//*****************************************************************************

//
// This function constructs an  array4d  object.
//
template <class fpt>
array4d<fpt>::array4d(int min_i_in, int max_i_in,
		     int min_j_in, int max_j_in,
		     int min_k_in, int max_k_in,
		     int min_l_in, int max_l_in)
	: min_i_(min_i_in), max_i_(max_i_in),
	  min_j_(min_j_in), max_j_(max_j_in),
	  min_k_(min_k_in), max_k_(max_k_in),
	  min_l_(min_l_in), max_l_(max_l_in)
{
stride_k_ = N_l();
stride_j_ = N_k() * stride_k_;
stride_i_ = N_j() * stride_j_;
N_array_ = N_i() * stride_i_;
array_ = new fpt[N_array_];

// need to explicitly initialize -- new[] *doesn't* do this automagically
	for (int i = 0 ; i < N_array() ; ++i)
	{
	array_[i] = fpt(0);
	}

offset_ = 0;	// temp value, needed for following  subscript()  call
offset_ = - subscript_unchecked(min_i_, min_j_, min_k_, min_l_);
		// must use unchecked form here since setup isn't done yet
}

//*****************************************************************************

//
// This function destroys an  array4d  object.
//
template <class fpt>
array4d<fpt>::~array4d()
{
delete[] array_;
}

//*****************************************************************************
// *** template instantiations: array1d<int>, array[1234]d<{float,double}>
//*****************************************************************************

template class array1d<int>;
template class array2d<int>;

template class array1d<float>;
template class array2d<float>;
template class array3d<float>;
template class array4d<float>;

template class array1d<double>;
template class array2d<double>;
template class array3d<double>;
template class array4d<double>;