#ifndef NUMDATA_HH
#define NUMDATA_HH
////////////////////////////////////////////////////////////////////////////
//! author="Robert Crida"
//! lib=NumData
//! date="27/2/1998"
//! userlevel=Normal
//! docentry="Pattern Recognition.Data Types;Numerical Methods.Data Types"
//! file="amma/PatternRec/Data/NumData.hh"
//! rcsid="$Id: NumData.hh,v 1.20 2000/02/16 14:09:59 ees1cg Exp $"

#include "amma/Num/NumLabel.hh"

// --------------------------------------------------------------------------
// **********  NumDataC  ****************************************************
// --------------------------------------------------------------------------
//: Stores data value tuples for use in data sets within PatternRec
//
// NumDataC<InputC,OutputC> is a template class for storing data value
// tuples. The object should be interpreted as a corresponding input/output
// pair.<p>
//
// Base class in the PatternRec hierarchy and is used for creating data sets
// for representing training and test data. See NumDataSetC<InputC,OutputC>
// for how it is used.

template <class InputC,class OutputC>
class NumDataC
{
public:
  NumDataC ();
  //: Default constructor
  // Calls default constructors of member data.

  NumDataC (const InputC &input, const OutputC &output);
  //: Constructor taking the input and output values

  NumDataC (istream &in);
  //: Constructs from stream

  NumDataC (const NumDataC<InputC,OutputC> &oth);
  //: Copy constructor
  // Makes a shallow copy.

  NumDataC<InputC,OutputC> Copy () const;
  //: Makes a deep copy

  const InputC & Input () const;
  //: Const access to the input value

  const OutputC & Output () const;
  //: Const access to the output value

  InputC & Input ();
  //: Access to the input value

  OutputC & Output ();
  //: Access to the output value

  void Save (ostream &out) const;
  //: Writes object to stream, can be loaded using constructor

private:
  InputC _input;
  OutputC _output;
};

template <class InputC,class OutputC>
ostream &operator<<(ostream &out,const NumDataC<InputC,OutputC> &dat)
{
  out << dat.Input() << " " << dat.Output();
  return out;
}

template <class InputC,class OutputC>
istream &operator>>(istream &in,NumDataC<InputC,OutputC> &dat)
{
  dat = NumDataC<InputC,OutputC>(in);
  return in;
}

//////////////////////////////////////////////////////

template <class InputC,class OutputC>
NumDataC<InputC,OutputC>::NumDataC ()
{}

template <class InputC,class OutputC>
NumDataC<InputC,OutputC>::NumDataC (const InputC &input, const OutputC &output)
  :_input(input),
   _output(output)
{}

template <class InputC,class OutputC>
NumDataC<InputC,OutputC>::NumDataC (istream &in)
{ in >> _input >> _output; }


template <class InputC,class OutputC>
NumDataC<InputC,OutputC>::NumDataC (const NumDataC<InputC,OutputC> &oth)
  :_input(oth._input),
   _output(oth._output)
{}

template <class InputC,class OutputC>
NumDataC<InputC,OutputC> NumDataC<InputC,OutputC>::Copy () const
{ return NumDataC<InputC,OutputC> (_input,_output); }

template <class InputC,class OutputC>
const InputC & NumDataC<InputC,OutputC>::Input () const
{ return _input; }

template <class InputC,class OutputC>
const OutputC & NumDataC<InputC,OutputC>::Output () const
{ return _output; }

template <class InputC,class OutputC>
InputC & NumDataC<InputC,OutputC>::Input ()
{ return _input; }

template <class InputC,class OutputC>
OutputC & NumDataC<InputC,OutputC>::Output ()
{ return _output; }

template <class InputC,class OutputC>
void NumDataC<InputC,OutputC>::Save (ostream &out) const
{ out << _input << "\n" << _output << "\n"; }


#endif