tvvector.c

TV-tree的c实现源码

/* 
 
                  COPYRIGHT NOTICE
 
This material was developed by Christos Faloutsos and King-Ip Lin
at the University of Maryland, College Park, Department of Computer Science.
Permission is granted to copy this software, to redistribute it
on a nonprofit basis, and to use it for any purpose, subject to
the following restrictions and understandings.
 
1. Any copy made of this software must include this copyright notice
in full.
 
2. All materials developed as a consequence of the use of this
software shall duly acknowledge such use, in accordance with the usual
standards of acknowledging credit in academic research.
 
3. The authors have made no warranty or representation that the
operation of this software will be error-free or suitable for any
application, and they are under under no obligation to provide any
services, by way of maintenance, update, or otherwise.  The software
is an experimental prototype offered on an as-is basis.
 
4. Redistribution for profit requires the express, written permission
of the authors.
 
*/

// Author : $Author$
// Date : $Date$
// Id : $Id$
// $Id: vector.C,v 1.3 1996/04/18 21:50:24 kilin Exp kilin $ 
#include <stdlib.h>
#include <assert.h>
#include <iostream.h>
#include <fstream.h>
#include "TVdefine.h"
#include "TVvector.h"


//     Constructors

TVector::TVector()
{
   total_dim = 0;
   compo = NULL;
// cout << "constructor invoked\n";
}

TVector::TVector(int dim)
{
   total_dim = dim;
   compo = new VCOM_TYPE [dim];
// cout << "constructor 2 invoked\n";
}

TVector::TVector(const TVector &v)
{
   total_dim = v.GetDim();
   compo = new VCOM_TYPE [total_dim];
   for (int i = 0; i < total_dim; i++)
       compo[i] = v[i];
// cout << "constructor 3 invoked\n";
}

//     Destructors

TVector::~TVector()
{
  if (compo)
      delete [] compo;
// cout << "destructor invoked\n";
}


//     Overloaded operators 

VCOM_TYPE& TVector::operator[](int dim) const
{
//  assert(dim < total_dim);
  if (dim >= total_dim)
    {
       char *p = NULL;
       p[2] = 'a';
    }
  return compo[dim];
}


TVector& TVector::operator=(const TVector& v)
{
   // remove old space if not equal
   if ((compo) && (total_dim != v.GetDim()))
      {
        delete [] compo;
        compo = new VCOM_TYPE[v.GetDim()];
      }
    else 
       if (!(compo) && v.GetDim())
          compo = new VCOM_TYPE[v.GetDim()];
   total_dim = v.GetDim();
   for (int i=0; i < total_dim; i++)
       compo[i] = v.compo[i];
// cout << "TVector assignment invoked\n";
   return *this;
} 

TVector TVector::operator+(const TVector& v) const
{
   int min_dim, i;

   min_dim = min(total_dim, v.GetDim());
   TVector vout(total_dim);
   for (i = 0; i < min_dim; i++)
      vout[i] = compo[i] + v[i];
   for (; i < total_dim; i++)
      vout[i] = compo[i];
   return vout;
}


TVector& TVector::operator+=(const TVector& v)
{
   int min_dim, i;

   min_dim = min(total_dim, v.GetDim());
   for (i = 0; i < min_dim; i++)
      compo[i] += v[i];
   return *this;
}

TVector TVector::operator+(const VCOM_TYPE n) const
{
   TVector vout(total_dim);

   for (int i = 0; i < total_dim; i++)
      vout[i] = compo[i] + n;
   return vout;
}


TVector& TVector::operator+=(const VCOM_TYPE n)
{

   for (int i = 0; i < total_dim; i++)
      compo[i] += n;
   return *this;
}


TVector TVector::operator-(const TVector& v) const
{
   int min_dim, i;

   min_dim = min(total_dim, v.GetDim());
   TVector vout(total_dim);
   for (i = 0; i < min_dim; i++)
      vout[i] = compo[i] - v[i];
   for (; i < total_dim; i++)
      vout[i] = compo[i];
   return vout;
}


TVector& TVector::operator-=(const TVector& v)
{
   int min_dim, i;

   min_dim = min(total_dim, v.GetDim());
   for (i = 0; i < min_dim; i++)
      compo[i] -= v[i];
   return *this;
}

TVector TVector::operator-(const VCOM_TYPE n) const
{
   TVector vout(total_dim);

   for (int i = 0; i < total_dim; i++)
      vout[i] = compo[i] - n;
   return vout;
}


TVector& TVector::operator-=(const VCOM_TYPE n)
{

   for (int i = 0; i < total_dim; i++)
      compo[i] -= n;
   return *this;
}

TVector TVector::operator-() const
{
   TVector vout(total_dim);

   for (int i = 0; i < total_dim; i++)
      vout[i] = -compo[i];
   return vout;
}


TVector TVector::operator*(const VCOM_TYPE n) const
{
   TVector vout(total_dim);

   for (int i = 0; i < total_dim; i++)
      vout[i] = compo[i] * n;
   return vout;
}


TVector& TVector::operator*=(const VCOM_TYPE n)
{

   for (int i = 0; i < total_dim; i++)
      compo[i] *= n;
   return *this;
}

TVector TVector::operator*(const int n) const
{
   TVector vout(total_dim);

   for (int i = 0; i < total_dim; i++)
      vout[i] = compo[i] *  n; 
   return vout;
}


TVector& TVector::operator*=(const int n)
{
   for (int i = 0; i < total_dim; i++)
      compo[i] *= n;
   return *this;
}

TVector TVector::operator/(const VCOM_TYPE n) const
{
   TVector vout(total_dim);

   for (int i = 0; i < total_dim; i++)
      vout[i] = compo[i] / n;
   return vout;
}


TVector& TVector::operator/=(const VCOM_TYPE n)
{

   for (int i = 0; i < total_dim; i++)
      compo[i] /= n;
   return *this;
}

TVector TVector::operator/(const int n) const
{
   TVector vout(total_dim);

   for (int i = 0; i < total_dim; i++)
      vout[i] = compo[i] / n; 
   return vout;
}


TVector& TVector::operator/=(const int n)
{
   for (int i = 0; i < total_dim; i++)
      compo[i] /= n;
   return *this;
}


int TVector::operator>(const TVector& v) const
{
   int min_dim = min(total_dim, v.GetDim());
   int i;

   for (i=0; (i < min_dim) && (abs(compo[i] - v[i]) < PRECISION); i++)
       ;
   return (i == min_dim) ? (min_dim != total_dim)  : (compo[i] > v[i]);
}


int TVector::operator>=(const TVector& v) const
{
   int min_dim = min(total_dim, v.GetDim());
   int i;

   for (i=0; (i < min_dim) && (abs(compo[i] - v[i]) < PRECISION); i++)
       ;
   return (i == min_dim) ? (min_dim == v.GetDim()) : (compo[i] >= v[i]);
}


int TVector::operator<(const TVector& v) const
{
   int min_dim = min(total_dim, v.GetDim());
   int i;

   for (i=0; (i < min_dim) && (abs(compo[i] - v[i]) < PRECISION); i++)
       ;
   return  (i == min_dim) ? (min_dim != v.GetDim()) : (compo[i] < v[i]);
}


int TVector::operator<=(const TVector& v) const
{
   int min_dim = min(total_dim, v.GetDim());
   int i;

   for (i=0; (i < min_dim) && (abs(compo[i] - v[i]) < PRECISION); i++)
       ;
   return (i == min_dim) ?  (min_dim == total_dim) : (compo[i] < v[i]);
}


int TVector::operator==(const TVector& v) const
{
   int i;
   if (total_dim == v.GetDim())
      for (i=0; (i < total_dim) && (abs(compo[i] - v[i]) < PRECISION); i++)
          ;
   return (total_dim == v.GetDim()) && (total_dim == i);
}


int TVector::operator!=(const TVector& v) const
{
   int i;
   if (total_dim == v.GetDim())
      for (i=0; (i < v.GetDim()) && (abs(compo[i] - v[i]) < PRECISION); i++)
          ;
   return (total_dim != v.GetDim()) || (total_dim != i);
}


TVector TVector::operator<<(const TVector& v) const
{
   int i,dim; 
   dim = v.GetDim();
   TVector vout(total_dim + dim);
   for (i = 0; i < total_dim; i++)
      vout[i] = compo[i];
   for (int j= 0; j < dim; j++)
      vout[i++] = v[j];
   return vout;
}

TVector& TVector::operator<<=(const TVector& v)
{
   int i,dim = v.GetDim();
   VCOM_TYPE *temp = NULL;
   int newdim;

   if (compo)
      {
         temp = new VCOM_TYPE[total_dim + dim];
         for (i = 0; i < total_dim; i++)
            temp[i] = compo[i];
         delete [] compo;
	 compo = temp;
      }
   else
      compo = new VCOM_TYPE[dim];
   for (int j= 0; j < dim; j++)
      compo[j+total_dim] = v[j];
   total_dim += dim;
   return *this;
}

TVector TVector::operator>>(const TVector& v) const
{
   int i,dim;

   dim = v.GetDim();
   TVector vout(total_dim + dim);
   for (i= 0; i < dim; i++)
      vout[i] = v[i];
   for (int j = 0; j < total_dim; j++)
      vout[i++] = compo[j];
   return vout;
}

TVector& TVector::operator>>=(const TVector& v)
{
   int i,dim;
   VCOM_TYPE *temp;

   temp = new VCOM_TYPE[total_dim];
   for (i = 0; i < total_dim; i++)
      temp[i] = compo[i];
   delete [] compo;
   compo = new  VCOM_TYPE[total_dim + (dim = v.GetDim())];
   for (i = 0; i < dim; i++)
      compo[i] = v[i];
   for (int j = 0; j < total_dim; j++)
      compo[i++] = temp[j];
   total_dim += dim;
   return *this;
}

//     Basic member functions

int TVector::GetDim() const
{
  return total_dim;
}


int TVector::Size() const
{
  return(sizeof(total_dim) + sizeof(VCOM_TYPE)  * total_dim);
}

int TVector::ExpectedSize(int dim) const
{
  return(sizeof(total_dim) + sizeof(VCOM_TYPE) * dim);
}

void TVector::SetAllCompo(VCOM_TYPE val)
{
  for (int i = 0; i < total_dim; i++)
      compo[i] = val;
}



// More Complex functions 

TVector TVector::ProjectFront(int dim) const
{

  assert(dim <= total_dim);

  TVector vout(dim);
  for (int i=0; i < dim; i++)
      vout[i] =  compo[i]; 
  return vout;
}


TVector TVector::ProjectBack(int dim) const
{
  TVector vout(dim);

  int startdim;

  assert(dim <= total_dim);

  startdim = total_dim - dim;
  for (int i=0; i < dim; i++)
      vout[i] = compo[i+ startdim]; 
  return vout;
}

TVector TVector::ProjectMid(int start, int dim) const
{

  TVector vout(dim);
  if (dim + start > total_dim)
     cout << "ah..........!!";
  assert(dim + start <= total_dim);

  for (int i=0; i < dim; i++)
      vout[i]  = compo[i+ start]; 
  return vout;
}


TVector* TVector::ProjectFrontP(int dim) const
{
  TVector *vout;

  assert(dim <= total_dim);

  vout = new TVector(dim);
  for (int i=0; i < dim; i++)
      (*vout)[i] = compo[i]; 
  return vout;
}


TVector* TVector::ProjectBackP(int dim) const
{
  TVector *vout;
  int startdim;

  assert(dim <= total_dim);

  vout = new TVector(dim);
  startdim = total_dim - dim;
  for (int i=0; i < dim; i++)
      (*vout)[i] = compo[i+ startdim]; 
  return vout;
}

TVector* TVector::ProjectMidP(int start, int dim) const
{

  TVector *vout;
  assert(dim + start <= total_dim);

  vout = new TVector(dim);
  for (int i=0; i < dim; i++)
      (*vout)[i]  = compo[i+ start]; 
  return vout;
}

TVector TVector::MinCompo(const TVector &v) const
{
   int mindim = min(total_dim, v.total_dim);

   TVector res(mindim);

   for (int i = 0; i < mindim; i++)
       res.compo[i] = min(compo[i], v.compo[i]);
   return(res);
}

TVector TVector::MaxCompo(const TVector &v) const
{
   int mindim = min(total_dim, v.total_dim);

   TVector res(mindim);

   for (int i = 0; i < mindim; i++)
       res.compo[i] = max(compo[i], v.compo[i]);
   return(res);
}

VCOM_TYPE TVector::Distance(const TVector& v) const
{
  VCOM_TYPE result = 0;

  assert(total_dim == v.GetDim());
  for (int i=0; i < total_dim; i++)
      result += abs(compo[i] - v[i]);
  return result; 
}

VCOM_TYPE TVector::Signed_Distance(const TVector& v) const
{
  VCOM_TYPE result = 0;

  assert(total_dim == v.GetDim());
  for (int i=0; i < total_dim; i++)
      result += compo[i] - v[i];
  return result; 
}

int TVector::Inrange(const TVector& v, VCOM_TYPE d) const
{
  int res = TRUE;

  assert(total_dim == v.GetDim());
  for (int i = 0; i < total_dim  && res; i++)
      res =  abs(compo[i] - v.compo[i]) <= d + PRECISION;
  return res;
}

int TVector::Inrange(const TVector& v, const TVector& v2) const
{
  int res = TRUE;

  assert(total_dim == v.GetDim());
  for (int i = 0; i < total_dim  && res; i++)
      res =  ((compo[i] >= v.compo[i]) && (compo[i] <= v2.compo[i]));
  return res;
}

int TVector::FirstDiffDim(const TVector &v) const
{
  int res = 0;
  int min_dim = min(v.GetDim(), total_dim);
  
  if (!min_dim)
     return -1;

  for (res = 0; (res < min_dim) && (v.compo[res] == compo[res]); res++)
      ;
  if ((res == min_dim) && (v.compo[res-1] == compo[res-1]))
     res = -1;
  return res;
}

VCOM_TYPE TVector::SumComponent() const
{
  VCOM_TYPE result;

  result = 0.0;
  for (int i=0; i < total_dim; i++)
      result += compo[i];
  return result;
}

VCOM_TYPE TVector::MaxComponent() const
{
  VCOM_TYPE result;

  result = compo[0];
  for (int i=1; i < total_dim; i++)
      result = max(result, compo[i]);
  return result;
}

VCOM_TYPE TVector::MinComponent() const
{
  VCOM_TYPE result;

  result = compo[0];
  for (int i=1; i < total_dim; i++)
      result = min(result, compo[i]);
  return result;
}

TVector& TVector::SetNull()
{
    if (compo)
       delete [] compo;
    total_dim = 0;
    return *this;
}

TVector& TVector::Abs()
{
   for (int i= 0; i < total_dim ; i++)
      if (compo[i] < 0)
	 compo[i] = -compo[i];
   return *this;
}

// Be-friended functions for vectors 

ostream& operator<<(ostream& os, const TVector& v) 
{
  int vlast;

  os << '(' ; 
  vlast = v.total_dim - 1;
  for (int i = 0; i < vlast; i++)
      os << v.compo[i] << ", ";
  if (vlast >= 0)
     os << v.compo[vlast];
  os << ')';
  return os;
}

ostream& operator<<(ostream& os, const TVector*& v) 
{
  int vlast;

  os << '(' ; 
  vlast = v->total_dim - 1;
  for (int i = 0; i < vlast; i++)
      os << v->compo[i] << ", ";
  if (vlast >= 0)
     os << v->compo[vlast];
  os << ')';
  return os;
}

ofstream& operator<(ofstream& os, const TVector& v) 
{
  int vlast;

  os << v.total_dim << " "; 
  vlast = v.total_dim - 1;
  for (int i = 0; i < vlast; i++)
      os << v.compo[i] << " ";
  if (vlast >= 0)
     os << v.compo[vlast];
  os << ' ';
  return os;
}

ofstream& operator<(ofstream& os, const TVector*& v) 
{
  int vlast;

  os << v->total_dim << " "; 
  vlast = v->total_dim - 1;
  for (int i = 0; i < vlast; i++)
      os << v->compo[i] << " ";
  if (vlast >= 0)
     os << v->compo[vlast];
  cout << ' ';
  return os;
}

istream& operator>>(istream& is, TVector& v) 
{
  if (!(v.total_dim))
     {
        cout << "No. of dimensions :  ";
        is >> v.total_dim;
        v.compo = new VCOM_TYPE[v.total_dim];
     }
  cout << "Enter all " << v.total_dim << " components : ";
  for (int i = 0 ; i < v.total_dim; i++)
     is >> v.compo[i];
  return is;
}


istream& operator>>(istream& is, TVector* & v) 
{
  int dim;

  delete v;
  cout << "No. of dimensions :  ";
  is >> dim;
  v = new TVector(dim);
  cout << "Enter all " << dim << " components : ";
  for (int i = 0 ; i < v->total_dim; i++)
     is >> v->compo[i];
  return is;
}


ifstream& operator>(ifstream& ifs, TVector& v) 
{
  int num;

  ifs >> v.total_dim;
  if (v.compo)
     delete [] v.compo;
  v.compo = new VCOM_TYPE[v.total_dim];
  for (int i = 0 ; i < v.total_dim; i++)
     ifs >> v.compo[i];
  return ifs;
}


ifstream& operator>(ifstream& ifs, TVector* & v) 
{
  int dim;

  delete v;
  ifs >> dim;
  v = new TVector(dim);
  for (int i = 0 ; i < v->total_dim; i++)
     ifs >> v->compo[i];
  return ifs;
}