// file: $isip/class/math/vector/VectorLong/VectorLong.h
// version: $Id: VectorLong.h,v 1.3 1999/05/30 00:16:17 duncan Exp $
//

// make sure definitions are only made once
//
#ifndef ISIP_VECTOR_LONG
#define ISIP_VECTOR_LONG

// isip include files
//
#ifndef ISIP_LONG
#include <Long.h>
#endif

// forward declarations
//
class VectorUshort;
class VectorUlong;
class VectorUllong;
class VectorShort;
class VectorLlong;
class VectorFloat;
class VectorDouble;
class VectorString;

// Vector_long: a vector of Long's
//
class VectorLong {

  //---------------------------------------------------------------------------
  //
  // protected data
  //
  //---------------------------------------------------------------------------
protected:

  Long *v_d;
  Long size_d;

  //---------------------------------------------------------------------------
  //
  // public methods
  //
  //---------------------------------------------------------------------------
public:
 
  // required static methods
  //
  static String& name();
  static boolean diagnose(long debug_level);

  // required methods
  //
  boolean debug(unichar* message);
  long size();
  
  // initialization and release methods. init() is called at the
  // beginning of the constructor, release() in the destructor. these
  // methods allow for external methods to effectively construct or
  // delete objects, useful for inheritance and block memory
  // management.
  //
  boolean init();
  boolean release();

  // destructor/constructor(s)
  //
  ~VectorLong(); 
  VectorLong(long size = DEF_SIZE);
  VectorLong(VectorLong& vector);
  VectorLong(long size, long value);
  VectorLong(long size, long* buf);

  // i/o methods
  //
  boolean get(Sof& sof, String& name, long tag);
  boolean get(Sof& sof, long tag);

  boolean put(Sof& sof, String& name, long tag);
  boolean put(Sof& sof, long tag);
  
  boolean read(Sof& sof, long size = SofParser::FULL_OBJECT,
	       boolean param = Integral::TRUE,
	       boolean nested = Integral::FALSE);

  boolean read(Sof& sof, String& pname, long size = SofParser::FULL_OBJECT,
	       boolean param = Integral::TRUE,
	       boolean nested = Integral::TRUE);
  
  boolean write(Sof& sof, String& name);
  boolean write(Sof& sof);

  // partial i/o methods
  //
  long getPartial(Sof& sof, String& name, long tag,
		  long start_pos, long num_elem);
  long getPartial(Sof& sof, long tag, long start_pos, long num_elem);

  long readPartial(Sof& sof, String& pname, long start_pos, long num_elem,
		   long size = SofParser::FULL_OBJECT,
		   boolean param = Integral::TRUE,
		   boolean nested = Integral::FALSE);

  long readPartial(Sof& sof, long start_pos, long num_elem,
		   long size = SofParser::FULL_OBJECT,
		   boolean param = Integral::TRUE,
		   boolean nested = Integral::FALSE);
  
  // inline methods
  //
  inline Long& operator()(long index) {
    return v_d[index];
  }
  inline long vsize() {
    return (long)size_d;
  }

  // automatic type conversions
  //
  operator long*();

  // operator overloads
  //
  VectorLong& operator= (VectorLong& vector);
  VectorLong& operator= (long value);

  VectorLong& operator+ (VectorLong& vector);
  VectorLong& operator+ (long value);

  VectorLong& operator- (VectorLong& vector);
  VectorLong& operator- (long value);

  VectorLong& operator* (VectorLong& vector);
  VectorLong& operator* (long value);

  VectorLong& operator/ (VectorLong& vector);
  VectorLong& operator/ (long value);

  VectorLong& operator% (VectorLong& vector);
  VectorLong& operator% (long value);

  VectorLong& operator+= (VectorLong& vector);
  VectorLong& operator+= (long value);

  VectorLong& operator-= (VectorLong& vector);
  VectorLong& operator-= (long value);

  VectorLong& operator*= (VectorLong& vector);
  VectorLong& operator*= (long value);

  VectorLong& operator/= (VectorLong& vector);
  VectorLong& operator/= (long value);

  VectorLong& operator%= (VectorLong& vector);
  VectorLong& operator%= (long value);

  VectorLong& operator++ ();
  VectorLong& operator-- ();
  VectorLong& operator- ();

  boolean operator== (VectorLong& vector);
  boolean operator== (long value);

  boolean operator!= (VectorLong& vector);
  boolean operator!= (long value);

  boolean operator> (VectorLong& vector);
  boolean operator> (long value);

  boolean operator< (VectorLong& vector);
  boolean operator< (long value);

  boolean operator>= (VectorLong& vector);
  boolean operator>= (long value);

  boolean operator<= (VectorLong& vector);
  boolean operator<= (long value);

  VectorLong& operator&  (VectorLong& vector);
  VectorLong& operator&  (long value);

  VectorLong& operator|  (VectorLong& vector);
  VectorLong& operator|  (long value);

  VectorLong& operator^  (VectorLong& vector);
  VectorLong& operator^  (long value);

  VectorLong& operator>> (VectorLong& vector);
  VectorLong& operator>> (long value);

  VectorLong& operator<< (VectorLong& vector);
  VectorLong& operator<< (long value);

  VectorLong& operator>>=(VectorLong& vector);
  VectorLong& operator>>=(long value);

  VectorLong& operator<<=(VectorLong& vector);
  VectorLong& operator<<=(long value);

  VectorLong& operator&= (VectorLong& vector);
  VectorLong& operator&= (long value);

  VectorLong& operator|= (VectorLong& vector);
  VectorLong& operator|= (long value);

  VectorLong& operator^= (VectorLong& vector);
  VectorLong& operator^= (long value);

  VectorLong& operator~  ();

  // get methods
  //
  boolean get(VectorUshort& arg);
  boolean get(VectorUlong& arg);
  boolean get(VectorUllong& arg);
  boolean get(VectorShort& arg);
  boolean get(VectorLong& arg);
  boolean get(VectorLlong& arg);
  boolean get(VectorFloat& arg);
  boolean get(VectorDouble& arg);
  boolean get(VectorString& arg);
  boolean get(String& arg);
  
  // assignment
  //
  boolean assign(long value);

  boolean assign(VectorUshort& arg);
  boolean assign(VectorUlong& arg);
  boolean assign(VectorUllong& arg);
  boolean assign(VectorShort& arg);
  boolean assign(VectorLong& arg);
  boolean assign(VectorLlong& arg);
  boolean assign(VectorFloat& arg);
  boolean assign(VectorDouble& arg);
  boolean assign(VectorString& arg);

  // Zhao: change SysChar to Char when Wu makes a Char class
  //
  boolean assign(String& arg, SysChar delimiter = SysChar::SPACEC);

  boolean assign(ushort* arg, long num_elem);
  boolean assign(ulong* arg, long num_elem);
  boolean assign(ullong* arg, long num_elem);
  boolean assign(short* arg, long num_elem);
  boolean assign(long* arg, long num_elem);
  boolean assign(llong* arg, long num_elem);
  boolean assign(float* arg, long num_elem);
  boolean assign(double* arg, long num_elem);
  boolean assign(String* arg, long num_elem);

  // resize methods
  //
  boolean resize(long new_size);
  boolean recreate(long new_size);

  // special assignment
  //
  boolean move(VectorLong& source_vector, long num_elements,
	       long source_offset, long dest_offset);
  
  boolean shift(VectorLong& source_vector, long increment);
  boolean shift(long increment);

  boolean concat(VectorLong& v2);
  boolean concat(VectorLong& v1, VectorLong& v2 );

  boolean copy(VectorLong& source_vector);

  // comparison methods		      	      	     
  //
  long compare(VectorLong& vector);

  // unary methods					      	      	     
  //
  boolean neg();
  boolean neg(VectorLong& source_vector);

  // relational and logical methods		      	      	     
  //
  boolean gt(VectorLong& vector);
  boolean gt(long value);

  boolean lt(VectorLong& vector);
  boolean lt(long value);

  boolean ge(VectorLong& vector);
  boolean ge(long value);

  boolean le(VectorLong& vector);
  boolean le(long value);

  boolean eq(VectorLong& vector);
  boolean eq(long value);

  boolean ne(VectorLong& vector);
  boolean ne(long value);

  // vector arithmetic methods				      	      	     
  //
  boolean increment(long value);
  boolean increment(VectorLong& source_vector, long value);
  
  boolean add(VectorLong& source_vector);
  boolean add(VectorLong& v1, VectorLong& v2);
  boolean add(long value);
  boolean add(VectorLong& vector, long value);  

  boolean sub(VectorLong& source_vector);
  boolean sub(VectorLong& v1, VectorLong& v2);
  boolean sub(long value);
  boolean sub(VectorLong& vector, long value);
  
  boolean mult(VectorLong& source_vector);
  boolean mult(VectorLong& v1, VectorLong& v2);
  boolean mult(long value);
  boolean mult(VectorLong& vector, long value);
  
  boolean div(VectorLong& source_vector);
  boolean div(VectorLong& v1, VectorLong& v2);
  boolean div(long value);
  boolean div(VectorLong& vector, long value);

  boolean mod(VectorLong& source_vector);
  boolean mod(VectorLong& v1, VectorLong& v2);
  boolean mod(long value);
  boolean mod(VectorLong& vector, long value);

  // bitwise methods
  //
  boolean band(VectorLong& v2);
  boolean band(VectorLong& v1, VectorLong& v2);
  boolean band(long value);
  boolean band(VectorLong& v1, long value);

  boolean bor(VectorLong& v2);
  boolean bor(VectorLong& v1, VectorLong& v2);
  boolean bor(long value);
  boolean bor(VectorLong& v1, long value);

  boolean bxor(VectorLong& v2);
  boolean bxor(VectorLong& v1, VectorLong& v2);
  boolean bxor(long value);
  boolean bxor(VectorLong& v1, long value);

  boolean brs(VectorLong& v2);
  boolean brs(VectorLong& v1, VectorLong& v2);
  boolean brs(long increment);
  boolean brs(VectorLong& v1, long increment);

  boolean bls(VectorLong& v2);
  boolean bls(VectorLong& v1, VectorLong& v2);
  boolean bls(long increment);
  boolean bls(VectorLong& v1, long increment);

  boolean b1cmpl(VectorLong& v1);
  boolean b1cmpl();

  // mathematical methods				      	      	     
  //
  boolean exp();
  boolean exp(VectorLong& vector);
  
  boolean exp2();
  boolean exp2(VectorLong& vector);

  boolean exp10();
  boolean exp10(VectorLong& vector);

  boolean log();
  boolean log(VectorLong& vector);
  
  boolean log2();
  boolean log2(VectorLong& vector);

  boolean log10();
  boolean log10(VectorLong& vector);

  boolean pow(long y);
  boolean pow(VectorLong& x, long y);

  boolean sqrt();
  boolean sqrt(VectorLong& x);

  boolean sq();
  boolean sq(VectorLong& x);

  boolean abs();
  boolean abs(VectorLong& vector);		
  
  boolean sign();
  boolean sign(VectorLong& vector);

  long min();
  long min(long& position);

  long minMag();
  long minMag(long& position);

  long max();
  long max(long& position);
  
  long maxMag();
  long maxMag(long& position);

  boolean limit(long min_val, long max_val);
  boolean limit(VectorLong& vector, long min_val, long max_val);

  boolean limitMin(long min_val);
  boolean limitMin(VectorLong& vector, long min_val);

  boolean limitMax(long max_val);
  boolean limitMax(VectorLong& vector, long max_val);

  boolean limitHard(long cmp_val, long new_val);
  boolean limitHard(VectorLong& vector, long cmp_val, long new_val);

  boolean centerClip(long min_val, long max_val);
  boolean centerClip(VectorLong& vector, long min_val, long max_val);
  
  boolean randseed();
  boolean randseed(long seedval);	
  
  boolean rand();
  boolean rand(long min_val, long max_val);
  boolean grand(long mean, long stdev);
     
  boolean ramp(long offset, long incr);

  // vector to scalar mathematical methods
  //
  long sum();
  long sum_sq();
  long avg();
  long rms();
  long var();
  long dotpr(VectorLong& vector);
  long norm(VectorLong& vector);
  long normSq(VectorLong& vector);

  long numNotEqual(long test_value);

  // element location
  //
  long first(long value, long start_pos = NO_POS);
  long last(long value, long end_pos = NO_POS);

  // ordering/sorting
  //
  boolean reorder(VectorLong& index_vector);
  boolean reorder(VectorLong& vector, VectorLong& index_vector);

  //---------------------------------------------------------------------------
  //
  // private methods
  //
  //---------------------------------------------------------------------------
private:

  //---------------------------------------------------------------------------
  //
  // public constants
  //
  //---------------------------------------------------------------------------
public:

  // define the class name
  //
  static const unichar CLASS_NAME[] = L"VectorLong";

  //----------------------------------------
  //
  // io related variables
  //
  //----------------------------------------  

  static const unichar DEF_PARAM[] = L"values";

  //----------------------------------------
  //
  // default values and arguments
  //
  //----------------------------------------  

  // default arguments to methods
  //
  static const long NO_POS = -1;
  
  // define the default value(s) of the class data
  //
  static const long DEF_VALUE = (long)0;
  static const long DEF_SIZE = (long)0;

  //----------------------------------------
  //
  // error codes
  //
  //----------------------------------------  

  static const long ERR = (long)22600;

  
};

// end of file
//
#endif