Tree-M/PMT.cpp

#include <cstdlib>

#include "MT/MT.h"
#include "MT/MTpredicate.h"
#include "PMT.h"

const PMT *current_pmt;
int IOread, IOwrite;
dist2sim hfunction; // argl. using c++ without any clue.

/*
static double *
kdup (double *k, int ndims)
{
  double *n = new double [ndims];

  memcpy (n, k, ndims * sizeof (double));
  return n;
}
*/

double Object::distance(const Object& other) const
{
   int i;
   double dist = 0;

   for (i = NDIMS; i--; )
     {
       double d = other.k[i] - k[i];

       dist += d*d;
     }

   return dist;
}

Object::Object(char *key)
{
  unsigned char *c = (unsigned char *)key;

  k = new double [NDIMS];

  for (int i = 0; i < NDIMS; i++)
    {
      unsigned long elem = 0;

      switch (ACC->elemsize)
        {
          case 4: elem |= *c++ << 24;
          case 3: elem |= *c++ << 16;
          case 2: elem |= *c++ <<  8;
          case 1: elem |= *c++ <<  0;
            break;
          default:
            abort ();
        }

      k[i] = ((double)elem) * ACC->max / ACC->steps + ACC->min;
    }
}

void Object::Compress(char *key)
{
  unsigned char *c = (unsigned char *)key;

  for (int i = 0; i < NDIMS; i++)
    {
      unsigned long elem = (unsigned long)floor ((k[i] - ACC->min) * ACC->steps / ACC->max);

      switch (ACC->elemsize)
        {
          case 4: *c++ = (elem >> 24) & 0xff;
          case 3: *c++ = (elem >> 16) & 0xff;
          case 2: *c++ = (elem >>  8) & 0xff;
          case 1: *c++ = (elem >>  0) & 0xff;
            break;
          default:
            abort ();
        }
    }
}

#define SETCUR current_pmt = this

PMT::PMT(int ndims, double min, double max, double steps)
{
  this->ndims = ndims;
  this->min   = min;
  this->max   = max;
  this->steps = steps;

  if (steps <= (1<<8))
    elemsize = 1;
  else if (steps <= (1<<16))
    elemsize = 2;
  else if (steps <= (1<<24))
    elemsize = 3;
  else
    elemsize = 4;

  maxDist = (max - min) * (max - min) * ndims;

  SETCUR;
  mt = new MT;
}

PMT::~PMT()
{
  SETCUR;
  delete mt;
}

void PMT::create(const char *path)
{
  SETCUR;
  mt->Create(path);
}

void PMT::open(const char *path)
{
  SETCUR;
  mt->Open(path);
}

void PMT::insert(double *k, int data)
{
  SETCUR;
  Object o(k);
  const MTkey key(o, 0, 0);
  const MTentry entry(key, data);
  mt->Insert(entry);
}

double PMT::distance(double *k1, double *k2) const
{
  SETCUR;
  Object o1(k1), o2(k2);
  return o1.distance(o2);
}


void PMT::range(double *k, double r) const
{
  SETCUR;
  Object o(k);
  Pred p(o);
  SimpleQuery q(&p, r);
  GiSTlist<MTentry *> res = mt->RangeSearch(q);

  while(!res.IsEmpty())
    {
      MTentry *e = res.RemoveFront ();
      add_result(e->Ptr(), e->Key()->obj.data(), ndims);
      delete e;
    }
}

void PMT::top(double *k, int n) const
{
  SETCUR;
  Object o(k);
  Pred p(o);
  TopQuery q(&p, n);
  MTentry **res = mt->TopSearch(q);

  for (int i=0; i < n; i++)
    {
      MTentry *e = res[i];
      add_result(e->Ptr(), e->Key()->obj.data(), ndims);
      delete e;
   }
}

int PMT::maxlevel() const
{
  SETCUR;
  return mt->MaxLevel();
}
Revision:	1.2
Committed:	Sun May 6 01:35:15 2001 UTC (23 years ago) by root
Branch:	MAIN
Changes since 1.1:	+23 -7 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	#include <cstdlib>
2
3			#include "MT/MT.h"
4			#include "MT/MTpredicate.h"
5			#include "PMT.h"
6
7			const PMT *current_pmt;
8			int IOread, IOwrite;
9			dist2sim hfunction; // argl. using c++ without any clue.
10
11			/*
12			static double *
13			kdup (double *k, int ndims)
14			{
15			double *n = new double [ndims];
16
17			memcpy (n, k, ndims * sizeof (double));
18			return n;
19			}
20			*/
21
22			double Object::distance(const Object& other) const
23			{
24			int i;
25			double dist = 0;
26
27			for (i = NDIMS; i--; )
28			{
29			double d = other.k[i] - k[i];
30
31			dist += d*d;
32			}
33
34			return dist;
35			}
36
37			Object::Object(char *key)
38			{
39			unsigned char c = (unsigned char )key;
40
41			k = new double [NDIMS];
42
43			for (int i = 0; i < NDIMS; i++)
44			{
45			unsigned long elem = 0;
46
47			switch (ACC->elemsize)
48			{
49			case 4: elem \|= *c++ << 24;
50			case 3: elem \|= *c++ << 16;
51			case 2: elem \|= *c++ << 8;
52			case 1: elem \|= *c++ << 0;
53			break;
54			default:
55			abort ();
56			}
57
58			k[i] = ((double)elem) * ACC->max / ACC->steps + ACC->min;
59			}
60			}
61
62			void Object::Compress(char *key)
63			{
64			unsigned char c = (unsigned char )key;
65
66			for (int i = 0; i < NDIMS; i++)
67			{
68			unsigned long elem = (unsigned long)floor ((k[i] - ACC->min) * ACC->steps / ACC->max);
69
70			switch (ACC->elemsize)
71			{
72			case 4: *c++ = (elem >> 24) & 0xff;
73			case 3: *c++ = (elem >> 16) & 0xff;
74			case 2: *c++ = (elem >> 8) & 0xff;
75			case 1: *c++ = (elem >> 0) & 0xff;
76			break;
77			default:
78			abort ();
79			}
80			}
81			}
82
83			#define SETCUR current_pmt = this
84
85			PMT::PMT(int ndims, double min, double max, double steps)
86			{
87			this->ndims = ndims;
88			this->min = min;
89			this->max = max;
90			this->steps = steps;
91
92			if (steps <= (1<<8))
93			elemsize = 1;
94			else if (steps <= (1<<16))
95			elemsize = 2;
96			else if (steps <= (1<<24))
97			elemsize = 3;
98			else
99			elemsize = 4;
100
101			maxDist = (max - min) * (max - min) * ndims;
102
103			SETCUR;
104			mt = new MT;
105			}
106
107			PMT::~PMT()
108			{
109			SETCUR;
110			delete mt;
111			}
112
113			void PMT::create(const char *path)
114			{
115			SETCUR;
116			mt->Create(path);
117			}
118
119			void PMT::open(const char *path)
120			{
121			SETCUR;
122			mt->Open(path);
123			}
124
125			void PMT::insert(double *k, int data)
126			{
127			SETCUR;
128			Object o(k);
129			const MTkey key(o, 0, 0);
130			const MTentry entry(key, data);
131			mt->Insert(entry);
132			}
133
134			double PMT::distance(double k1, double k2) const
135			{
136			SETCUR;
137			Object o1(k1), o2(k2);
138			return o1.distance(o2);
139			}
140
141
142			void PMT::range(double *k, double r) const
143			{
144			SETCUR;
145			Object o(k);
146			Pred p(o);
147			SimpleQuery q(&p, r);
148			GiSTlist<MTentry *> res = mt->RangeSearch(q);
149
150	root	1.2	while(!res.IsEmpty())
151			{
152			MTentry *e = res.RemoveFront ();
153			add_result(e->Ptr(), e->Key()->obj.data(), ndims);
154			delete e;
155			}
156			}
157	root	1.1
158	root	1.2	void PMT::top(double *k, int n) const
159			{
160			SETCUR;
161			Object o(k);
162			Pred p(o);
163			TopQuery q(&p, n);
164			MTentry **res = mt->TopSearch(q);
165	root	1.1
166	root	1.2	for (int i=0; i < n; i++)
167			{
168			MTentry *e = res[i];
169			add_result(e->Ptr(), e->Key()->obj.data(), ndims);
170			delete e;
171			}
172	root	1.1	}
173
174	root	1.2	int PMT::maxlevel() const
175	root	1.1	{
176	root	1.2	SETCUR;
177			return mt->MaxLevel();
178	root	1.1	}