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::data() const
{
  double *d = new double [NDIMS];

  for (int i = NDIMS; i--; )
     d[i] = int2double(k[i]);

  return d;
}

double Object::distance(const Object& other) const
{
  if (ACC->distfast)
    {
      velem dist = 0;

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

          dist += (velem)(d*d);
        }

      return dist * ACC->distmul;
    }
  else 
    {
      double dist = 0.;

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

          dist += (velem)(d*d);
        }

      return dist;
    }
}


Object::Object(double *pkey)
{
  k = new velem[NDIMS];

  // discretize the vector
  for (int i = NDIMS; i--; )
     k[i] = double2int (pkey[i]);

  free (pkey);
}

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

  k = new velem [NDIMS];

  for (int i = 0; i < NDIMS; i++)
    {
      velem 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] = elem;
    }
}

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

  for (int i = 0; i < NDIMS; i++)
    {
      velem elem = k[i];

      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, unsigned int pagesize)
{
  steps--;

  assert (min <= 0);

  this->ndims = ndims;
  this->min   = min;
  this->max   = max;
  this->steps = steps;

  this->vzero = (velem)floor (- min * steps / max);

  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;

  if (elemsize <= 2
      && floor (steps * steps * 0.5 + 1) < velem(1<<31) / velem(ndims))
    {
      distfast = 1;
      distmul = maxDist / double(steps * steps * ndims);
    }
  else
    distfast = 0;

  printf ("%f < %ld?\n", floor (steps * steps * 0.5 + 1) , velem(1<<31) / velem(ndims));
  printf ("elem %d, distmul %f, maxdist %f\n", elemsize, distmul, maxDist);

  SETCUR;
  mt = new MT (pagesize);
}

PMT::~PMT()
{
  SETCUR;
  mt->Sync();
  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);
}

void PMT::sync()
{
  SETCUR;
  mt->Sync();
}

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 ();
      double *data = e->Key()->obj.data ();
      add_result(e->Ptr(), data, ndims);
      delete data;
      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.4
Committed:	Wed May 23 02:11:14 2001 UTC (23 years ago) by root
Branch:	MAIN
Changes since 1.3:	+74 -20 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	root	1.4	double *Object::data() const
23			{
24			double *d = new double [NDIMS];
25
26			for (int i = NDIMS; i--; )
27			d[i] = int2double(k[i]);
28
29			return d;
30			}
31
32	root	1.1	double Object::distance(const Object& other) const
33			{
34	root	1.4	if (ACC->distfast)
35			{
36			velem dist = 0;
37	root	1.1
38	root	1.4	for (int i = NDIMS; i--; )
39			{
40			long d = other.k[i] - k[i];
41
42			dist += (velem)(d*d);
43			}
44
45			return dist * ACC->distmul;
46			}
47			else
48			{
49			double dist = 0.;
50
51			for (int i = NDIMS; i--; )
52			{
53			double d = int2double(other.k[i]) - int2double(k[i]);
54	root	1.1
55	root	1.4	dist += (velem)(d*d);
56			}
57	root	1.1
58	root	1.4	return dist;
59			}
60	root	1.1	}
61
62	root	1.3
63			Object::Object(double *pkey)
64			{
65	root	1.4	k = new velem[NDIMS];
66	root	1.3
67			// discretize the vector
68			for (int i = NDIMS; i--; )
69	root	1.4	k[i] = double2int (pkey[i]);
70
71			free (pkey);
72	root	1.3	}
73
74	root	1.1	Object::Object(char *key)
75			{
76			unsigned char c = (unsigned char )key;
77
78	root	1.4	k = new velem [NDIMS];
79	root	1.1
80			for (int i = 0; i < NDIMS; i++)
81			{
82	root	1.4	velem elem = 0;
83	root	1.1
84			switch (ACC->elemsize)
85			{
86			case 4: elem \|= *c++ << 24;
87			case 3: elem \|= *c++ << 16;
88			case 2: elem \|= *c++ << 8;
89			case 1: elem \|= *c++ << 0;
90			break;
91			default:
92			abort ();
93			}
94
95	root	1.4	k[i] = elem;
96	root	1.1	}
97			}
98
99			void Object::Compress(char *key)
100			{
101			unsigned char c = (unsigned char )key;
102
103			for (int i = 0; i < NDIMS; i++)
104			{
105	root	1.4	velem elem = k[i];
106	root	1.1
107			switch (ACC->elemsize)
108			{
109			case 4: *c++ = (elem >> 24) & 0xff;
110			case 3: *c++ = (elem >> 16) & 0xff;
111			case 2: *c++ = (elem >> 8) & 0xff;
112			case 1: *c++ = (elem >> 0) & 0xff;
113			break;
114			default:
115			abort ();
116			}
117			}
118			}
119
120			#define SETCUR current_pmt = this
121
122	root	1.4	PMT::PMT(int ndims, double min, double max, double steps, unsigned int pagesize)
123	root	1.1	{
124	root	1.4	steps--;
125
126			assert (min <= 0);
127
128	root	1.1	this->ndims = ndims;
129			this->min = min;
130			this->max = max;
131			this->steps = steps;
132
133	root	1.4	this->vzero = (velem)floor (- min * steps / max);
134
135			if (steps < (1<<8))
136	root	1.1	elemsize = 1;
137	root	1.4	else if (steps < (1<<16))
138	root	1.1	elemsize = 2;
139	root	1.4	else if (steps < (1<<24))
140	root	1.1	elemsize = 3;
141			else
142			elemsize = 4;
143
144			maxDist = (max - min) * (max - min) * ndims;
145
146	root	1.4	if (elemsize <= 2
147			&& floor (steps * steps * 0.5 + 1) < velem(1<<31) / velem(ndims))
148			{
149			distfast = 1;
150			distmul = maxDist / double(steps * steps * ndims);
151			}
152			else
153			distfast = 0;
154
155			printf ("%f < %ld?\n", floor (steps * steps * 0.5 + 1) , velem(1<<31) / velem(ndims));
156			printf ("elem %d, distmul %f, maxdist %f\n", elemsize, distmul, maxDist);
157
158	root	1.1	SETCUR;
159	root	1.4	mt = new MT (pagesize);
160	root	1.1	}
161
162			PMT::~PMT()
163			{
164			SETCUR;
165	root	1.4	mt->Sync();
166	root	1.1	delete mt;
167			}
168
169			void PMT::create(const char *path)
170			{
171			SETCUR;
172			mt->Create(path);
173			}
174
175			void PMT::open(const char *path)
176			{
177			SETCUR;
178			mt->Open(path);
179			}
180
181			void PMT::insert(double *k, int data)
182			{
183			SETCUR;
184			Object o(k);
185			const MTkey key(o, 0, 0);
186			const MTentry entry(key, data);
187			mt->Insert(entry);
188			}
189
190	root	1.4	void PMT::sync()
191			{
192			SETCUR;
193			mt->Sync();
194			}
195
196	root	1.1	double PMT::distance(double k1, double k2) const
197			{
198			SETCUR;
199			Object o1(k1), o2(k2);
200			return o1.distance(o2);
201			}
202
203
204			void PMT::range(double *k, double r) const
205			{
206			SETCUR;
207			Object o(k);
208			Pred p(o);
209			SimpleQuery q(&p, r);
210			GiSTlist<MTentry *> res = mt->RangeSearch(q);
211
212	root	1.2	while(!res.IsEmpty())
213			{
214			MTentry *e = res.RemoveFront ();
215	root	1.4	double *data = e->Key()->obj.data ();
216			add_result(e->Ptr(), data, ndims);
217			delete data;
218	root	1.2	delete e;
219			}
220			}
221	root	1.1
222	root	1.2	void PMT::top(double *k, int n) const
223			{
224			SETCUR;
225			Object o(k);
226			Pred p(o);
227			TopQuery q(&p, n);
228			MTentry **res = mt->TopSearch(q);
229	root	1.1
230	root	1.2	for (int i=0; i < n; i++)
231			{
232			MTentry *e = res[i];
233			add_result(e->Ptr(), e->Key()->obj.data(), ndims);
234			delete e;
235			}
236	root	1.1	}
237
238	root	1.2	int PMT::maxlevel() const
239	root	1.1	{
240	root	1.2	SETCUR;
241			return mt->MaxLevel();
242	root	1.1	}