├── test
├── test4
├── helper.h
├── juraset2.asc
├── BinaryTree.h
├── makefile
├── helper.cpp
├── test.cpp
├── test3.cpp
├── BinaryTree.cpp
├── test4.cpp
├── test2.cpp
├── test4dimensiones.cpp
├── main.cpp
├── test10dimensiones.cpp
├── datos.txt
└── juraset.asc


/test:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gonzalezf/Proyecto_GeoInnova_KVecinos/master/test


--------------------------------------------------------------------------------
/test4:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gonzalezf/Proyecto_GeoInnova_KVecinos/master/test4


--------------------------------------------------------------------------------
/helper.h:
--------------------------------------------------------------------------------
 1 | #ifndef _INCLUDE_HELPER_H_
 2 | #define _INCLUDE_HELPER_H_
 3 | 
 4 | using namespace std;
 5 | #include <iostream> 
 6 | #include <fstream>
 7 | #include <sstream>
 8 | #include <string>
 9 | #include <vector>
10 | #include <cmath>
11 | #include <sstream>
12 | #include <stdlib.h> 
13 | 
14 | class Helper {
15 | 
16 | 	public:
17 |     bool ArchivoExiste(const std::string& name);
18 | 	void ImprimirTiempoTranscurrido(double num);
19 | 	std::vector<std::vector<float>>  loadFile(std::string fileName, int maxVar);
20 | 
21 | 
22 | };
23 | 
24 | #endif


--------------------------------------------------------------------------------
/juraset2.asc:
--------------------------------------------------------------------------------
 1 | Titulo
 2 | 13
 3 | x
 4 | y
 5 | z
 6 | var 1
 7 | var 2
 8 | var 3
 9 | var 4
10 | var 5
11 | var 6
12 | var 7
13 | var 8
14 | var 9
15 | var 10
16 | 0 0 1 1.74 25.72 77.36 9.32 38.32 21.32 92.56 0.45 19.9 7.21
17 | 0 2 0 1.335 24.76 77.88 10 40.2 29.72 73.56 0.33 19.28 7.79
18 | 4.308 1.933 0 2.15 22.7 56.4 11.92 43.52 29.72 90 0.49 12.8 6.72
19 | 4.383 1.081 0 1.565 34.32 66.4 16.32 38.52 26.2 88.4 0.54 22.79 10.84
20 | 3.244 4.519 0 1.145 31.28 72.4 3.5 40.4 22.04 75.2 0.36 22.65 2.53
21 | 3.925 3.785 0 0.894 27.44 60 15.08 30.52 21.76 72.4 0.25 16.46 9.05
22 | 3 0 1 1.61 8.88 30.8 10.6 47 21.4 64.8 0.14 2.74 3.26
23 | 


--------------------------------------------------------------------------------
/BinaryTree.h:
--------------------------------------------------------------------------------
 1 | #ifndef _INCLUDE_BINARY_TREE_H_
 2 | #define _INCLUDE_BINARY_TREE_H_
 3 | #include <cstddef>
 4 | #include <iostream>
 5 | using namespace std;
 6 | class BinarySearchTree
 7 | {
 8 |     private:
 9 |         struct tree_node
10 |         {
11 |            tree_node* left;
12 |            tree_node* right;
13 |            int data;
14 |         };
15 |         tree_node* root;
16 |     
17 |     public:
18 |         BinarySearchTree()
19 |         {
20 |            root = NULL;
21 |         }
22 |        
23 |         bool isEmpty() const { return root==NULL; }
24 |         void print_inorder();
25 |         void inorder(tree_node*);
26 |         void print_preorder();
27 |         void preorder(tree_node*);
28 |         void print_postorder();
29 |         void postorder(tree_node*);
30 |         void insert(int);
31 |         void remove(int);
32 | };
33 | 
34 | 
35 | #endif


--------------------------------------------------------------------------------
/makefile:
--------------------------------------------------------------------------------
 1 | # Set up basic variables:
 2 | CC         = g++
 3 | CFLAGS     = -c -Wall -O3 -std=c++11 -g
 4 | LDFLAGS    =
 5 | # List of sources:
 6 | SOURCES1    = test.cpp
 7 | OBJECTS1    = $(SOURCES1:.cpp=.o)
 8 | 
 9 | SOURCES2    = test2.cpp
10 | OBJECTS2    = $(SOURCES2:.cpp=.o)
11 | 
12 | # Name of executable target:
13 | EXECUTABLE1 = test
14 | 
15 | EXECUTABLE2 = test2
16 | 
17 | 
18 | # MRPT specific flags:
19 | #  Here we invoke "pkg-config" passing it as argument the list of the
20 | #  MRPT libraries needed by our program (see available libs
21 | #   with "pkg-config --list-all | grep mrpt").
22 | #
23 | #CFLAGS     += `pkg-config --cflags mrpt-base`
24 | 
25 | 
26 | all: $(SOURCES) $(EXECUTABLE1) $(EXECUTABLE2)
27 | 
28 | $(EXECUTABLE1): $(OBJECTS1)
29 | 	$(CC)  $(LDFLAGS) $(OBJECTS1) -o $@
30 | 
31 | $(EXECUTABLE2): $(OBJECTS2)
32 | 	$(CC)  $(LDFLAGS) $(OBJECTS2) -o $@
33 | 
34 | .cpp.o:
35 | 	$(CC) $(CFLAGS) $< -o $@
36 | 
37 | clean:
38 | 	rm -rf $(EXECUTABLE1) $(EXECUTABLE2) $(OBJECTS1) $(OBJECTS2)
39 | 


--------------------------------------------------------------------------------
/helper.cpp:
--------------------------------------------------------------------------------
 1 | #include "helper.h"
 2 | #include <iostream>
 3 | #include <fstream>
 4 | #include <string>
 5 | #include <sstream>
 6 | #include <vector>
 7 | 
 8 | 
 9 | bool Helper::ArchivoExiste(const std::string& name){
10 |     ifstream f(name.c_str());
11 |     return f.good();
12 | }
13 | 
14 | void Helper::ImprimirTiempoTranscurrido(double num){
15 |     int hor,minu,seg;
16 |     hor=(int)(num / 3600);
17 |     minu=(int)((num - hor * 3600) / 60);
18 |     seg=num - (hor * 3600 + minu * 60);
19 |     cout<<"Tiempo Trancurrido: "<<hor<<"h "<<minu<<"m "<<seg<<"s"<<endl;
20 | }
21 | 
22 | std::vector<std::vector<float>>  Helper::loadFile(std::string fileName, int maxVar){
23 |   std::vector<std::vector<float>> data;
24 |   float value;
25 |   std::vector<float> point;
26 |   int numVar;
27 |   std::ifstream inFile(fileName.c_str());
28 |   std::string line;
29 |   //leer el título
30 |   std::getline(inFile, line);
31 |   //leer la cantidad de variables
32 |   std::getline(inFile, line);
33 |   std::istringstream iss (line);
34 |   iss>> numVar;
35 |   //leer el nombre de las variables
36 |   for (int i = 0; i < numVar; i++) {
37 |     std::getline(inFile, line);
38 |   }
39 |   //setear la cantidad de variables a usar
40 |   if(maxVar==0 or maxVar> numVar)
41 |     maxVar=numVar;
42 |   //leer cada dato
43 |   while (std::getline(inFile, line)) {
44 |     std::istringstream iss (line);
45 |     for (int i = 0; i < maxVar; i++) {
46 |       iss>> value;
47 |       point.push_back(value);
48 |     }
49 |     data.push_back(point);
50 |     point.clear();
51 |   }
52 |   return data;
53 | }
54 | /*
55 | int main (){
56 |   std::vector<std::vector<float> > data;
57 |   std::string fileName="../juraset.asc";
58 |   //std::cout << "Ingrese o ruta del archivo: ";
59 |   //std::cin >> fileName;
60 |   data=loadFile(fileName,0);
61 |   for (size_t  i = 0; i < data.size(); i++) {
62 |     for (size_t j = 0; j < data[0].size(); j++) {
63 |       std::cout << data[i][j]<<" ";
64 |     }
65 |     std::cout << std::endl;
66 |   }
67 |   return 0;
68 | }
69 | */
70 | 


--------------------------------------------------------------------------------
/test.cpp:
--------------------------------------------------------------------------------
  1 | #include "../nanoflann/include/nanoflann.hpp"
  2 | #include <cstdlib>
  3 | #include <iostream>
  4 | #include <sys/time.h>
  5 | 
  6 | using namespace std;
  7 | using namespace nanoflann;
  8 | 
  9 | template <typename T>
 10 | struct PointCloud{
 11 | 	struct Point{
 12 | 		T  x,y,z;
 13 | 	};
 14 | 	std::vector<Point>  pts;
 15 | 
 16 | 	typedef  PointCloud Derived; //!< In this case the dataset class is myself.
 17 | 	/// CRTP helper method
 18 | 	inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
 19 | 	/// CRTP helper method
 20 | 	inline       Derived& derived()       { return *static_cast<Derived*>(this); }
 21 | 	// Must return the number of data points
 22 | 	inline size_t kdtree_get_point_count() const { return pts.size(); }
 23 | 	// Returns the distance between the vector "p1[0:size-1]" and the data point with index "idx_p2" stored in the class:
 24 | 	inline T kdtree_distance(const T *p1, const size_t idx_p2,size_t size) const{
 25 | 		T d0=p1[0]-pts[idx_p2].x;
 26 | 		T d1=p1[1]-pts[idx_p2].y;
 27 | 		T d2=p1[2]-pts[idx_p2].z;
 28 | 		return d0*d0+d1*d1+d2*d2;
 29 | 	}
 30 |   // Returns the dim'th component of the idx'th point in the class:
 31 |   // Since this is inlined and the "dim" argument is typically an immediate value, the
 32 |   //  "if/else's" are actually solved at compile time.
 33 |   inline T kdtree_get_pt(const size_t idx, int dim) const
 34 |   {
 35 |     if (dim==0) return pts[idx].x;
 36 |     else if (dim==1) return pts[idx].y;
 37 |     else return pts[idx].z;
 38 |   }
 39 | 
 40 |   // Optional bounding-box computation: return false to default to a standard bbox computation loop.
 41 |   //   Return true if the BBOX was already computed by the class and returned in "bb" so it can be avoided to redo it again.
 42 |   //   Look at bb.size() to find out the expected dimensionality (e.g. 2 or 3 for point clouds)
 43 |   template <class BBOX>
 44 |   bool kdtree_get_bbox(BBOX &bb) const { return false; }
 45 |   // load dataset in Freiburg 3D scans format:
 46 |   PointCloud(){
 47 |     char str[300];
 48 |     cout << "Ingrese nombre archivo: ";
 49 |     scanf("%s", str);
 50 |     //FILE *f = fopen("juraset.asc","rt");
 51 | 		FILE *f = fopen(str,"rt");
 52 |     if (!f) throw std::runtime_error("can't open dataset file!");
 53 |     pts.clear();
 54 |     for (size_t i = 0; i < 15; i++) {
 55 |       fgets(str,sizeof(str),f);
 56 |     }
 57 |     while (fgets(str,sizeof(str),f)){
 58 |       float x,y,z;
 59 |       if (sscanf(str,"%f %f %f",&x,&y,&z)==3){
 60 |         pts.resize(pts.size()+1);
 61 |         pts.rbegin()->x=x;
 62 |         pts.rbegin()->y=y;
 63 |         pts.rbegin()->z=z;
 64 |       }
 65 |     }
 66 |     fprintf(stderr,"Read dataset: %u points\n", static_cast<unsigned int>(pts.size()));
 67 |     fclose(f);
 68 |   }
 69 | };
 70 | 
 71 | template <typename num_t>
 72 | void perf_test(const size_t max_leaf_elements,PointCloud<float> cloud){
 73 | 	num_t query_pt[3] = { 0, 0, 0};
 74 | 	//se arma el kd-tree
 75 | 	typedef KDTreeSingleIndexAdaptor<
 76 | 		L2_Simple_Adaptor<num_t, PointCloud<num_t> > ,
 77 | 		PointCloud<num_t>,
 78 | 		3 /* dim */
 79 | 		> my_kd_tree_t;
 80 | 
 81 | 	my_kd_tree_t   index(3 /*dim*/, cloud, KDTreeSingleIndexAdaptorParams(max_leaf_elements) );
 82 | 	index.buildIndex();
 83 | 	//busqueda en el arbol
 84 | 	const size_t num_results = 2;
 85 | 	int aux;
 86 | 	size_t ret_index;
 87 | 	num_t out_dist_sqr;
 88 | 	while(true){
 89 | 		 cout <<"Ingrese coordenadas x,y,z(seperados por coma): ";
 90 | 		 aux=scanf("%f,%f,%f",&query_pt[0], &query_pt[1], &query_pt[2]);
 91 | 		 if(aux==1 && query_pt[0]==0){
 92 | 			 break;
 93 | 		 }
 94 | 		 else if( aux!=3 ){
 95 | 			 continue;
 96 | 		 }
 97 | 		 else{
 98 | 			 std::cout << query_pt[0]<<","<<query_pt[1]<<","<<query_pt[2] << std::endl;
 99 | 	 		nanoflann::KNNResultSet<num_t> resultSet(num_results);
100 | 	 		resultSet.init(&ret_index, &out_dist_sqr );
101 | 	 		index.findNeighbors(resultSet, &query_pt[0], nanoflann::SearchParams(10));
102 | 	 		cout<< "ret_index=" << ret_index << " out_dist_sqr=" << out_dist_sqr << endl;
103 | 		 }
104 | 	}
105 | };
106 | 
107 | int main(int argc, char const *argv[]) {
108 |   PointCloud<float> cloudy;
109 | 	// for (size_t i = 0; i < cloudy.pts.size(); i++) {
110 | 	//   std::cout << cloudy.pts[i].x << " "
111 | 	//   << cloudy.pts[i].y << " "
112 | 	//   << cloudy.pts[i].z << " ";
113 | 	//   std::cout << std::endl;
114 | 	// }
115 | 	perf_test<float> (30,cloudy);
116 |   return 0;
117 | }
118 | 


--------------------------------------------------------------------------------
/test3.cpp:
--------------------------------------------------------------------------------
  1 | #include "../nanoflann/include/nanoflann.hpp"
  2 | 
  3 | #include <ctime>
  4 | #include <cstdlib>
  5 | #include <iostream>
  6 | 
  7 | using namespace std;
  8 | using namespace nanoflann;
  9 | 
 10 | #define REAL_DATASET_FILE "juraset.asc"
 11 | 
 12 | void dump_mem_usage();
 13 | 
 14 | // This is an exampleof a custom data set class
 15 | template <typename T>
 16 | struct PointCloud
 17 | {
 18 | 	struct Point
 19 | 	{
 20 | 		T  x,y,z;
 21 | 	};
 22 | 
 23 | 	std::vector<Point>  pts;
 24 | 
 25 | 	// Must return the number of data points
 26 | 	inline size_t kdtree_get_point_count() const { return pts.size(); }
 27 | 
 28 | 	// Returns the distance between the vector "p1[0:size-1]" and the data point with index "idx_p2" stored in the class:
 29 | 	inline T kdtree_distance(const T *p1, const size_t idx_p2,size_t /*size*/) const
 30 | 	{
 31 | 		const T d0=p1[0]-pts[idx_p2].x;
 32 | 		const T d1=p1[1]-pts[idx_p2].y;
 33 | 		const T d2=p1[2]-pts[idx_p2].z;
 34 | 		return d0*d0+d1*d1+d2*d2;
 35 | 	}
 36 | 
 37 | 	// Returns the dim'th component of the idx'th point in the class:
 38 | 	// Since this is inlined and the "dim" argument is typically an immediate value, the
 39 | 	//  "if/else's" are actually solved at compile time.
 40 | 	inline T kdtree_get_pt(const size_t idx, int dim) const
 41 | 	{
 42 | 		if (dim==0) return pts[idx].x;
 43 | 		else if (dim==1) return pts[idx].y;
 44 | 		else return pts[idx].z;
 45 | 	}
 46 | 
 47 | 	// Optional bounding-box computation: return false to default to a standard bbox computation loop.
 48 | 	//   Return true if the BBOX was already computed by the class and returned in "bb" so it can be avoided to redo it again.
 49 | 	//   Look at bb.size() to find out the expected dimensionality (e.g. 2 or 3 for point clouds)
 50 | 	template <class BBOX>
 51 | 	bool kdtree_get_bbox(BBOX& /* bb */) const { return false; }
 52 | 
 53 | 		// Default ctor.
 54 | 	PointCloud() {}
 55 | 
 56 | 	// load dataset in Freiburg 3D scans format:
 57 | 	PointCloud(const char* sFil)
 58 | 	{
 59 | 		FILE *f = fopen(sFil,"rt");
 60 | 		if (!f) throw std::runtime_error("can't open dataset file!");
 61 | 		pts.clear();
 62 | 
 63 | 		char str[300];
 64 | 		for (size_t i = 0; i < 15; i++) {
 65 | 			fgets(str,sizeof(str),f);
 66 | 		}
 67 | 		while (fgets(str,sizeof(str),f))
 68 | 		{
 69 | 			float x,y,z;
 70 | 			if (sscanf(str,"%f %f %f",&x,&y,&z)==3)
 71 | 			{
 72 | 					pts.resize(pts.size()+1);
 73 | 				pts.rbegin()->x=x;
 74 | 				pts.rbegin()->y=y;
 75 | 				pts.rbegin()->z=z;
 76 | 			}
 77 | 		}
 78 | 		fprintf(stderr,"Read dataset: %u points\n", static_cast<unsigned int>(pts.size()));
 79 | 
 80 | 		fclose(f);
 81 | 	}
 82 | 
 83 | };
 84 | 
 85 | 
 86 | 
 87 | #ifdef REAL_DATASET_FILE
 88 | PointCloud<float> cloud(REAL_DATASET_FILE);
 89 | #endif
 90 | 
 91 | 
 92 | 
 93 | template <typename num_t>
 94 | void kdtree_demo()
 95 | {
 96 | 	#ifndef REAL_DATASET_FILE
 97 | 
 98 | 		cout << "No existe dataset"<<endl;
 99 | 
100 | 	#else
101 | 		num_t query_pt[3] = { 0, 0, 0}; //elemento a buscar
102 | 	#endif
103 | 	// construct a kd-tree index:
104 | 	typedef KDTreeSingleIndexAdaptor<
105 | 		L2_Simple_Adaptor<num_t, PointCloud<num_t> > ,
106 | 		PointCloud<num_t>,
107 | 		3 /* dim */
108 | 		> my_kd_tree_t;
109 | 
110 | 	dump_mem_usage();
111 | 
112 | 	my_kd_tree_t   index(3 /*dim*/, cloud, KDTreeSingleIndexAdaptorParams(10 /* max leaf */) );
113 | 	index.buildIndex();
114 | 
115 | 	dump_mem_usage();
116 | 	{
117 | 		// do a knn search
118 | 		const size_t num_results = 1;
119 | 		size_t ret_index;
120 | 		num_t out_dist_sqr;
121 | 		nanoflann::KNNResultSet<num_t> resultSet(num_results);
122 | 		resultSet.init(&ret_index, &out_dist_sqr );
123 | 		index.findNeighbors(resultSet, &query_pt[0], nanoflann::SearchParams(10));
124 | 
125 | 		std::cout << "knnSearch(number results="<<num_results<<"): \n";
126 | 		std::cout << "ret_index=" << ret_index << " distancia max= " << out_dist_sqr << endl;
127 | 	}
128 | 	{
129 | 		// Unsorted radius search:
130 | 		const num_t radius = 1;
131 | 		std::vector<std::pair<size_t,num_t> > indices_dists;
132 | 		RadiusResultSet<num_t,size_t> resultSet(radius,indices_dists);
133 | 
134 | 		index.findNeighbors(resultSet, query_pt, nanoflann::SearchParams());
135 | 
136 | 		// Get worst (furthest) point, without sorting:
137 | 		std::pair<size_t,num_t> worst_pair = resultSet.worst_item();
138 | 		cout << "Worst pair: idx=" << worst_pair.first << " dist=" << worst_pair.second << endl;
139 | 	}
140 | 
141 | }
142 | 
143 | int main()
144 | {
145 | 	// Randomize Seed
146 | 	srand(time(NULL));
147 | 	kdtree_demo<float>();
148 | 	return 0;
149 | }
150 | 
151 | void dump_mem_usage()
152 | {
153 | 	FILE* f=fopen("/proc/self/statm","rt");
154 | 	if (!f) return;
155 | 	char str[300];
156 | 	size_t n=fread(str,1,200,f);
157 | 	str[n]=0;
158 | 	printf("MEM: %s\n",str);
159 | 	fclose(f);
160 | }
161 | 


--------------------------------------------------------------------------------
/BinaryTree.cpp:
--------------------------------------------------------------------------------
  1 | #include "BinaryTree.h"
  2 | #include <cstddef>
  3 | #include <iostream>
  4 | using namespace std;
  5 | 
  6 | 
  7 | 
  8 | // Smaller elements go left
  9 | // larger elements go right
 10 | void BinarySearchTree::insert(int d)
 11 | {
 12 |     tree_node* t = new tree_node;
 13 |     tree_node* parent;
 14 |     t->data = d;
 15 |     t->left = NULL;
 16 |     t->right = NULL;
 17 |     parent = NULL;
 18 |     
 19 |     // is this a new tree?
 20 |     if(isEmpty()) root = t;
 21 |     else
 22 |     {
 23 |         //Note: ALL insertions are as leaf nodes
 24 |         tree_node* curr;
 25 |         curr = root;
 26 |         // Find the Node's parent
 27 |         while(curr)
 28 |         {
 29 |             parent = curr;
 30 |             if(t->data > curr->data) curr = curr->right;
 31 |             else curr = curr->left;
 32 |         }
 33 | 
 34 |         if(t->data < parent->data)
 35 |            parent->left = t;
 36 |         else
 37 |            parent->right = t;
 38 |     }
 39 | }
 40 | 
 41 | void BinarySearchTree::remove(int d)
 42 | {
 43 |     //Locate the element
 44 |     bool found = false;
 45 |     if(isEmpty())
 46 |     {
 47 |         cout<<" This Tree is empty! "<<endl;
 48 |         return;
 49 |     }
 50 |     
 51 |     tree_node* curr;
 52 |     tree_node* parent;
 53 |     curr = root;
 54 |     
 55 |     while(curr != NULL)
 56 |     {
 57 |          if(curr->data == d)
 58 |          {
 59 |             found = true;
 60 |             break;
 61 |          }
 62 |          else
 63 |          {
 64 |              parent = curr;
 65 |              if(d>curr->data) curr = curr->right;
 66 |              else curr = curr->left;
 67 |          }
 68 |     }
 69 |     if(!found)
 70 | 		 {
 71 |         cout<<" Data not found! "<<endl;
 72 |         return;
 73 |     }
 74 | 
 75 | 
 76 | 		 // 3 cases :
 77 |     // 1. We're removing a leaf node
 78 |     // 2. We're removing a node with a single child
 79 |     // 3. we're removing a node with 2 children
 80 | 
 81 |     // Node with single child
 82 |     if((curr->left == NULL && curr->right != NULL)|| (curr->left != NULL
 83 | && curr->right == NULL))
 84 |     {
 85 |        if(curr->left == NULL && curr->right != NULL)
 86 |        {
 87 |            if(parent->left == curr)
 88 |            {
 89 |              parent->left = curr->right;
 90 |              delete curr;
 91 |            }
 92 |            else
 93 |            {
 94 |              parent->right = curr->right;
 95 |              delete curr;
 96 |            }
 97 |        }
 98 |        else // left child present, no right child
 99 |        {
100 |           if(parent->left == curr)
101 |            {
102 |              parent->left = curr->left;
103 |              delete curr;
104 |            }
105 |            else
106 |            {
107 |              parent->right = curr->left;
108 |              delete curr;
109 |            }
110 |        }
111 |      return;
112 |     }
113 | 
114 | 		 //We're looking at a leaf node
115 | 		 if( curr->left == NULL && curr->right == NULL)
116 |     {
117 |         if(parent->left == curr) parent->left = NULL;
118 |         else parent->right = NULL;
119 | 		 		 delete curr;
120 | 		 		 return;
121 |     }
122 | 
123 | 
124 |     //Node with 2 children
125 |     // replace node with smallest value in right subtree
126 |     if (curr->left != NULL && curr->right != NULL)
127 |     {
128 |         tree_node* chkr;
129 |         chkr = curr->right;
130 |         if((chkr->left == NULL) && (chkr->right == NULL))
131 |         {
132 |             curr = chkr;
133 |             delete chkr;
134 |             curr->right = NULL;
135 |         }
136 |         else // right child has children
137 |         {
138 |             //if the node's right child has a left child
139 |             // Move all the way down left to locate smallest element
140 | 
141 |             if((curr->right)->left != NULL)
142 |             {
143 |                 tree_node* lcurr;
144 |                 tree_node* lcurrp;
145 |                 lcurrp = curr->right;
146 |                 lcurr = (curr->right)->left;
147 |                 while(lcurr->left != NULL)
148 |                 {
149 |                    lcurrp = lcurr;
150 |                    lcurr = lcurr->left;
151 |                 }
152 | 		curr->data = lcurr->data;
153 |                 delete lcurr;
154 |                 lcurrp->left = NULL;
155 |            }
156 |            else
157 |            {
158 |                tree_node* tmp;
159 |                tmp = curr->right;
160 |                curr->data = tmp->data;
161 | 	       curr->right = tmp->right;
162 |                delete tmp;
163 |            }
164 | 
165 |         }
166 | 		 return;
167 |     }
168 | 
169 | }
170 | 
171 | void BinarySearchTree::print_inorder()
172 | {
173 |   inorder(root);
174 | }
175 | 
176 | void BinarySearchTree::inorder(tree_node* p)
177 | {
178 |     if(p != NULL)
179 |     {
180 |         if(p->left) inorder(p->left);
181 |         cout<<" "<<p->data<<" ";
182 |         if(p->right) inorder(p->right);
183 |     }
184 |     else return;
185 | }
186 | 
187 | void BinarySearchTree::print_preorder()
188 | {
189 |     preorder(root);
190 | }
191 | 
192 | void BinarySearchTree::preorder(tree_node* p)
193 | {
194 |     if(p != NULL)
195 |     {
196 |         cout<<" "<<p->data<<" ";
197 |         if(p->left) preorder(p->left);
198 |         if(p->right) preorder(p->right);
199 |     }
200 |     else return;
201 | }
202 | 
203 | void BinarySearchTree::print_postorder()
204 | {
205 |     postorder(root);
206 | }
207 | 
208 | void BinarySearchTree::postorder(tree_node* p)
209 | {
210 |     if(p != NULL)
211 |     {
212 |         if(p->left) postorder(p->left);
213 |         if(p->right) postorder(p->right);
214 |         cout<<" "<<p->data<<" ";
215 |     }
216 |     else return;
217 | }
218 | 
219 | 


--------------------------------------------------------------------------------
/test4.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | #include "../nanoflann/include/nanoflann.hpp"
  3 | 
  4 | #include <ctime>
  5 | #include <cstdlib>
  6 | #include <iostream>
  7 | 
  8 | using namespace std;
  9 | using namespace nanoflann;
 10 | #define REAL_DATASET_FILE "juraset.asc"
 11 | 
 12 | // This is an example of a custom data set class
 13 | template <typename T>
 14 | struct PointCloud
 15 | {
 16 | 	struct Point
 17 | 	{
 18 | 		T  x,y,z;
 19 | 	};
 20 | 
 21 | 	std::vector<Point>  pts;
 22 | 
 23 | 	// Must return the number of data points
 24 | 	inline size_t kdtree_get_point_count() const { return pts.size(); }
 25 | 
 26 | 	// Returns the distance between the vector "p1[0:size-1]" and the data point with index "idx_p2" stored in the class:
 27 | 	inline T kdtree_distance(const T *p1, const size_t idx_p2,size_t /*size*/) const
 28 | 	{
 29 | 		const T d0=p1[0]-pts[idx_p2].x;
 30 | 		const T d1=p1[1]-pts[idx_p2].y;
 31 | 		const T d2=p1[2]-pts[idx_p2].z;
 32 | 		return d0*d0+d1*d1+d2*d2;
 33 | 	}
 34 | 
 35 | 	// Returns the dim'th component of the idx'th point in the class:
 36 | 	// Since this is inlined and the "dim" argument is typically an immediate value, the
 37 | 	//  "if/else's" are actually solved at compile time.
 38 | 	inline T kdtree_get_pt(const size_t idx, int dim) const
 39 | 	{
 40 | 		if (dim==0) return pts[idx].x;
 41 | 		else if (dim==1) return pts[idx].y;
 42 | 		else return pts[idx].z;
 43 | 	}
 44 | 
 45 | 	// Optional bounding-box computation: return false to default to a standard bbox computation loop.
 46 | 	//   Return true if the BBOX was already computed by the class and returned in "bb" so it can be avoided to redo it again.
 47 | 	//   Look at bb.size() to find out the expected dimensionality (e.g. 2 or 3 for point clouds)
 48 | 	template <class BBOX>
 49 | 	bool kdtree_get_bbox(BBOX& /*bb*/) const { return false; }
 50 | 	// Default ctor.
 51 | 	PointCloud() {}
 52 | 
 53 | 	// load dataset in Freiburg 3D scans format:
 54 | 	PointCloud(const char* sFil)
 55 | 	{
 56 | 		FILE *f = fopen(sFil,"rt");
 57 | 		if (!f) throw std::runtime_error("can't open dataset file!");
 58 | 		pts.clear();
 59 | 
 60 | 		char str[300];
 61 | 		for (size_t i = 0; i < 15; i++) {
 62 | 			fgets(str,sizeof(str),f);
 63 | 		}
 64 | 		while (fgets(str,sizeof(str),f))
 65 | 		{
 66 | 			float x,y,z;
 67 | 			if (sscanf(str,"%f %f %f",&x,&y,&z)==3)
 68 | 			{
 69 | 					pts.resize(pts.size()+1);
 70 | 				pts.rbegin()->x=x;
 71 | 				pts.rbegin()->y=y;
 72 | 				pts.rbegin()->z=z;
 73 | 			}
 74 | 		}
 75 | 		fprintf(stderr,"Read dataset: %u points\n", static_cast<unsigned int>(pts.size()));
 76 | 
 77 | 		fclose(f);
 78 | 	}
 79 | };
 80 | 
 81 | template <typename T>
 82 | void generateRandomPointCloud(PointCloud<T> &point, const size_t N, const T max_range = 10)
 83 | {
 84 | 	std::cout << "Generating "<< N << " point cloud...";
 85 | 	point.pts.resize(N);
 86 | 	for (size_t i=0;i<N;i++)
 87 | 	{
 88 | 		point.pts[i].x = max_range * (rand() % 1000) / T(1000);
 89 | 		point.pts[i].y = max_range * (rand() % 1000) / T(1000);
 90 | 		point.pts[i].z = max_range * (rand() % 1000) / T(1000);
 91 | 	}
 92 | 
 93 | 	std::cout << "done\n";
 94 | }
 95 | 
 96 | 
 97 | 
 98 | 
 99 | 
100 | template <typename num_t>
101 | void kdtree_demo(const size_t N)
102 | {
103 | 	//PointCloud<num_t> cloud;
104 | 	#ifdef REAL_DATASET_FILE
105 | 		PointCloud<float> cloud(REAL_DATASET_FILE);
106 | 	#endif
107 | 	// Generate points:
108 | 	//generateRandomPointCloud(cloud, N);
109 | 
110 | 	// construct a kd-tree index:
111 | 	#ifndef REAL_DATASET_FILE
112 | 
113 | 		cout << "No existe dataset"<<endl;
114 | 
115 | 	#else
116 | 		num_t query_pt[3] = { 0, 0, 0}; //elemento a buscar
117 | 	#endif
118 | 
119 | 	/*
120 | 	typedef KDTreeSingleIndexAdaptor<
121 | 		L2_Simple_Adaptor<num_t, PointCloud<num_t> > ,
122 | 		PointCloud<num_t>,
123 | 		3 
124 | 		> my_kd_tree_t;
125 | 
126 | 	my_kd_tree_t   index(3 , cloud, KDTreeSingleIndexAdaptorParams(10));
127 | 	index.buildIndex();
128 | 	*/
129 | 
130 | 	typedef KDTreeSingleIndexAdaptor<
131 | 		L2_Simple_Adaptor<num_t, PointCloud<num_t> > ,
132 | 		PointCloud<num_t>,
133 | 		3 /* dim */
134 | 		> my_kd_tree_t;
135 | 
136 | 	my_kd_tree_t   index(3 /*dim*/, cloud, KDTreeSingleIndexAdaptorParams(N) );
137 | 	index.buildIndex();
138 | 
139 | 	// ----------------------------------------------------------------
140 | 	// knnSearch():  Perform a search for the N closest points
141 | 	// ----------------------------------------------------------------
142 | 	{
143 | 		size_t num_results = 5;
144 | 		std::vector<size_t>   ret_index(num_results);
145 | 		std::vector<num_t> out_dist_sqr(num_results);
146 | 
147 | 		num_results = index.knnSearch(&query_pt[0], num_results, &ret_index[0], &out_dist_sqr[0]);
148 | 		
149 | 		// In case of less points in the tree than requested:
150 | 		ret_index.resize(num_results);
151 | 		out_dist_sqr.resize(num_results);
152 | 
153 | 		cout << "knnSearch(): num_results=" << num_results << "\n";
154 | 		for (size_t i=0;i<num_results;i++)
155 | 			cout << "idx["<< i << "]=" << ret_index[i] << " dist["<< i << "]=" << out_dist_sqr[i] << endl;
156 | 		cout << "\n";
157 | 	}
158 | 
159 | 	// ----------------------------------------------------------------
160 | 	// radiusSearch():  Perform a search for the N closest points
161 | 	// ----------------------------------------------------------------
162 | 	{
163 | 		const num_t search_radius = static_cast<num_t>(10);
164 | 		std::vector<std::pair<size_t,num_t> >   ret_matches;
165 | 
166 | 		nanoflann::SearchParams params;
167 | 		//params.sorted = false;
168 | 
169 | 		const size_t nMatches = index.radiusSearch(&query_pt[0],search_radius, ret_matches, params);
170 | 
171 | 		cout << "radiusSearch(): radius=" << search_radius << " -> " << nMatches << " matches\n";
172 | 		for (size_t i=0;i<nMatches;i++)
173 | 			cout << "idx["<< i << "]=" << ret_matches[i].first << " dist["<< i << "]=" << ret_matches[i].second << endl;
174 | 		cout << "\n";
175 | 	}
176 | 
177 | }
178 | 
179 |  int main()
180 | {
181 | 	// Randomize Seed
182 | 	srand(time(NULL));
183 | 	//kdtree_demo<float>(4);
184 | 	kdtree_demo<float>(10);
185 | 	return 0;
186 | }
187 | 
188 | 


--------------------------------------------------------------------------------
/test2.cpp:
--------------------------------------------------------------------------------
  1 | #include "../nanoflann/include/nanoflann.hpp"
  2 | #include <cstdlib>
  3 | #include <iostream>
  4 | #include <sys/time.h>
  5 | 
  6 | using namespace std;
  7 | using namespace nanoflann;
  8 | 
  9 | // Comment-out for using random points:
 10 | #define REAL_DATASET_FILE "juraset.asc"
 11 | 
 12 | #define VERBOSE_OUTPUT
 13 | 
 14 | #ifdef VERBOSE_OUTPUT
 15 | #	define VERB_COUT std::cout
 16 | #else
 17 | #	define VERB_COUT if (0) std::cout
 18 | #endif
 19 | 
 20 | 
 21 | template <typename T>
 22 | struct PointCloud
 23 | {
 24 | 	struct Point
 25 | 	{
 26 | 		T  x,y,z;
 27 | 	};
 28 | 
 29 | 	std::vector<Point>  pts;
 30 | 
 31 | 	typedef  PointCloud Derived; //!< In this case the dataset class is myself.
 32 | 
 33 | 	/// CRTP helper method
 34 | 	inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
 35 | 	/// CRTP helper method
 36 | 	inline       Derived& derived()       { return *static_cast<Derived*>(this); }
 37 | 
 38 | 	// Must return the number of data points
 39 | 	inline size_t kdtree_get_point_count() const { return pts.size(); }
 40 | 
 41 | 	// Returns the distance between the vector "p1[0:size-1]" and the data point with index "idx_p2" stored in the class:
 42 | 	inline T kdtree_distance(const T *p1, const size_t idx_p2,size_t size) const
 43 | 	{
 44 | 		T d0=p1[0]-pts[idx_p2].x;
 45 | 		T d1=p1[1]-pts[idx_p2].y;
 46 | 		T d2=p1[2]-pts[idx_p2].z;
 47 | 		return d0*d0+d1*d1+d2*d2;
 48 | 	}
 49 | 
 50 | 	// Returns the dim'th component of the idx'th point in the class:
 51 | 	// Since this is inlined and the "dim" argument is typically an immediate value, the
 52 | 	//  "if/else's" are actually solved at compile time.
 53 | 	inline T kdtree_get_pt(const size_t idx, int dim) const
 54 | 	{
 55 | 		if (dim==0) return pts[idx].x;
 56 | 		else if (dim==1) return pts[idx].y;
 57 | 		else return pts[idx].z;
 58 | 	}
 59 | 
 60 | 	// Optional bounding-box computation: return false to default to a standard bbox computation loop.
 61 | 	//   Return true if the BBOX was already computed by the class and returned in "bb" so it can be avoided to redo it again.
 62 | 	//   Look at bb.size() to find out the expected dimensionality (e.g. 2 or 3 for point clouds)
 63 | 	template <class BBOX>
 64 | 	bool kdtree_get_bbox(BBOX &bb) const { return false; }
 65 | 
 66 | 	// Default ctor.
 67 | 	PointCloud() {}
 68 | 
 69 | 	// load dataset in Freiburg 3D scans format:
 70 | 	PointCloud(const char* sFil)
 71 | 	{
 72 | 		size_t c=0;
 73 | 		FILE *f = fopen(sFil,"rt");
 74 | 		if (!f) throw std::runtime_error("can't open dataset file!");
 75 | 		pts.clear();
 76 | 
 77 | 		char str[300];
 78 | 		for (size_t i = 0; i < 15; i++) {
 79 | 			fgets(str,sizeof(str),f);
 80 | 		}
 81 | 		while (fgets(str,sizeof(str),f))
 82 | 		{
 83 | 			float x,y,z;
 84 | 			if (sscanf(str,"%f %f %f",&x,&y,&z)==3)
 85 | 			{
 86 | 					pts.resize(pts.size()+1);
 87 | 				pts.rbegin()->x=x;
 88 | 				pts.rbegin()->y=y;
 89 | 				pts.rbegin()->z=z;
 90 | 			}
 91 | 		}
 92 | 		fprintf(stderr,"Read dataset: %u points\n", static_cast<unsigned int>(pts.size()));
 93 | 
 94 | 		fclose(f);
 95 | 	}
 96 | };
 97 | 
 98 | double get_time()
 99 | {
100 | 	struct timeval tv;
101 | 	gettimeofday(&tv,NULL);
102 | 	return tv.tv_sec+tv.tv_usec/1000000.0;
103 | }
104 | 
105 | double my_random(const double min,const double max)
106 | {
107 | 	return min+(max-min)*(rand() % 1000) / 1000.0;
108 | }
109 | 
110 | template <typename T>
111 | void generateRandomPointCloud(PointCloud<T> &point, const size_t N, const T max_range = 10)
112 | {
113 | 	VERB_COUT << "Generating "<< N << " point cloud...";
114 | 	const double t0=get_time();
115 | 
116 | 	point.pts.resize(N);
117 | 	for (size_t i=0;i<N;i++)
118 | 	{
119 | 		point.pts[i].x = max_range * (rand() % 1000) / T(1000);
120 | 		point.pts[i].y = max_range * (rand() % 1000) / T(1000);
121 | 		point.pts[i].z = max_range * (rand() % 1000) / T(1000);
122 | 	}
123 | 
124 | 	const double t1=get_time();
125 | 	VERB_COUT << "done in "<< (t1-t0)*1e3 << " ms\n";
126 | }
127 | 
128 | // Load dataset only once:
129 | #ifdef REAL_DATASET_FILE
130 | PointCloud<float> cloud(REAL_DATASET_FILE);
131 | #endif
132 | 
133 | 
134 | //FIN CARGAR DATASET!
135 | 
136 | 
137 | 
138 | 
139 | template <typename num_t>
140 | 
141 | //funcion de prueba, entrega vecino más cercano. se debe definir el max numero
142 | void perf_test(const size_t max_leaf_elements)
143 | {
144 | #ifndef REAL_DATASET_FILE
145 | 
146 | 	cout << "No existe dataset"<<endl;
147 | 
148 | #else
149 | 	float xUser, yUser, zUser;
150 | 	num_t query_pt[3] = { 0, 0, 0}; //elemento a buscar
151 | #endif
152 | 
153 | 	// construct an randomized kd-tree index using 4 kd-trees
154 | 	double t0=get_time();
155 | 
156 | 	typedef KDTreeSingleIndexAdaptor<
157 | 		L2_Simple_Adaptor<num_t, PointCloud<num_t> > ,
158 | 		PointCloud<num_t>,
159 | 		3 /* dim */
160 | 		> my_kd_tree_t;
161 | 
162 | 	my_kd_tree_t   index(3 /*dim*/, cloud, KDTreeSingleIndexAdaptorParams(max_leaf_elements) );
163 | 	index.buildIndex();
164 | 	double t1=get_time();
165 | 	const double At_build = t1-t0;
166 | 	VERB_COUT << "Build Index<>: " << (t1-t0)*1e3 << " ms\n";
167 | 
168 | 	// do a knn search
169 | 	t0=get_time();
170 | 
171 | 	const size_t num_results = 1;
172 | 	size_t ret_index;
173 | 	num_t out_dist_sqr;
174 | 	nanoflann::KNNResultSet<num_t> resultSet(num_results);
175 | 	resultSet.init(&ret_index, &out_dist_sqr );
176 | 	index.findNeighbors(resultSet, &query_pt[0], nanoflann::SearchParams(10));
177 | 	//index.knnSearch(query, indices, dists, num_results, nanoflann::SearchParams(10));
178 | 
179 | 	t1=get_time();
180 | 	const double At_search = t1-t0;
181 | 	VERB_COUT << "knnSearch(num results= "<<num_results<<"): " << (t1-t0)*1e3 << " ms\n";
182 | 	VERB_COUT << "ret_index=" << ret_index << " distancia max" << out_dist_sqr << endl;
183 | 
184 | 	// Output for stats generation:
185 | 	cout
186 | 		<< cloud.pts.size() << "\t "
187 | 		<< max_leaf_elements << "\t "
188 | 		<< At_build << "\t "
189 | 		<< At_search << "\n";
190 | 
191 | }
192 | 
193 | 
194 | 
195 | int main(int argc, char** argv)
196 | {
197 | 
198 | 	size_t maxLeaf = 50; // VARIAR ENTRE 10 Y 50!
199 | 	perf_test<float>(maxLeaf);
200 | 
201 | 
202 | 
203 | 	return 0;
204 | }
205 | 


--------------------------------------------------------------------------------
/test4dimensiones.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | #include "../nanoflann/include/nanoflann.hpp"
  3 | 
  4 | #include <ctime>
  5 | #include <cstdlib>
  6 | #include <iostream>
  7 | 
  8 | using namespace std;
  9 | using namespace nanoflann;
 10 | #define REAL_DATASET_FILE "juraset.asc"
 11 | 
 12 | // This is an example of a custom data set class
 13 | template <typename T>
 14 | struct PointCloud
 15 | {
 16 | 	struct Point
 17 | 	{
 18 | 		T  a,b,c,d;
 19 | 	};
 20 | 
 21 | 	std::vector<Point>  pts;
 22 | 
 23 | 	// Must return the number of data points
 24 | 	inline size_t kdtree_get_point_count() const { return pts.size(); }
 25 | 
 26 | 	// Returns the distance between the vector "p1[0:size-1]" and the data point with index "idx_p2" stored in the class:
 27 | 	inline T kdtree_distance(const T *p1, const size_t idx_p2,size_t /*size*/) const
 28 | 	{
 29 | 		const T d0=p1[0]-pts[idx_p2].a;
 30 | 		const T d1=p1[1]-pts[idx_p2].b;
 31 | 		const T d2=p1[2]-pts[idx_p2].c;
 32 | 		const T d3=p1[3]-pts[idx_p2].d;
 33 | 		return d0*d0+d1*d1+d2*d2+d3*d3;
 34 | 	}
 35 | 	/* Para 3 dimensiones
 36 | 	inline T kdtree_distance(const T *p1, const size_t idx_p2,size_t ) const
 37 | 	{
 38 | 		const T d0=p1[0]-pts[idx_p2].x;
 39 | 		const T d1=p1[1]-pts[idx_p2].y;
 40 | 		const T d2=p1[2]-pts[idx_p2].z;
 41 | 		return d0*d0+d1*d1+d2*d2;
 42 | 	}*/
 43 | 
 44 | 	// Returns the dim'th component of the idx'th point in the class:
 45 | 	// Since this is inlined and the "dim" argument is typically an immediate value, the
 46 | 	//  "if/else's" are actually solved at compile time.
 47 | 	inline T kdtree_get_pt(const size_t idx, int dim) const
 48 | 	{
 49 | 		if (dim==0) return pts[idx].a;
 50 | 		else if (dim==1) return pts[idx].b;
 51 | 		else if(dim == 2)return pts[idx].c;
 52 | 		else return pts[idx].d;
 53 | 	}
 54 | 
 55 | 	// Optional bounding-box computation: return false to default to a standard bbox computation loop.
 56 | 	//   Return true if the BBOX was already computed by the class and returned in "bb" so it can be avoided to redo it again.
 57 | 	//   Look at bb.size() to find out the expected dimensionality (e.g. 2 or 3 for point clouds)
 58 | 	template <class BBOX>
 59 | 	bool kdtree_get_bbox(BBOX& /*bb*/) const { return false; }
 60 | 	// Default ctor.
 61 | 	PointCloud() {}
 62 | 
 63 | 	// load dataset in Freiburg 3D scans format:
 64 | 	PointCloud(const char* sFil)
 65 | 	{
 66 | 		FILE *f = fopen(sFil,"rt");
 67 | 		if (!f) throw std::runtime_error("can't open dataset file!");
 68 | 		pts.clear();
 69 | 
 70 | 		char str[300];
 71 | 		for (size_t i = 0; i < 15; i++) {
 72 | 			fgets(str,sizeof(str),f);
 73 | 		}
 74 | 		while (fgets(str,sizeof(str),f))
 75 | 		{
 76 | 			float a,b,c,d;
 77 | 			if (sscanf(str,"%f %f %f %f",&a,&b,&c,&d)==4)
 78 | 			{
 79 | 					pts.resize(pts.size()+1);
 80 | 				pts.rbegin()->a=a;
 81 | 				pts.rbegin()->b=b;
 82 | 				pts.rbegin()->c=c;
 83 | 				pts.rbegin()->d=d;
 84 | 			}
 85 | 		}
 86 | 		fprintf(stderr,"Read dataset: %u points\n", static_cast<unsigned int>(pts.size()));
 87 | 
 88 | 		fclose(f);
 89 | 	}
 90 | };
 91 | 
 92 | template <typename T>
 93 | void generateRandomPointCloud(PointCloud<T> &point, const size_t N, const T max_range = 10)
 94 | {
 95 | 	std::cout << "Generating "<< N << " point cloud...";
 96 | 	point.pts.resize(N);
 97 | 	for (size_t i=0;i<N;i++)
 98 | 	{
 99 | 		point.pts[i].x = max_range * (rand() % 1000) / T(1000);
100 | 		point.pts[i].y = max_range * (rand() % 1000) / T(1000);
101 | 		point.pts[i].z = max_range * (rand() % 1000) / T(1000);
102 | 	}
103 | 
104 | 	std::cout << "done\n";
105 | }
106 | 
107 | 
108 | 
109 | 
110 | 
111 | template <typename num_t>
112 | void kdtree_demo(const size_t N)
113 | {
114 | 	//PointCloud<num_t> cloud;
115 | 	#ifdef REAL_DATASET_FILE
116 | 		PointCloud<float> cloud(REAL_DATASET_FILE);
117 | 	#endif
118 | 	// Generate points:
119 | 	//generateRandomPointCloud(cloud, N);
120 | 
121 | 	// construct a kd-tree index:
122 | 	#ifndef REAL_DATASET_FILE
123 | 
124 | 		cout << "No existe dataset"<<endl;
125 | 
126 | 	#else
127 | 		//num_t query_pt[3] = { 0, 0, 0}; //elemento a buscar
128 | 		num_t query_pt[4] = { 0, 0, 0,0}; //elemento a buscar
129 | 
130 | 	#endif
131 | 
132 | 
133 | 
134 | 	typedef KDTreeSingleIndexAdaptor<
135 | 		L2_Simple_Adaptor<num_t, PointCloud<num_t> > ,
136 | 		PointCloud<num_t>,
137 | 		4 /* dim */
138 | 		> my_kd_tree_t;
139 | 
140 | 	my_kd_tree_t   index(4 /*dim*/, cloud, KDTreeSingleIndexAdaptorParams(N) );
141 | 	index.buildIndex();
142 | 
143 | 	// ----------------------------------------------------------------
144 | 	// knnSearch():  Perform a search for the N closest points
145 | 	// ----------------------------------------------------------------
146 | 	{
147 | 		size_t num_results = 5;
148 | 		std::vector<size_t>   ret_index(num_results);
149 | 		std::vector<num_t> out_dist_sqr(num_results);
150 | 
151 | 		num_results = index.knnSearch(&query_pt[0], num_results, &ret_index[0], &out_dist_sqr[0]);
152 | 		
153 | 		// In case of less points in the tree than requested:
154 | 		ret_index.resize(num_results);
155 | 		out_dist_sqr.resize(num_results);
156 | 
157 | 		cout << "knnSearch(): num_results=" << num_results << "\n";
158 | 		for (size_t i=0;i<num_results;i++)
159 | 			cout << "idx["<< i << "]=" << ret_index[i] << " dist["<< i << "]=" << out_dist_sqr[i] << endl;
160 | 		cout << "\n";
161 | 	}
162 | 
163 | 	// ----------------------------------------------------------------
164 | 	// radiusSearch():  Perform a search for the N closest points
165 | 	// ----------------------------------------------------------------
166 | 	{
167 | 		const num_t search_radius = static_cast<num_t>(10);
168 | 		std::vector<std::pair<size_t,num_t> >   ret_matches;
169 | 
170 | 		nanoflann::SearchParams params;
171 | 		//params.sorted = false;
172 | 
173 | 		const size_t nMatches = index.radiusSearch(&query_pt[0],search_radius, ret_matches, params);
174 | 
175 | 		cout << "radiusSearch(): radius=" << search_radius << " -> " << nMatches << " matches\n";
176 | 		for (size_t i=0;i<nMatches;i++)
177 | 			cout << "idx["<< i << "]=" << ret_matches[i].first << " dist["<< i << "]=" << ret_matches[i].second << endl;
178 | 		cout << "\n";
179 | 	}
180 | 
181 | }
182 | 
183 |  int main()
184 | {
185 | 	// Randomize Seed
186 | 	srand(time(NULL));
187 | 	//kdtree_demo<float>(4);
188 | 	kdtree_demo<float>(10);
189 | 	return 0;
190 | }
191 | 
192 | 


--------------------------------------------------------------------------------
/main.cpp:
--------------------------------------------------------------------------------
  1 | using namespace std;
  2 | #include "BinaryTree.h"
  3 | #include "helper.h"
  4 | #include <time.h>
  5 | #include <cstddef>
  6 | #include "../nanoflann/include/nanoflann.hpp"
  7 | using namespace nanoflann;
  8 | 
  9 | 
 10 | //void dump_mem_usage();
 11 | 
 12 | struct PointCloud
 13 | {
 14 |   struct Point
 15 |   {
 16 |     float  x,y,z;
 17 |   };
 18 | 
 19 |   std::vector<Point>  pts;
 20 |   // Must return the number of data points
 21 |   inline size_t kdtree_get_point_count() const { return pts.size(); }
 22 | 
 23 |   // Returns the distance between the vector "p1[0:size-1]" and the data point with index "idx_p2" stored in the class:
 24 |   inline float kdtree_distance(const T *p1, const size_t idx_p2,size_t /*size*/) const
 25 |   {
 26 |     const float d0=p1[0]-pts[idx_p2].x;
 27 |     const float d1=p1[1]-pts[idx_p2].y;
 28 |     const float d2=p1[2]-pts[idx_p2].z;
 29 |     return d0*d0+d1*d1+d2*d2;
 30 |   }
 31 | 
 32 |   // Returns the dim'th component of the idx'th point in the class:
 33 |   // Since this is inlined and the "dim" argument is typically an immediate value, the
 34 |   //  "if/else's" are actually solved at compile time.
 35 |   inline float kdtree_get_pt(const size_t idx, int dim) const
 36 |   {
 37 |     if (dim==0) return pts[idx].x;
 38 |     else if (dim==1) return pts[idx].y;
 39 |     else return pts[idx].z;
 40 |   }
 41 | 
 42 |   // Optional bounding-box computation: return false to default to a standard bbox computation loop.
 43 |   //   Return true if the BBOX was already computed by the class and returned in "bb" so it can be avoided to redo it again.
 44 |   //   Look at bb.size() to find out the expected dimensionality (e.g. 2 or 3 for point clouds)
 45 |   template <class BBOX>
 46 |   bool kdtree_get_bbox(BBOX& /* bb */) const { return false; }
 47 | 
 48 | };
 49 | 
 50 | std::vector<std::vector<float> >  generatePointCloud(string fileName, int dimensionNumber)
 51 | {
 52 |   std::cout << "Generando nube de puntos...";
 53 |   Helper helper;
 54 |   std::vector<std::vector<float> > data = helper.loadFile(fileName,dimensionNumber);
 55 |   std::cout << "Realizado\n";
 56 |   return data;
 57 | 
 58 | }
 59 | 
 60 | PointCloud transformDataToCloud(vector<vector<float>> data){
 61 |   PointCloud cloud;
 62 |   for(size_t i = 0; i < data.size();i++){
 63 |     for(size_t j = 0; j < 3; j++){
 64 |       if(j == 0){
 65 |         cloud.pts[i][0]; // x
 66 |       }
 67 |       if(j == 1){
 68 |         cloud.pts[i][1]; // y
 69 |       }
 70 |       else{
 71 |         cloud.pts[i][2]; //z
 72 |       }
 73 | 
 74 |     }
 75 |   }
 76 |   return cloud;
 77 | }
 78 | 
 79 | void kdtree_demo(string fileName, int dimensionNumber)
 80 | {
 81 | 
 82 |   // Generate points:
 83 |   vector<vector<float>> data = generatePointCloud(fileName,dimensionNumber);
 84 |   PointCloud cloud = transformDataToCloud(data); //data lista para ser trabajada con nanoflann
 85 | 
 86 |   num_t query_pt[3] = { 0.5, 0.5, 0.5}; // elemento a buscar
 87 | 
 88 | 
 89 |   // construct a kd-tree index:
 90 |   typedef KDTreeSingleIndexAdaptor<
 91 |     L2_Simple_Adaptor<float, PointCloud > ,
 92 |     PointCloud,
 93 |     3 /* dim */
 94 |     > my_kd_tree_t;
 95 | 
 96 |   dump_mem_usage();
 97 |   /*
 98 |   my_kd_tree_t   index(3 , cloud, KDTreeSingleIndexAdaptorParams(10 ) );
 99 |   index.buildIndex();
100 | 
101 |   dump_mem_usage();
102 |   {
103 |     // do a knn search
104 |     const size_t num_results = 1;
105 |     size_t ret_index;
106 |     num_t out_dist_sqr;
107 |     nanoflann::KNNResultSet<num_t> resultSet(num_results);
108 |     resultSet.init(&ret_index, &out_dist_sqr );
109 |     index.findNeighbors(resultSet, &query_pt[0], nanoflann::SearchParams(10));
110 | 
111 |     std::cout << "knnSearch(nn="<<num_results<<"): \n";
112 |     std::cout << "ret_index=" << ret_index << " out_dist_sqr=" << out_dist_sqr << endl;
113 |   }
114 | 
115 |     // Unsorted radius search:
116 |     /*
117 |     {
118 |     const num_t radius = 1;
119 |     std::vector<std::pair<size_t,num_t> > indices_dists;
120 |     RadiusResultSet<num_t,size_t> resultSet(radius,indices_dists);
121 | 
122 |     index.findNeighbors(resultSet, query_pt, nanoflann::SearchParams());
123 | 
124 |     // Get worst (furthest) point, without sorting:
125 |     std::pair<size_t,num_t> worst_pair = resultSet.worst_item();
126 |     cout << "Worst pair: idx=" << worst_pair.first << " dist=" << worst_pair.second << endl;
127 |     }
128 |     */
129 | 
130 | 
131 | }
132 | 
133 | 
134 | 
135 | int main()
136 | {
137 |   Helper helper;
138 |   string fileName;
139 |   int dimensionNumber;
140 |   cout << "Ingrese nombre archivo: ";
141 |   cin>>textFile;
142 |   cout << "Ingrese número de variables que desee usar (0 para todas las que contiene el archivo): ";
143 |   cin >> dimensionNumber;
144 | 
145 |   kdtree_demo(fileName,dimensionNumber);
146 | 
147 | }
148 | 
149 | /*
150 | 
151 |   vector<vector<float>> data = helper.loadFile(textFile,dimensionNumber);
152 |   for(size_t i = 0; i < data.size();i++){
153 |     for(size_t j = 0; j < data[0].size();j++){
154 |       cout<< data[i][j]<<" ";
155 |     }
156 |     cout<<endl;
157 |   }
158 |     BinarySearchTree b;
159 |     int ch,tmp,tmp1;
160 |     while(1)
161 |     {
162 |        cout<<endl<<endl;
163 |        cout<<" Binary Search Tree Operations "<<endl;
164 |        cout<<" ----------------------------- "<<endl;
165 |        cout<<" 1. Insertion/Creation "<<endl;
166 |        cout<<" 2. In-Order Traversal "<<endl;
167 |        cout<<" 3. Pre-Order Traversal "<<endl;
168 |        cout<<" 4. Post-Order Traversal "<<endl;
169 |        cout<<" 5. Removal "<<endl;
170 |        cout<<" 6. Exit "<<endl;
171 |        cout<<" Enter your choice : ";
172 |        cin>>ch;
173 |        switch(ch)
174 |        {
175 |            case 1 : cout<<" Enter Number to be inserted : ";
176 |                     cin>>tmp;
177 |                     b.insert(tmp);
178 |                     break;
179 |            case 2 : cout<<endl;
180 |                     cout<<" In-Order Traversal "<<endl;
181 |                     cout<<" -------------------"<<endl;
182 |                     b.print_inorder();
183 |                     break;
184 |            case 3 : cout<<endl;
185 |                     cout<<" Pre-Order Traversal "<<endl;
186 |                     cout<<" -------------------"<<endl;
187 |                     b.print_preorder();
188 |                     break;
189 |            case 4 : cout<<endl;
190 |                     cout<<" Post-Order Traversal "<<endl;
191 |                     cout<<" --------------------"<<endl;
192 |                     b.print_postorder();
193 |                     break;
194 |            case 5 : cout<<" Enter data to be deleted : ";
195 |                     cin>>tmp1;
196 |                     b.remove(tmp1);
197 |                     break;
198 |            case 6 :
199 |                     return 0;
200 | 
201 |        }
202 |     }*/
203 | 


--------------------------------------------------------------------------------
/test10dimensiones.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | #include "../nanoflann/include/nanoflann.hpp"
  3 | 
  4 | #include <ctime>
  5 | #include <cstdlib>
  6 | #include <iostream>
  7 | 
  8 | using namespace std;
  9 | using namespace nanoflann;
 10 | #define REAL_DATASET_FILE "datos.txt"
 11 | 
 12 | // This is an example of a custom data set class
 13 | template <typename T>
 14 | struct PointCloud
 15 | {
 16 | 	struct Point
 17 | 	{
 18 | 		T  a,b,c,d,e,f,g,h,i,j;
 19 | 	};
 20 | 
 21 | 	std::vector<Point>  pts;
 22 | 
 23 | 	// Must return the number of data points
 24 | 	inline size_t kdtree_get_point_count() const { return pts.size(); }
 25 | 
 26 | 	// Returns the distance between the vector "p1[0:size-1]" and the data point with index "idx_p2" stored in the class:
 27 | 	inline T kdtree_distance(const T *p1, const size_t idx_p2,size_t /*size*/) const
 28 | 	{
 29 | 		const T d0=p1[0]-pts[idx_p2].a;
 30 | 		const T d1=p1[1]-pts[idx_p2].b;
 31 | 		const T d2=p1[2]-pts[idx_p2].c;
 32 | 		const T d3=p1[3]-pts[idx_p2].d;
 33 | 		const T d4=p1[4]-pts[idx_p2].e;
 34 | 		const T d5=p1[5]-pts[idx_p2].f;
 35 | 		const T d6=p1[6]-pts[idx_p2].g;
 36 | 		const T d7=p1[6]-pts[idx_p2].h;
 37 | 		const T d8=p1[7]-pts[idx_p2].i;
 38 | 		const T d9=p1[8]-pts[idx_p2].j;
 39 | 		return d0*d0+d1*d1+d2*d2+d3*d3+d4*d4+d5*d5+d6*d6+d7+d7+d8*d8+d9*d9;
 40 | 	}
 41 | 	/* Para 3 dimensiones
 42 | 	inline T kdtree_distance(const T *p1, const size_t idx_p2,size_t ) const
 43 | 	{
 44 | 		const T d0=p1[0]-pts[idx_p2].x;
 45 | 		const T d1=p1[1]-pts[idx_p2].y;
 46 | 		const T d2=p1[2]-pts[idx_p2].z;
 47 | 		return d0*d0+d1*d1+d2*d2;
 48 | 	}*/
 49 | 
 50 | 	// Returns the dim'th component of the idx'th point in the class:
 51 | 	// Since this is inlined and the "dim" argument is typically an immediate value, the
 52 | 	//  "if/else's" are actually solved at compile time.
 53 | 	inline T kdtree_get_pt(const size_t idx, int dim) const
 54 | 	{
 55 | 		if (dim==0) return pts[idx].a;
 56 | 		else if (dim==1) return pts[idx].b;
 57 | 		else if(dim == 2)return pts[idx].c;
 58 | 		else if(dim == 3) return pts[idx].d;
 59 | 		else if(dim == 4) return pts[idx].e;
 60 | 		else if(dim ==5) return pts[idx].f;
 61 | 		else if(dim == 6) return pts[idx].g;
 62 | 		else if(dim == 7) return pts[idx].h;
 63 | 		else if(dim == 8) return pts[idx].i;
 64 | 		else return pts[idx].j;
 65 | 	}
 66 | 
 67 | 	// Optional bounding-box computation: return false to default to a standard bbox computation loop.
 68 | 	//   Return true if the BBOX was already computed by the class and returned in "bb" so it can be avoided to redo it again.
 69 | 	//   Look at bb.size() to find out the expected dimensionality (e.g. 2 or 3 for point clouds)
 70 | 	template <class BBOX>
 71 | 	bool kdtree_get_bbox(BBOX& /*bb*/) const { return false; }
 72 | 	// Default ctor.
 73 | 	PointCloud() {}
 74 | 
 75 | 	// load dataset in Freiburg 3D scans format:
 76 | 	PointCloud(const char* sFil)
 77 | 	{
 78 | 		FILE *f = fopen(sFil,"rt");
 79 | 		if (!f) throw std::runtime_error("can't open dataset file!");
 80 | 		pts.clear();
 81 | 
 82 | 		char str[300];
 83 | 		for (size_t i = 0; i < 15; i++) {
 84 | 			fgets(str,sizeof(str),f);
 85 | 		}
 86 | 		while (fgets(str,sizeof(str),f))
 87 | 		{
 88 | 			float a,b,c,d,e,f,g,h,i,j;
 89 | 			if (sscanf(str,"%f %f %f %f %f %f %f %f %f %f",&a,&b,&c,&d,&e,&f,&g,&h,&i,&j)==10)
 90 | 			{
 91 | 					pts.resize(pts.size()+1);
 92 | 				pts.rbegin()->a=a;
 93 | 				pts.rbegin()->b=b;
 94 | 				pts.rbegin()->c=c;
 95 | 				pts.rbegin()->d=d;
 96 | 				pts.rbegin()->e=e;
 97 | 				pts.rbegin()->f=f;
 98 | 				pts.rbegin()->g=g;
 99 | 				pts.rbegin()->h=h;
100 | 				pts.rbegin()->i=i;
101 | 				pts.rbegin()->j=j;
102 | 			}
103 | 		}
104 | 		fprintf(stderr,"Read dataset: %u points\n", static_cast<unsigned int>(pts.size()));
105 | 
106 | 		fclose(f);
107 | 	}
108 | };
109 | 
110 | template <typename T>
111 | void generateRandomPointCloud(PointCloud<T> &point, const size_t N, const T max_range = 10)
112 | {
113 | 	std::cout << "Generating "<< N << " point cloud...";
114 | 	point.pts.resize(N);
115 | 	for (size_t i=0;i<N;i++)
116 | 	{
117 | 		point.pts[i].x = max_range * (rand() % 1000) / T(1000);
118 | 		point.pts[i].y = max_range * (rand() % 1000) / T(1000);
119 | 		point.pts[i].z = max_range * (rand() % 1000) / T(1000);
120 | 	}
121 | 
122 | 	std::cout << "done\n";
123 | }
124 | 
125 | 
126 | 
127 | 
128 | 
129 | template <typename num_t>
130 | void kdtree_demo(const size_t N)
131 | {
132 | 	//PointCloud<num_t> cloud;
133 | 	#ifdef REAL_DATASET_FILE
134 | 		PointCloud<float> cloud(REAL_DATASET_FILE);
135 | 	#endif
136 | 	// Generate points:
137 | 	//generateRandomPointCloud(cloud, N);
138 | 
139 | 	// construct a kd-tree index:
140 | 	#ifndef REAL_DATASET_FILE
141 | 
142 | 		cout << "No existe dataset"<<endl;
143 | 
144 | 	#else
145 | 		//num_t query_pt[3] = { 0, 0, 0}; //elemento a buscar
146 | 		num_t query_pt[10] = { 0, 0, 0,0,0,0,0,0,0,0}; //elemento a buscar
147 | 
148 | 	#endif
149 | 
150 | 
151 | 
152 | 	typedef KDTreeSingleIndexAdaptor<
153 | 		L2_Simple_Adaptor<num_t, PointCloud<num_t> > ,
154 | 		PointCloud<num_t>,
155 | 		10 /* dim */
156 | 		> my_kd_tree_t;
157 | 
158 | 	my_kd_tree_t   index(10 /*dim*/, cloud, KDTreeSingleIndexAdaptorParams(N) );
159 | 	index.buildIndex();
160 | 
161 | 	// ----------------------------------------------------------------
162 | 	// knnSearch():  Perform a search for the N closest points
163 | 	// ----------------------------------------------------------------
164 | 	{
165 | 		size_t num_results = 5;
166 | 		std::vector<size_t>   ret_index(num_results);
167 | 		std::vector<num_t> out_dist_sqr(num_results);
168 | 
169 | 		num_results = index.knnSearch(&query_pt[0], num_results, &ret_index[0], &out_dist_sqr[0]);
170 | 		
171 | 		// In case of less points in the tree than requested:
172 | 		ret_index.resize(num_results);
173 | 		out_dist_sqr.resize(num_results);
174 | 
175 | 		cout << "knnSearch(): num_results=" << num_results << "\n";
176 | 		for (size_t i=0;i<num_results;i++)
177 | 			cout << "idx["<< i << "]=" << ret_index[i] << " dist["<< i << "]=" << out_dist_sqr[i] << endl;
178 | 		cout << "\n";
179 | 	}
180 | 
181 | 	// ----------------------------------------------------------------
182 | 	// radiusSearch():  Perform a search for the N closest points
183 | 	// ----------------------------------------------------------------
184 | 	{
185 | 		const num_t search_radius = static_cast<num_t>(10000000000);
186 | 		std::vector<std::pair<size_t,num_t> >   ret_matches;
187 | 
188 | 		nanoflann::SearchParams params;
189 | 		//params.sorted = false;
190 | 
191 | 		const size_t nMatches = index.radiusSearch(&query_pt[0],search_radius, ret_matches, params);
192 | 
193 | 		cout << "radiusSearch(): radius=" << search_radius << " -> " << nMatches << " matches\n";
194 | 		for (size_t i=0;i<nMatches;i++)
195 | 			cout << "idx["<< i << "]=" << ret_matches[i].first << " dist["<< i << "]=" << ret_matches[i].second << endl;
196 | 		cout << "\n";
197 | 	}
198 | 
199 | }
200 | 
201 |  int main()
202 | {
203 | 	// Randomize Seed
204 | 	srand(time(NULL));
205 | 	//kdtree_demo<float>(4);
206 | 	kdtree_demo<float>(10);
207 | 	return 0;
208 | }
209 | 
210 | 


--------------------------------------------------------------------------------
/datos.txt:
--------------------------------------------------------------------------------
  1 | 0	0	0	0	0	0	1	0	0	0
  2 | 0	2	0	0	0	0	0	0	0	0
  3 | 2.544	1.972	1	1.335	24.76	77.88	10.00	40.20	29.72	73.56
  4 | 2.807	3.347	1	1.610	8.88	30.80	10.60	47.00	21.40	64.80
  5 | 4.308	1.933	1	2.150	22.70	56.40	11.92	43.52	29.72	90.00
  6 | 4.383	1.081	1	1.565	34.32	66.40	16.32	38.52	26.20	88.40
  7 | 3.244	4.519	1	1.145	31.28	72.40	3.50	40.40	22.04	75.20
  8 | 3.925	3.785	1	0.894	27.44	60.00	15.08	30.52	21.76	72.40
  9 | 2.116	3.498	1	0.525	66.12	141.00	4.20	25.40	9.92	72.08
 10 | 1.842	0.989	1	0.240	22.32	52.40	4.52	27.96	11.32	56.40
 11 | 1.709	1.843	1	0.625	18.72	41.60	12.08	33.32	16.88	75.60
 12 | 3.800	4.578	1	3.873	22.24	46.00	9.84	46.00	21.64	143.20
 13 | 2.699	1.199	1	1.425	8.76	56.40	7.56	40.80	15.72	66.80
 14 | 3.033	4.384	1	0.455	21.36	38.36	2.36	19.24	7.08	37.88
 15 | 4.232	1.588	1	1.025	5.88	52.80	8.84	28.32	17.40	47.60
 16 | 4.750	1.369	1	0.775	17.60	32.92	11.96	35.60	23.76	70.80
 17 | 2.341	4.135	1	0.620	18.52	42.00	5.32	31.00	10.80	46.80
 18 | 2.827	3.667	1	0.400	3.96	21.48	4.68	20.52	6.68	25.20
 19 | 3.043	4.692	1	0.625	8.24	29.92	3.53	25.20	11.32	31.32
 20 | 1.687	1.174	1	0.355	21.56	46.80	3.64	18.40	6.64	39.56
 21 | 2.235	2.386	1	1.585	40.88	88.68	12.44	40.56	25.08	114.28
 22 | 3.122	1.695	1	1.885	35.92	72.88	12.92	44.00	34.72	120.28
 23 | 2.219	2.774	1	1.300	8.80	56.52	13.04	32.48	31.52	71.76
 24 | 3.185	2.092	1	1.575	22.12	43.68	11.20	35.72	35.00	90.68
 25 | 3.514	5.119	1	4.191	15.48	33.36	9.28	52.00	21.76	145.60
 26 | 4.459	2.624	1	1.485	11.16	34.64	6.84	19.00	15.84	82.80
 27 | 4.339	1.473	1	0.915	39.80	64.80	10.80	32.72	18.60	86.00
 28 | 4.920	1.417	1	0.705	15.76	39.52	8.56	30.28	21.96	66.40
 29 | 3.648	3.780	1	0.620	48.80	63.20	14.16	28.56	24.44	78.00
 30 | 2.916	4.916	1	0.885	4.52	37.16	6.28	27.92	13.88	46.80
 31 | 3.127	1.691	1	1.960	47.12	93.92	13.40	45.20	35.12	123.84
 32 | 3.441	4.719	1	3.155	48.80	55.60	9.28	62.40	24.28	151.60
 33 | 3.336	4.613	1	1.280	24.96	49.20	5.92	38.52	23.28	81.60
 34 | 3.649	2.674	1	1.785	9.65	58.40	7.44	23.72	17.72	58.00
 35 | 3.875	4.924	1	1.895	25.28	35.60	11.48	52.00	26.72	141.60
 36 | 2.612	4.114	1	0.570	33.80	58.40	4.88	27.32	7.44	47.60
 37 | 2.340	4.141	1	0.540	17.40	36.88	5.48	35.72	10.60	53.20
 38 | 3.811	1.318	1	0.750	16.40	39.80	12.60	36.20	26.60	80.80
 39 | 3.661	3.788	1	0.875	65.20	69.60	14.64	28.88	20.80	76.40
 40 | 4.340	3.736	1	2.818	29.12	46.00	11.24	35.04	21.96	80.80
 41 | 2.972	0.988	1	3.805	112.04	229.56	9.16	67.04	28.88	219.32
 42 | 2.286	3.068	1	0.605	28.80	56.60	9.68	27.32	12.80	67.16
 43 | 1.813	2.116	1	1.003	21.20	48.80	11.32	33.48	20.56	110.00
 44 | 3.379	4.308	1	1.900	10.28	36.44	8.52	46.40	24.80	83.60
 45 | 1.965	2.807	1	0.895	60.72	89.68	12.60	41.60	24.16	102.44
 46 | 3.559	4.009	1	4.020	21.08	52.00	6.16	60.80	21.96	101.60
 47 | 2.267	4.189	1	0.560	12.72	39.64	6.64	35.12	11.12	57.20
 48 | 2.965	1.002	1	1.390	57.20	129.20	10.36	45.60	24.60	149.20
 49 | 3.120	1.469	1	1.910	11.60	69.16	2.12	31.12	8.00	50.40
 50 | 3.454	4.654	1	1.070	10.88	29.88	7.80	38.24	19.92	70.80
 51 | 1.071	1.567	1	0.795	9.92	37.48	9.96	29.08	15.28	65.60
 52 | 3.573	3.542	1	0.550	50.40	77.20	9.56	26.60	16.00	76.00
 53 | 3.331	4.609	1	1.255	49.60	80.40	7.00	42.80	25.44	101.60
 54 | 3.541	1.739	1	2.055	10.80	43.60	6.32	29.80	20.80	59.36
 55 | 3.303	3.963	1	1.220	51.60	80.80	11.00	34.04	20.32	90.00
 56 | 3.316	2.987	1	0.975	30.10	48.80	14.60	33.00	23.60	83.20
 57 | 1.879	1.171	1	0.465	23.32	54.80	4.00	24.64	9.16	44.40
 58 | 1.122	2.267	1	1.145	14.80	47.60	11.08	37.08	31.56	74.40
 59 | 4.423	1.078	1	1.525	22.00	46.80	16.92	38.60	26.80	87.60
 60 | 1.241	1.155	1	1.455	7.28	36.52	4.52	20.20	12.68	39.60
 61 | 1.706	1.848	1	1.120	20.72	41.20	11.92	34.84	19.96	83.20
 62 | 3.260	5.420	1	1.819	17.60	35.80	11.72	38.04	28.60	82.40
 63 | 4.081	0.897	1	0.495	14.32	32.76	11.20	22.40	10.92	50.40
 64 | 3.077	2.926	1	2.120	12.32	42.40	10.12	35.32	21.52	64.80
 65 | 3.406	4.741	1	2.150	28.96	42.80	7.32	48.00	19.72	120.80
 66 | 3.699	3.800	1	0.650	35.56	80.80	11.60	27.44	19.28	74.00
 67 | 1.619	2.883	1	0.840	22.84	50.40	6.80	30.56	16.08	58.80
 68 | 3.196	1.814	1	3.925	47.40	84.16	12.92	25.60	26.12	92.36
 69 | 3.447	4.733	1	1.980	27.12	39.92	8.40	40.80	17.68	108.00
 70 | 3.009	4.738	1	0.450	12.44	34.00	3.53	25.64	10.00	39.40
 71 | 3.452	4.736	1	2.960	38.96	70.40	7.20	45.20	15.00	148.40
 72 | 2.908	1.263	1	1.685	9.40	34.56	9.84	31.28	14.72	84.32
 73 | 4.578	1.512	1	1.305	17.50	38.96	13.52	45.52	27.20	77.60
 74 | 3.512	5.124	1	4.227	16.88	34.64	9.64	48.40	22.92	136.80
 75 | 3.312	2.991	1	0.980	22.70	41.60	12.52	32.60	19.40	72.80
 76 | 2.159	2.041	1	1.570	17.44	49.60	10.44	37.72	28.32	81.60
 77 | 4.742	1.381	1	0.860	15.12	32.84	11.88	32.72	23.48	63.60
 78 | 3.592	4.027	1	2.170	12.52	37.68	10.84	55.20	29.48	74.40
 79 | 3.152	3.272	1	1.560	34.00	76.40	12.80	42.60	23.52	94.00
 80 | 4.781	1.375	1	0.810	12.08	36.28	10.88	27.44	20.84	58.80
 81 | 2.319	2.405	1	1.710	56.24	104.68	12.84	43.40	26.96	125.40
 82 | 3.617	2.084	1	0.845	27.92	78.80	12.80	33.72	26.20	79.60
 83 | 2.278	0.929	1	0.357	13.24	35.40	4.08	19.36	6.56	46.80
 84 | 3.792	2.695	1	1.535	5.88	55.20	6.76	20.32	13.40	52.40
 85 | 4.113	2.700	1	1.285	13.64	84.40	1.55	8.72	7.16	65.20
 86 | 3.043	4.698	1	1.820	7.60	27.04	3.92	27.36	10.44	39.80
 87 | 3.271	2.160	1	0.945	37.40	59.04	13.32	37.80	32.60	104.36
 88 | 1.433	1.525	1	1.605	13.48	49.60	7.36	67.60	16.20	75.20
 89 | 3.184	2.098	1	2.230	24.60	44.88	11.92	37.80	37.72	96.60
 90 | 3.675	4.293	1	0.890	4.40	26.76	8.60	37.68	22.96	66.00
 91 | 3.681	5.690	1	1.898	15.16	59.20	12.64	54.00	28.36	86.00
 92 | 2.461	3.423	1	0.370	15.72	29.36	3.14	22.60	6.08	47.20
 93 | 4.576	1.411	1	1.380	15.64	34.44	11.28	37.60	25.76	71.60
 94 | 2.223	0.580	1	0.285	14.16	44.00	9.60	38.00	24.52	76.00
 95 | 3.031	1.201	1	0.610	16.40	52.56	6.44	21.84	10.36	51.24
 96 | 3.347	2.505	1	0.625	5.36	41.20	6.96	33.20	19.20	43.60
 97 | 2.465	4.003	1	0.325	9.72	24.64	3.19	21.40	4.72	35.08
 98 | 3.175	2.102	1	1.985	18.92	42.68	12.20	38.40	37.20	89.84
 99 | 3.733	0.974	1	0.950	15.40	36.60	8.92	40.80	26.52	74.00
100 | 3.085	1.677	1	2.040	26.20	63.92	11.80	40.40	29.80	107.20
101 | 2.595	3.638	1	0.325	17.52	44.40	3.71	14.52	4.76	40.80
102 | 4.279	3.283	1	0.830	19.20	36.36	13.36	33.60	24.64	84.40
103 | 2.933	0.978	1	0.800	166.40	146.80	12.40	31.44	16.00	100.40
104 | 3.590	4.033	1	2.080	11.52	37.56	7.92	56.40	24.84	79.60
105 | 2.883	1.237	1	2.550	12.12	36.56	8.52	31.24	16.12	96.96
106 | 2.429	1.620	1	2.235	31.96	77.60	11.84	52.40	26.64	126.80
107 | 2.333	2.417	1	1.435	53.20	107.60	9.12	37.44	21.32	110.32
108 | 0.626	1.652	1	0.375	4.20	37.12	7.28	33.32	14.40	46.40
109 | 2.969	0.778	1	1.930	77.32	157.28	12.44	43.04	33.76	166.28
110 | 0.971	1.576	1	1.215	9.80	35.64	10.08	29.28	15.20	64.00
111 | 1.392	1.846	1	1.050	7.44	37.68	10.60	39.24	20.00	48.40
112 | 2.540	3.320	1	1.260	17.20	53.60	9.76	45.32	17.60	62.80
113 | 1.738	1.771	1	0.685	19.64	41.60	11.92	33.64	16.24	76.00
114 | 2.243	3.031	1	0.705	19.20	34.00	11.80	29.92	14.60	59.88
115 | 3.656	2.630	1	1.385	9.23	80.40	2.07	9.72	5.36	49.20
116 | 2.325	4.143	1	0.505	14.00	33.24	5.48	34.00	10.92	54.40
117 | 4.550	1.416	1	1.740	18.10	41.60	12.40	44.32	27.72	73.60
118 | 4.325	1.436	1	0.560	19.40	36.76	11.60	26.92	13.72	57.20
119 | 3.669	4.291	1	1.917	8.40	35.12	8.44	33.48	18.72	59.60
120 | 1.877	1.186	1	0.320	26.16	45.20	3.80	18.20	6.44	39.88
121 | 3.044	1.123	1	0.630	18.04	38.24	12.00	31.28	18.68	80.76
122 | 3.001	2.581	1	4.180	8.20	42.04	9.60	45.32	22.20	81.72
123 | 3.136	2.091	1	1.110	17.92	38.72	14.20	34.80	30.32	79.00
124 | 2.633	3.650	1	0.425	16.20	50.40	3.09	22.12	5.04	61.60
125 | 3.721	4.239	1	0.280	18.00	41.20	8.00	25.96	12.28	46.40
126 | 2.333	2.367	1	1.390	59.16	101.92	12.36	42.12	28.20	135.88
127 | 4.038	2.354	1	2.805	10.50	44.00	12.20	39.20	32.92	65.60
128 | 3.117	1.702	1	1.710	30.00	58.60	14.12	42.80	35.00	106.36
129 | 1.824	0.999	1	0.165	23.64	56.40	3.75	18.60	7.08	44.00
130 | 2.850	1.890	1	1.360	8.68	53.60	2.81	10.76	7.08	28.88
131 | 2.502	3.988	1	0.240	20.72	22.36	3.76	18.92	5.20	32.24
132 | 1.443	1.509	1	1.445	15.40	50.80	7.76	61.20	20.68	75.60
133 | 2.008	1.350	1	0.515	16.04	35.04	5.00	32.56	8.96	50.40
134 | 2.978	4.009	1	0.560	8.35	25.40	6.52	24.40	12.40	49.20
135 | 1.662	1.425	1	0.905	44.40	82.00	11.24	37.40	16.56	78.40
136 | 1.587	1.080	1	0.605	26.24	54.00	5.16	29.28	11.44	54.00
137 | 3.994	3.814	1	2.423	32.52	80.40	14.48	45.60	28.32	84.00
138 | 4.383	2.279	1	0.785	6.72	43.60	7.48	35.92	22.72	60.80
139 | 2.901	4.919	1	0.810	5.48	28.80	4.64	28.60	14.92	42.00
140 | 4.156	1.242	1	1.100	5.72	32.48	7.84	32.20	17.92	44.00
141 | 4.475	3.526	1	0.951	38.96	78.80	15.28	29.36	20.36	70.80
142 | 2.580	3.654	1	0.275	7.48	20.20	3.55	16.20	4.64	33.44
143 | 0.701	1.997	1	1.580	9.84	64.80	12.60	60.80	32.20	86.00
144 | 3.649	3.887	1	1.060	26.44	51.20	11.48	41.60	29.24	80.80
145 | 2.623	0.853	1	2.580	29.24	59.20	11.64	45.20	27.36	106.40
146 | 1.315	1.975	1	3.680	14.44	56.40	11.12	52.00	28.72	89.60
147 | 3.656	2.670	1	1.875	9.52	70.00	11.12	36.12	25.40	65.20
148 | 4.426	0.821	1	0.805	8.76	27.20	13.00	48.32	26.00	61.60
149 | 2.882	3.693	1	0.535	8.76	27.04	4.60	20.80	5.40	32.92
150 | 1.108	1.535	1	2.055	60.00	195.60	8.08	50.40	23.16	108.00
151 | 4.480	1.089	1	0.555	10.80	36.52	10.28	27.64	19.60	64.80
152 | 1.468	2.192	1	1.510	10.88	44.40	10.92	57.60	30.68	80.40
153 | 2.319	4.103	1	0.580	20.52	34.88	5.48	36.00	10.92	50.40
154 | 3.585	4.040	1	1.970	24.64	66.00	8.00	51.20	25.76	99.20
155 | 3.647	3.786	1	0.765	42.00	70.80	13.84	29.72	20.96	90.80
156 | 2.310	2.732	1	0.735	17.68	39.20	12.72	39.00	23.24	79.04
157 | 3.962	2.009	1	1.445	42.92	78.40	12.40	43.52	34.40	104.40
158 | 3.470	5.555	1	2.234	12.52	48.40	13.48	45.20	29.68	64.00
159 | 1.839	0.995	1	0.225	27.72	55.60	4.24	24.88	10.12	56.00
160 | 1.706	1.165	1	0.740	25.52	60.80	4.36	20.40	8.68	62.40
161 | 2.774	1.544	1	1.915	19.32	45.72	8.44	42.32	20.64	90.24
162 | 3.493	5.092	1	3.421	14.80	34.32	9.80	52.40	20.44	134.40
163 | 1.695	3.227	1	1.835	10.88	56.68	5.88	35.08	21.44	97.48
164 | 4.409	1.084	1	1.770	18.92	48.80	17.32	37.72	27.00	89.20
165 | 2.596	3.212	1	3.995	15.92	45.16	8.64	49.72	22.00	118.24
166 | 1.897	1.220	1	0.260	9.24	27.00	3.48	16.24	4.76	27.20
167 | 2.083	1.695	1	0.440	11.28	56.40	6.00	29.28	16.68	54.80
168 | 3.673	4.278	1	1.015	7.36	34.00	9.28	44.00	19.28	70.40
169 | 2.731	3.002	1	0.485	6.60	32.44	9.00	27.32	20.92	57.96
170 | 4.264	3.391	1	2.828	79.20	135.20	11.16	32.64	24.96	132.80
171 | 3.792	2.707	1	1.380	6.44	45.60	8.16	26.92	17.12	55.20
172 | 3.390	1.048	1	1.660	24.60	57.28	10.12	42.92	29.32	123.32
173 | 3.184	5.075	1	0.685	11.36	23.68	7.08	33.76	16.32	53.60
174 | 3.644	2.677	1	0.930	6.77	51.20	9.56	37.40	23.12	56.40
175 | 3.504	5.130	1	5.129	14.76	36.80	8.60	39.24	18.28	135.60
176 | 2.242	3.036	1	0.725	17.00	34.08	10.32	26.32	12.72	56.72
177 | 3.332	4.628	1	0.740	96.00	59.20	4.52	35.92	17.20	83.20
178 | 3.498	3.196	1	0.990	14.50	36.24	15.12	32.80	22.92	65.60
179 | 1.883	1.176	1	0.195	25.12	49.60	3.92	21.80	7.52	43.20
180 | 3.322	3.001	1	1.340	25.30	44.40	14.32	35.00	23.12	81.20
181 | 1.047	1.922	1	1.240	18.32	52.00	14.20	43.60	22.52	83.20
182 | 3.843	3.121	1	1.840	33.32	44.40	10.80	39.52	35.28	86.00
183 | 1.301	0.599	1	0.910	21.20	64.80	13.24	32.84	18.00	75.20
184 | 1.106	1.548	1	1.270	19.12	65.20	9.16	52.80	19.44	65.20
185 | 1.114	1.535	1	1.480	106.80	226.40	9.12	58.80	26.16	140.40
186 | 1.511	0.734	1	1.245	22.64	64.40	7.84	47.20	21.96	71.20
187 | 1.317	1.501	1	1.385	120.80	66.40	6.44	42.80	19.64	94.80
188 | 1.439	1.523	1	1.720	16.40	52.40	7.24	54.80	16.52	75.60
189 | 1.651	1.157	1	0.525	26.28	46.40	3.88	20.84	8.36	49.60
190 | 1.701	1.169	1	0.690	17.04	52.40	4.24	23.48	9.04	45.60
191 | 1.857	0.659	1	3.530	66.00	118.00	10.08	52.80	24.44	124.80
192 | 1.346	1.954	1	0.930	9.00	38.12	10.56	39.04	20.24	69.20
193 | 1.354	1.966	1	1.165	8.64	38.32	10.72	43.60	24.00	59.60
194 | 1.350	1.970	1	3.810	17.92	64.80	10.12	60.80	27.08	102.00
195 | 1.932	1.004	1	0.135	10.44	37.00	4.52	15.08	5.24	32.56
196 | 1.837	1.037	1	0.215	23.44	46.80	3.88	23.00	8.16	44.00
197 | 1.690	1.858	1	1.775	29.76	54.80	12.96	38.72	22.36	91.60
198 | 1.720	1.833	1	0.585	24.36	50.00	11.60	31.68	15.96	76.80
199 | 1.543	2.537	1	1.563	26.72	52.40	10.40	45.20	28.72	104.00
200 | 2.353	1.274	1	0.275	8.24	32.56	4.32	15.40	4.20	37.88
201 | 1.889	2.462	1	2.505	12.16	65.20	10.20	48.40	31.04	78.40
202 | 2.327	2.417	1	1.385	58.72	116.48	9.68	39.72	22.60	123.00
203 | 2.504	1.965	1	1.790	19.92	62.36	10.44	41.84	25.64	80.32
204 | 2.599	1.996	1	2.115	61.32	172.12	13.16	43.08	53.20	133.88
205 | 2.561	1.984	1	1.630	18.08	63.16	13.56	51.36	42.92	77.40
206 | 2.898	1.274	1	2.700	15.56	38.28	6.52	32.76	15.00	99.60
207 | 2.902	1.263	1	4.495	10.24	32.92	10.32	39.16	22.64	101.68
208 | 3.085	1.214	1	0.765	37.60	68.40	7.68	18.52	11.28	86.20
209 | 3.046	1.205	1	0.400	9.60	32.76	11.16	21.64	13.36	44.00
210 | 3.025	1.201	1	0.320	12.92	40.20	5.60	18.52	7.20	43.72
211 | 2.040	3.153	1	0.655	17.20	41.88	5.00	16.56	8.24	51.24
212 | 2.234	2.737	1	1.110	10.28	47.80	14.60	39.28	24.44	71.12
213 | 2.220	2.732	1	0.770	16.00	44.40	12.28	43.48	23.88	62.28
214 | 2.224	2.728	1	1.205	11.36	41.04	13.80	46.84	27.44	85.52
215 | 2.580	2.311	1	1.555	15.40	51.24	8.84	40.16	23.92	77.56
216 | 2.254	3.045	1	0.575	31.80	54.28	9.68	27.12	13.20	66.92
217 | 2.656	2.656	1	0.525	79.20	138.56	12.52	26.12	18.00	91.48
218 | 3.465	1.393	1	0.705	48.72	86.68	12.52	28.72	17.60	96.60
219 | 2.553	3.314	1	0.990	9.28	38.00	8.80	38.72	15.72	60.12
220 | 2.538	3.314	1	1.655	31.52	90.36	8.96	50.60	17.32	81.60
221 | 2.402	3.979	1	0.515	13.12	26.96	4.08	30.12	8.20	43.20
222 | 2.456	3.990	1	0.350	11.60	27.68	3.27	26.32	4.92	37.16
223 | 2.537	3.768	1	0.230	8.72	26.84	3.79	18.20	5.68	32.08
224 | 2.584	3.649	1	0.305	17.12	48.40	3.72	18.00	5.60	44.80
225 | 3.887	1.663	1	1.535	29.60	56.80	15.20	40.72	32.40	85.60
226 | 4.412	1.088	1	1.530	17.72	47.60	17.72	39.52	26.40	80.80
227 | 2.795	3.645	1	0.300	13.40	37.76	4.24	17.32	6.32	27.12
228 | 2.837	3.679	1	0.425	4.68	22.56	5.08	22.72	8.00	31.48
229 | 2.832	3.676	1	0.360	4.44	18.96	6.68	26.12	11.80	28.92
230 | 3.308	2.963	1	1.060	28.00	50.00	17.32	36.00	23.92	78.40
231 | 3.422	2.851	1	0.900	49.00	70.40	9.52	38.72	26.20	94.80
232 | 3.692	2.430	1	1.610	9.44	42.80	5.00	19.40	8.76	31.16
233 | 4.331	1.449	1	0.950	19.60	37.88	12.00	29.20	18.72	61.20
234 | 4.333	1.455	1	0.820	32.10	63.20	10.32	29.80	16.72	67.60
235 | 4.502	1.167	1	0.860	12.70	37.08	12.12	28.40	20.12	61.60
236 | 3.228	3.617	1	1.835	45.92	80.40	13.32	47.40	24.00	90.00
237 | 3.768	2.775	1	0.220	6.67	31.88	10.80	26.32	17.52	45.20
238 | 3.768	2.675	1	1.095	6.20	46.80	12.12	41.32	28.80	56.80
239 | 3.798	2.694	1	0.995	5.38	51.20	9.68	32.80	19.12	54.00
240 | 4.590	1.414	1	0.960	16.40	30.76	11.72	35.20	21.92	64.80
241 | 4.571	1.407	1	1.400	15.24	38.40	10.72	38.64	26.40	70.80
242 | 4.745	1.372	1	0.690	16.44	34.12	11.96	35.64	23.68	66.40
243 | 4.788	1.647	1	0.720	11.40	32.68	8.80	34.08	26.72	63.20
244 | 2.974	4.937	1	2.260	12.64	36.28	5.88	36.44	21.52	77.60
245 | 2.906	4.922	1	1.130	5.92	21.60	4.32	20.32	13.20	32.84
246 | 3.109	4.729	1	0.645	8.40	28.56	3.12	22.68	8.88	42.40
247 | 3.040	4.713	1	0.630	7.24	26.00	3.66	23.96	9.36	36.64
248 | 3.919	3.466	1	0.860	12.80	28.60	9.76	28.40	17.48	58.80
249 | 4.189	3.045	1	1.645	35.60	67.60	8.08	46.40	20.32	90.40
250 | 3.652	4.312	1	3.149	8.24	56.00	10.72	51.20	27.72	98.00
251 | 3.894	3.805	1	0.552	50.00	91.20	14.32	29.00	20.12	79.20
252 | 3.917	3.773	1	1.568	18.40	43.60	13.56	30.36	22.28	71.60
253 | 3.925	3.779	1	0.855	11.40	29.68	14.24	29.20	21.00	59.60
254 | 4.252	3.292	1	0.733	39.20	65.60	11.80	26.00	22.24	74.00
255 | 4.292	3.290	1	2.080	71.60	52.80	11.92	31.68	28.64	110.80
256 | 4.283	3.278	1	0.844	21.04	34.68	13.88	37.12	26.48	90.00
257 | 3.530	4.999	1	0.490	4.64	31.64	7.44	34.52	16.76	56.80
258 | 4.070	4.157	1	1.916	45.60	50.00	14.36	47.60	28.44	90.80
259 | 4.610	3.315	1	1.384	7.48	48.00	12.68	30.76	20.72	46.80
260 | 3.605	5.345	1	0.849	18.40	35.00	9.04	29.48	17.56	58.00
261 | 2.672	3.558	1	1.570	18.60	38.20	8.28	37.12	18.60	65.20
262 | 3.589	4.443	1	2.045	11.48	33.36	10.80	40.80	21.52	112.80
263 | 4.010	4.713	1	1.203	13.04	26.56	12.00	53.20	23.92	91.60
264 | 2.942	3.137	1	0.490	5.64	25.88	10.92	23.40	14.60	41.20
265 | 1.409	2.748	1	0.692	10.32	31.16	8.12	27.16	14.64	50.40
266 | 3.978	2.910	1	1.750	8.36	37.72	9.12	35.48	26.40	63.20
267 | 2.715	2.100	1	0.415	4.44	41.00	9.12	30.32	24.24	53.16
268 | 3.870	0.762	1	0.685	10.92	30.84	11.72	31.92	13.12	49.28
269 | 2.445	2.521	1	0.920	30.28	68.12	10.56	49.04	31.52	102.72
270 | 3.827	2.219	1	2.120	7.35	54.40	6.36	23.00	14.52	72.40
271 | 2.488	1.064	1	0.495	17.08	46.80	8.52	31.40	16.12	57.60
272 | 1.646	0.524	1	1.060	18.88	55.20	14.44	37.28	25.24	76.40
273 | 3.136	2.370	1	0.790	3.98	35.28	5.20	33.12	14.92	32.60
274 | 3.740	5.134	1	0.772	8.16	30.16	10.84	39.04	24.24	56.80
275 | 1.678	2.327	1	1.188	31.36	72.40	9.68	37.44	22.36	108.40
276 | 4.399	3.180	1	1.615	91.20	108.80	11.96	34.56	30.20	156.80
277 | 3.935	4.368	1	3.023	19.72	45.60	12.76	40.80	25.36	105.20
278 | 3.330	1.604	1	2.315	113.12	144.36	9.92	56.20	25.40	147.40
279 | 3.557	2.640	1	2.650	12.30	54.40	8.84	25.72	18.92	58.40
280 | 1.376	0.945	1	3.780	32.76	94.40	9.68	42.80	23.52	175.20
281 | 2.024	2.251	1	1.805	55.60	142.00	12.60	38.00	23.12	124.80
282 | 3.310	4.594	1	1.580	56.40	93.60	5.80	40.40	22.52	108.80
283 | 4.097	1.798	1	1.930	19.30	46.40	13.80	45.00	35.72	90.00
284 | 2.326	3.633	1	0.415	18.32	31.92	2.36	20.12	6.28	40.72
285 | 3.514	4.098	1	0.675	9.24	27.24	6.56	26.00	11.64	50.00
286 | 3.168	4.173	1	0.745	8.52	30.28	3.94	26.56	15.40	52.40
287 | 4.292	1.039	1	1.420	18.80	36.48	11.12	27.52	20.60	63.20
288 | 2.834	0.988	1	1.425	13.32	53.60	15.24	49.20	25.56	108.80
289 | 4.443	1.723	1	1.310	17.70	48.40	12.72	34.80	19.60	80.40
290 | 3.482	2.295	1	1.765	127.00	300.00	10.32	40.52	30.80	192.00
291 | 3.665	4.789	1	0.647	9.76	21.76	8.72	31.12	13.88	60.80
292 | 4.173	2.144	1	1.810	17.90	48.80	13.20	44.12	29.60	92.80
293 | 2.143	1.139	1	0.394	39.56	105.60	4.44	21.64	8.92	72.40
294 | 3.061	2.025	1	1.600	20.60	35.72	10.92	37.72	25.32	92.64
295 | 2.985	1.679	1	1.675	22.92	61.44	14.40	46.28	43.68	111.08
296 | 3.438	3.752	1	1.280	13.04	43.60	6.36	31.00	18.60	65.20
297 | 4.637	0.956	1	0.870	16.50	35.32	12.80	33.52	22.52	78.40
298 | 3.049	5.285	1	0.800	7.68	48.40	12.40	49.20	27.16	60.40
299 | 1.106	1.366	1	0.475	22.68	55.20	3.96	22.16	7.92	46.80
300 | 3.633	2.986	1	0.855	25.50	51.60	12.40	32.92	22.32	80.40
301 | 3.708	3.331	1	1.340	10.32	41.20	9.32	28.48	23.28	58.00
302 | 2.909	1.334	1	1.805	28.92	74.36	6.12	24.80	11.24	111.32
303 | 2.102	2.597	1	0.825	31.20	70.40	15.32	36.52	25.36	75.44
304 | 1.797	1.215	1	0.545	33.08	58.00	4.24	21.80	8.88	47.20
305 | 3.255	1.253	1	1.780	154.60	239.96	11.40	41.00	24.52	259.84
306 | 4.129	3.601	1	2.566	7.88	55.20	10.60	32.84	23.60	59.20
307 | 3.363	3.407	1	0.610	7.86	34.84	14.80	28.52	19.32	53.20
308 | 1.452	1.290	1	0.585	15.16	56.40	5.80	39.88	13.20	51.20
309 | 4.745	3.105	1	1.436	14.20	32.68	5.24	19.44	9.52	44.80
310 | 0.491	1.862	1	2.415	21.32	48.40	7.88	32.72	18.16	49.20
311 | 2.369	2.176	1	0.750	73.12	139.16	15.60	29.76	20.20	95.68
312 | 3.676	1.528	1	0.805	38.72	88.32	11.12	32.00	19.52	88.16
313 | 1.257	2.057	1	0.650	12.80	41.60	11.44	37.08	19.64	52.00
314 | 3.903	2.565	1	0.510	5.96	62.40	1.65	3.32	1.98	60.40
315 | 1.603	1.981	1	0.705	16.04	38.24	13.04	29.84	17.92	70.40
316 | 3.395	5.210	1	1.112	13.12	25.56	9.80	36.56	19.48	65.60
317 | 2.564	1.409	1	1.310	117.60	152.80	8.44	41.60	20.40	145.20
318 | 0.912	2.132	1	2.200	11.88	51.60	10.48	60.40	30.80	78.40
319 | 3.093	3.828	1	0.450	11.50	30.92	7.96	23.20	9.36	43.20
320 | 0.836	1.787	1	0.825	12.96	50.00	14.32	40.80	22.84	80.40
321 | 2.758	0.643	1	1.245	13.08	88.00	8.08	39.56	18.64	86.80
322 | 3.017	3.482	1	1.090	8.80	26.32	12.80	38.72	18.80	59.20
323 | 3.212	2.716	1	0.780	29.80	60.40	12.52	35.52	24.00	75.60
324 | 4.022	1.453	1	1.950	22.60	52.00	10.60	47.00	36.72	100.00
325 | 4.054	3.256	1	1.310	21.16	52.80	8.92	35.04	20.08	78.80
326 | 2.521	2.867	1	1.585	11.40	39.36	13.20	42.00	33.12	75.64
327 | 3.319	4.864	1	0.520	6.04	21.12	5.08	32.68	15.40	37.52
328 | 2.823	4.249	1	1.005	7.08	35.40	5.36	18.12	8.20	51.60
329 | 1.722	0.869	1	0.570	21.36	67.20	4.08	24.88	9.68	56.80
330 | 2.251	3.288	1	0.330	5.72	18.68	1.92	14.92	4.68	26.80
331 | 1.182	1.711	1	2.535	8.72	55.60	12.56	70.00	26.24	71.60
332 | 1.830	3.018	1	2.685	32.68	69.32	10.12	43.52	27.88	111.76
333 | 3.752	1.874	1	0.690	20.80	55.60	13.60	37.60	28.40	80.40
334 | 2.218	1.485	1	0.375	19.36	45.20	12.04	34.08	16.36	70.00
335 | 1.873	1.560	1	1.955	26.08	60.40	9.68	37.88	20.88	110.80
336 | 3.600	1.183	1	1.185	22.72	49.72	10.00	34.20	27.40	89.88
337 | 2.887	4.889	1	1.325	5.40	37.52	3.74	27.64	14.44	46.40
338 | 1.527	1.636	1	0.795	42.00	84.80	7.92	27.40	13.20	78.80
339 | 1.333	2.407	1	1.630	20.56	46.00	13.40	43.60	37.52	98.40
340 | 2.413	0.718	1	0.677	11.92	38.16	12.48	34.52	23.92	69.20
341 | 1.948	1.906	1	1.298	22.24	45.60	12.00	49.60	26.04	96.40
342 | 1.754	2.672	1	1.530	16.24	43.60	10.36	46.40	29.80	77.20
343 | 2.294	1.830	1	0.670	8.72	32.76	9.72	46.80	23.24	81.60
344 | 2.639	1.755	1	1.010	5.96	67.36	9.96	28.68	17.44	52.48
345 | 1.905	3.363	1	0.500	16.68	39.76	4.80	23.12	9.36	46.40
346 | 2.175	2.942	1	1.665	37.00	43.80	14.80	40.28	30.08	87.84
347 | 2.791	2.446	1	1.520	16.32	57.52	9.16	36.20	24.12	84.40
348 | 2.866	2.791	1	1.315	14.00	45.96	11.20	30.92	24.32	79.08
349 | 3.407	1.953	1	1.325	9.92	38.40	9.12	37.32	24.60	84.08
350 | 3.946	1.107	1	0.495	7.52	33.00	8.28	33.00	20.60	48.80
351 | 2.452	3.995	1	0.395	12.72	28.24	3.56	24.00	5.60	39.64
352 | 2.747	3.903	1	0.380	3.55	21.12	5.44	25.52	11.40	25.00
353 | 3.287	3.061	1	2.085	39.00	52.40	13.20	45.92	26.40	104.00
354 | 4.367	1.377	1	2.610	24.00	47.20	20.60	37.20	29.40	86.40
355 | 4.713	1.302	1	0.845	10.28	33.64	9.68	29.92	23.80	65.60
356 | 4.248	2.489	1	1.220	5.52	48.80	5.24	27.04	21.04	46.40
357 | 3.784	3.677	1	0.640	6.68	34.32	13.92	28.32	18.00	55.20
358 | 4.324	2.835	1	1.650	8.88	60.00	8.72	33.36	22.72	80.00
359 | 3.859	4.022	1	1.433	43.60	60.80	13.32	47.60	29.12	87.20
360 | 2.593	3.312	1	0.325	8.08	26.20	10.60	30.00	14.00	54.96
361 | 


--------------------------------------------------------------------------------
/juraset.asc:
--------------------------------------------------------------------------------
  1 | Titulo
  2 | 13
  3 | x
  4 | y
  5 | z
  6 | var 1
  7 | var 2
  8 | var 3
  9 | var 4
 10 | var 5
 11 | var 6
 12 | var 7
 13 | var 8
 14 | var 9
 15 | var 10
 16 | 2.386 3.077 0 1.74 25.72 77.36 9.32 38.32 21.32 92.56 0.45 19.9 7.21
 17 | 2.544 1.972 0 1.335 24.76 77.88 10 40.2 29.72 73.56 0.33 19.28 7.79
 18 | 2.807 3.347 0 1.61 8.88 30.8 10.6 47 21.4 64.8 0.14 2.74 3.26
 19 | 4.308 1.933 0 2.15 22.7 56.4 11.92 43.52 29.72 90 0.49 12.8 6.72
 20 | 4.383 1.081 0 1.565 34.32 66.4 16.32 38.52 26.2 88.4 0.54 22.79 10.84
 21 | 3.244 4.519 0 1.145 31.28 72.4 3.5 40.4 22.04 75.2 0.36 22.65 2.53
 22 | 3.925 3.785 0 0.894 27.44 60 15.08 30.52 21.76 72.4 0.25 16.46 9.05
 23 | 2.116 3.498 0 0.525 66.12 141 4.2 25.4 9.92 72.08 0.35 93.23 5.92
 24 | 1.842 0.989 0 0.24 22.32 52.4 4.52 27.96 11.32 56.4 0.05 11.7 2.37
 25 | 1.709 1.843 0 0.625 18.72 41.6 12.08 33.32 16.88 75.6 0.12 7.79 5.03
 26 | 3.8 4.578 0 3.873 22.24 46 9.84 46 21.64 143.2 0.86 10.23 4.53
 27 | 2.699 1.199 0 1.425 8.76 56.4 7.56 40.8 15.72 66.8 0.12 4.94 4.26
 28 | 3.033 4.384 0 0.455 21.36 38.36 2.36 19.24 7.08 37.88 0.1 8.19 0.91
 29 | 4.232 1.588 0 1.025 5.88 52.8 8.84 28.32 17.4 47.6 0.06 3.1 4.67
 30 | 4.75 1.369 0 0.775 17.6 32.92 11.96 35.6 23.76 70.8 0.14 5.79 3.94
 31 | 2.341 4.135 0 0.62 18.52 42 5.32 31 10.8 46.8 0.11 7.78 2.23
 32 | 2.827 3.667 0 0.4 3.96 21.48 4.68 20.52 6.68 25.2 0.02 0.85 1.01
 33 | 3.043 4.692 0 0.625 8.24 29.92 3.53 25.2 11.32 31.32 0.05 2.47 1.06
 34 | 1.687 1.174 0 0.355 21.56 46.8 3.64 18.4 6.64 39.56 0.08 10.09 1.7
 35 | 2.235 2.386 0 1.585 40.88 88.68 12.44 40.56 25.08 114.28 0.65 36.25 11.03
 36 | 3.122 1.695 0 1.885 35.92 72.88 12.92 44 34.72 120.28 0.68 26.18 9.42
 37 | 2.219 2.774 0 1.3 8.8 56.52 13.04 32.48 31.52 71.76 0.11 4.97 7.37
 38 | 3.185 2.092 0 1.575 22.12 43.68 11.2 35.72 35 90.68 0.35 9.66 4.89
 39 | 3.514 5.119 0 4.191 15.48 33.36 9.28 52 21.76 145.6 0.65 5.16 3.1
 40 | 4.459 2.624 0 1.485 11.16 34.64 6.84 19 15.84 82.8 0.17 3.87 2.37
 41 | 4.339 1.473 0 0.915 39.8 64.8 10.8 32.72 18.6 86 0.36 25.79 7
 42 | 4.92 1.417 0 0.705 15.76 39.52 8.56 30.28 21.96 66.4 0.11 6.23 3.38
 43 | 3.648 3.78 0 0.62 48.8 63.2 14.16 28.56 24.44 78 0.3 30.84 8.95
 44 | 2.916 4.916 0 0.885 4.52 37.16 6.28 27.92 13.88 46.8 0.04 1.68 2.33
 45 | 3.127 1.691 0 1.96 47.12 93.92 13.4 45.2 35.12 123.84 0.92 44.26 12.59
 46 | 3.441 4.719 0 3.155 48.8 55.6 9.28 62.4 24.28 151.6 1.54 27.13 5.16
 47 | 3.336 4.613 0 1.28 24.96 49.2 5.92 38.52 23.28 81.6 0.32 12.28 2.91
 48 | 3.649 2.674 0 1.785 9.65 58.4 7.44 23.72 17.72 58 0.17 5.64 4.34
 49 | 3.875 4.924 0 1.895 25.28 35.6 11.48 52 26.72 141.6 0.48 9 4.09
 50 | 2.612 4.114 0 0.57 33.8 58.4 4.88 27.32 7.44 47.6 0.19 19.74 2.85
 51 | 2.34 4.141 0 0.54 17.4 36.88 5.48 35.72 10.6 53.2 0.09 6.42 2.02
 52 | 3.811 1.318 0 0.75 16.4 39.8 12.6 36.2 26.6 80.8 0.12 6.53 5.01
 53 | 3.661 3.788 0 0.875 65.2 69.6 14.64 28.88 20.8 76.4 0.57 45.38 10.19
 54 | 4.34 3.736 0 2.818 29.12 46 11.24 35.04 21.96 80.8 0.82 13.4 5.17
 55 | 2.972 0.988 0 3.805 112.04 229.56 9.16 67.04 28.88 219.32 4.26 257.2 21.03
 56 | 2.286 3.068 0 0.605 28.8 56.6 9.68 27.32 12.8 67.16 0.17 16.3 5.48
 57 | 1.813 2.116 0 1.003 21.2 48.8 11.32 33.48 20.56 110 0.21 10.35 5.52
 58 | 3.379 4.308 0 1.9 10.28 36.44 8.52 46.4 24.8 83.6 0.2 3.75 3.1
 59 | 1.965 2.807 0 0.895 60.72 89.68 12.6 41.6 24.16 102.44 0.54 54.45 11.3
 60 | 3.559 4.009 0 4.02 21.08 52 6.16 60.8 21.96 101.6 0.85 10.96 3.2
 61 | 2.267 4.189 0 0.56 12.72 39.64 6.64 35.12 11.12 57.2 0.07 5.04 2.63
 62 | 2.965 1.002 0 1.39 57.2 129.2 10.36 45.6 24.6 149.2 0.8 73.9 13.39
 63 | 3.12 1.469 0 1.91 11.6 69.16 2.12 31.12 8 50.4 0.22 8.02 1.47
 64 | 3.454 4.654 0 1.07 10.88 29.88 7.8 38.24 19.92 70.8 0.12 3.25 2.33
 65 | 1.071 1.567 0 0.795 9.92 37.48 9.96 29.08 15.28 65.6 0.08 3.72 3.73
 66 | 3.573 3.542 0 0.55 50.4 77.2 9.56 26.6 16 76 0.28 38.91 7.38
 67 | 3.331 4.609 0 1.255 49.6 80.4 7 42.8 25.44 101.6 0.62 39.88 5.63
 68 | 3.541 1.739 0 2.055 10.8 43.6 6.32 29.8 20.8 59.36 0.22 4.71 2.76
 69 | 3.303 3.963 0 1.22 51.6 80.8 11 34.04 20.32 90 0.63 41.69 8.89
 70 | 3.316 2.987 0 0.975 30.1 48.8 14.6 33 23.6 83.2 0.29 14.69 7.12
 71 | 1.879 1.171 0 0.465 23.32 54.8 4 24.64 9.16 44.4 0.11 12.78 2.19
 72 | 1.122 2.267 0 1.145 14.8 47.6 11.08 37.08 31.56 74.4 0.17 7.04 5.27
 73 | 4.423 1.078 0 1.525 22 46.8 16.92 38.6 26.8 87.6 0.34 10.3 7.92
 74 | 1.241 1.155 0 1.455 7.28 36.52 4.52 20.2 12.68 39.6 0.11 2.66 1.65
 75 | 1.706 1.848 0 1.12 20.72 41.2 11.92 34.84 19.96 83.2 0.23 8.54 4.91
 76 | 3.26 5.42 0 1.819 17.6 35.8 11.72 38.04 28.6 82.4 0.32 6.3 4.2
 77 | 4.081 0.897 0 0.495 14.32 32.76 11.2 22.4 10.92 50.4 0.07 4.69 3.67
 78 | 3.077 2.926 0 2.12 12.32 42.4 10.12 35.32 21.52 64.8 0.26 5.22 4.29
 79 | 3.406 4.741 0 2.15 28.96 42.8 7.32 48 19.72 120.8 0.62 12.39 3.13
 80 | 3.699 3.8 0 0.65 35.56 80.8 11.6 27.44 19.28 74 0.23 28.73 9.37
 81 | 1.619 2.883 0 0.84 22.84 50.4 6.8 30.56 16.08 58.8 0.19 11.51 3.43
 82 | 3.196 1.814 0 3.925 47.4 84.16 12.92 25.6 26.12 92.36 1.86 39.89 10.87
 83 | 3.447 4.733 0 1.98 27.12 39.92 8.4 40.8 17.68 108 0.54 10.83 3.35
 84 | 3.009 4.738 0 0.45 12.44 34 3.53 25.64 10 39.4 0.06 4.23 1.2
 85 | 3.452 4.736 0 2.96 38.96 70.4 7.2 45.2 15 148.4 1.15 27.43 5.07
 86 | 2.908 1.263 0 1.685 9.4 34.56 9.84 31.28 14.72 84.32 0.16 3.25 3.4
 87 | 4.578 1.512 0 1.305 17.5 38.96 13.52 45.52 27.2 77.6 0.23 6.82 5.27
 88 | 3.512 5.124 0 4.227 16.88 34.64 9.64 48.4 22.92 136.8 0.71 5.85 3.34
 89 | 3.312 2.991 0 0.98 22.7 41.6 12.52 32.6 19.4 72.8 0.22 9.44 5.21
 90 | 2.159 2.041 0 1.57 17.44 49.6 10.44 37.72 28.32 81.6 0.27 8.65 5.18
 91 | 4.742 1.381 0 0.86 15.12 32.84 11.88 32.72 23.48 63.6 0.13 4.97 3.9
 92 | 3.592 4.027 0 2.17 12.52 37.68 10.84 55.2 29.48 74.4 0.27 4.72 4.08
 93 | 3.152 3.272 0 1.56 34 76.4 12.8 42.6 23.52 94 0.53 25.98 9.78
 94 | 4.781 1.375 0 0.81 12.08 36.28 10.88 27.44 20.84 58.8 0.1 4.38 3.95
 95 | 2.319 2.405 0 1.71 56.24 104.68 12.84 43.4 26.96 125.4 0.96 58.87 13.44
 96 | 3.617 2.084 0 0.845 27.92 78.8 12.8 33.72 26.2 79.6 0.24 22 10.09
 97 | 2.278 0.929 0 0.357 13.24 35.4 4.08 19.36 6.56 46.8 0.05 4.69 1.44
 98 | 3.792 2.695 0 1.535 5.88 55.2 6.76 20.32 13.4 52.4 0.09 3.25 3.73
 99 | 4.113 2.7 0 1.285 13.64 84.4 1.55 8.72 7.16 65.2 0.18 11.51 1.31
100 | 3.043 4.698 0 1.82 7.6 27.04 3.92 27.36 10.44 39.8 0.14 2.06 1.06
101 | 3.271 2.16 0 0.945 37.4 59.04 13.32 37.8 32.6 104.36 0.35 22.08 7.86
102 | 1.433 1.525 0 1.605 13.48 49.6 7.36 67.6 16.2 75.2 0.22 6.69 3.65
103 | 3.184 2.098 0 2.23 24.6 44.88 11.92 37.8 37.72 96.6 0.55 11.04 5.35
104 | 3.675 4.293 0 0.89 4.4 26.76 8.6 37.68 22.96 66 0.04 1.18 2.3
105 | 3.681 5.69 0 1.898 15.16 59.2 12.64 54 28.36 86 0.29 8.97 7.48
106 | 2.461 3.423 0 0.37 15.72 29.36 3.14 22.6 6.08 47.2 0.06 4.62 0.92
107 | 4.576 1.411 0 1.38 15.64 34.44 11.28 37.6 25.76 71.6 0.22 5.39 3.88
108 | 2.223 0.58 0 0.285 14.16 44 9.6 38 24.52 76 0.04 6.23 4.22
109 | 3.031 1.201 0 0.61 16.4 52.56 6.44 21.84 10.36 51.24 0.1 8.62 3.38
110 | 3.347 2.505 0 0.625 5.36 41.2 6.96 33.2 19.2 43.6 0.03 2.21 2.87
111 | 2.465 4.003 0 0.325 9.72 24.64 3.19 21.4 4.72 35.08 0.03 2.4 0.79
112 | 3.175 2.102 0 1.985 18.92 42.68 12.2 38.4 37.2 89.84 0.38 8.08 5.21
113 | 3.733 0.974 0 0.95 15.4 36.6 8.92 40.8 26.52 74 0.15 5.64 3.26
114 | 3.085 1.677 0 2.04 26.2 63.92 11.8 40.4 29.8 107.2 0.53 16.75 7.54
115 | 2.595 3.638 0 0.325 17.52 44.4 3.71 14.52 4.76 40.8 0.06 7.78 1.65
116 | 4.279 3.283 0 0.83 19.2 36.36 13.36 33.6 24.64 84.4 0.16 6.98 4.86
117 | 2.933 0.978 0 0.8 166.4 146.8 12.4 31.44 16 100.4 1.33 244.28 18.2
118 | 3.59 4.033 0 2.08 11.52 37.56 7.92 56.4 24.84 79.6 0.24 4.33 2.97
119 | 2.883 1.237 0 2.55 12.12 36.56 8.52 31.24 16.12 96.96 0.31 4.43 3.11
120 | 2.429 1.62 0 2.235 31.96 77.6 11.84 52.4 26.64 126.8 0.71 24.8 9.19
121 | 2.333 2.417 0 1.435 53.2 107.6 9.12 37.44 21.32 110.32 0.76 57.24 9.81
122 | 0.626 1.652 0 0.375 4.2 37.12 7.28 33.32 14.4 46.4 0.02 1.56 2.7
123 | 2.969 0.778 0 1.93 77.32 157.28 12.44 43.04 33.76 166.28 1.49 121.61 19.57
124 | 0.971 1.576 0 1.215 9.8 35.64 10.08 29.28 15.2 64 0.12 3.49 3.59
125 | 1.392 1.846 0 1.05 7.44 37.68 10.6 39.24 20 48.4 0.08 2.8 3.99
126 | 2.54 3.32 0 1.26 17.2 53.6 9.76 45.32 17.6 62.8 0.22 9.22 5.23
127 | 1.738 1.771 0 0.685 19.64 41.6 11.92 33.64 16.24 76 0.13 8.17 4.96
128 | 2.243 3.031 0 0.705 19.2 34 11.8 29.92 14.6 59.88 0.14 6.53 4.01
129 | 3.656 2.63 0 1.385 9.23 80.4 2.07 9.72 5.36 49.2 0.13 7.42 1.66
130 | 2.325 4.143 0 0.505 14 33.24 5.48 34 10.92 54.4 0.07 4.65 1.82
131 | 4.55 1.416 0 1.74 18.1 41.6 12.4 44.32 27.72 73.6 0.31 7.53 5.16
132 | 4.325 1.436 0 0.56 19.4 36.76 11.6 26.92 13.72 57.2 0.11 7.13 4.26
133 | 3.669 4.291 0 1.917 8.4 35.12 8.44 33.48 18.72 59.6 0.16 2.95 2.96
134 | 1.877 1.186 0 0.32 26.16 45.2 3.8 18.2 6.44 39.88 0.08 11.82 1.72
135 | 3.044 1.123 0 0.63 18.04 38.24 12 31.28 18.68 80.76 0.11 6.9 4.59
136 | 3.001 2.581 0 4.18 8.2 42.04 9.6 45.32 22.2 81.72 0.34 3.45 4.04
137 | 3.136 2.091 0 1.11 17.92 38.72 14.2 34.8 30.32 79 0.2 6.94 5.5
138 | 2.633 3.65 0 0.425 16.2 50.4 3.09 22.12 5.04 61.6 0.07 8.16 1.56
139 | 3.721 4.239 0 0.28 18 41.2 8 25.96 12.28 46.4 0.05 7.42 3.3
140 | 2.333 2.367 0 1.39 59.16 101.92 12.36 42.12 28.2 135.88 0.82 60.3 12.6
141 | 4.038 2.354 0 2.805 10.5 44 12.2 39.2 32.92 65.6 0.29 4.62 5.37
142 | 3.117 1.702 0 1.71 30 58.6 14.12 42.8 35 106.36 0.51 17.58 8.27
143 | 1.824 0.999 0 0.165 23.64 56.4 3.75 18.6 7.08 44 0.04 13.33 2.12
144 | 2.85 1.89 0 1.36 8.68 53.6 2.81 10.76 7.08 28.88 0.12 4.65 1.51
145 | 2.502 3.988 0 0.24 20.72 22.36 3.76 18.92 5.2 32.24 0.05 4.63 0.84
146 | 1.443 1.509 0 1.445 15.4 50.8 7.76 61.2 20.68 75.6 0.22 7.82 3.94
147 | 2.008 1.35 0 0.515 16.04 35.04 5 32.56 8.96 50.4 0.08 5.62 1.75
148 | 2.978 4.009 0 0.56 8.35 25.4 6.52 24.4 12.4 49.2 0.05 2.12 1.66
149 | 1.662 1.425 0 0.905 44.4 82 11.24 37.4 16.56 78.4 0.4 36.41 9.22
150 | 1.587 1.08 0 0.605 26.24 54 5.16 29.28 11.44 54 0.16 14.17 2.79
151 | 3.994 3.814 0 2.423 32.52 80.4 14.48 45.6 28.32 84 0.79 26.15 11.64
152 | 4.383 2.279 0 0.785 6.72 43.6 7.48 35.92 22.72 60.8 0.05 2.93 3.26
153 | 2.901 4.919 0 0.81 5.48 28.8 4.64 28.6 14.92 42 0.04 1.58 1.34
154 | 4.156 1.242 0 1.1 5.72 32.48 7.84 32.2 17.92 44 0.06 1.86 2.55
155 | 4.475 3.526 0 0.951 38.96 78.8 15.28 29.36 20.36 70.8 0.37 30.7 12.04
156 | 2.58 3.654 0 0.275 7.48 20.2 3.55 16.2 4.64 33.44 0.02 1.51 0.72
157 | 0.701 1.997 0 1.58 9.84 64.8 12.6 60.8 32.2 86 0.16 6.38 8.16
158 | 3.649 3.887 0 1.06 26.44 51.2 11.48 41.6 29.24 80.8 0.28 13.54 5.88
159 | 2.623 0.853 0 2.58 29.24 59.2 11.64 45.2 27.36 106.4 0.75 17.31 6.89
160 | 1.315 1.975 0 3.68 14.44 56.4 11.12 52 28.72 89.6 0.53 8.14 6.27
161 | 3.656 2.67 0 1.875 9.52 70 11.12 36.12 25.4 65.2 0.18 6.66 7.78
162 | 4.426 0.821 0 0.805 8.76 27.2 13 48.32 26 61.6 0.07 2.38 3.54
163 | 2.882 3.693 0 0.535 8.76 27.04 4.6 20.8 5.4 32.92 0.05 2.37 1.24
164 | 1.108 1.535 0 2.055 60 195.6 8.08 50.4 23.16 108 1.23 117.36 15.8
165 | 4.48 1.089 0 0.555 10.8 36.52 10.28 27.64 19.6 64.8 0.06 3.94 3.75
166 | 1.468 2.192 0 1.51 10.88 44.4 10.92 57.6 30.68 80.4 0.16 4.83 4.85
167 | 2.319 4.103 0 0.58 20.52 34.88 5.48 36 10.92 50.4 0.12 7.16 1.91
168 | 3.585 4.04 0 1.97 24.64 66 8 51.2 25.76 99.2 0.49 16.26 5.28
169 | 3.647 3.786 0 0.765 42 70.8 13.84 29.72 20.96 90.8 0.32 29.74 9.8
170 | 2.31 2.732 0 0.735 17.68 39.2 12.72 39 23.24 79.04 0.13 6.93 4.99
171 | 3.962 2.009 0 1.445 42.92 78.4 12.4 43.52 34.4 104.4 0.62 33.65 9.72
172 | 3.47 5.555 0 2.234 12.52 48.4 13.48 45.2 29.68 64 0.28 6.06 6.52
173 | 1.839 0.995 0 0.225 27.72 55.6 4.24 24.88 10.12 56 0.06 15.41 2.36
174 | 1.706 1.165 0 0.74 25.52 60.8 4.36 20.4 8.68 62.4 0.19 15.52 2.65
175 | 2.774 1.544 0 1.915 19.32 45.72 8.44 42.32 20.64 90.24 0.37 8.83 3.86
176 | 3.493 5.092 0 3.421 14.8 34.32 9.8 52.4 20.44 134.4 0.51 5.08 3.36
177 | 1.695 3.227 0 1.835 10.88 56.68 5.88 35.08 21.44 97.48 0.2 6.17 3.33
178 | 4.409 1.084 0 1.77 18.92 48.8 17.32 37.72 27 89.2 0.33 9.23 8.45
179 | 2.596 3.212 0 3.995 15.92 45.16 8.64 49.72 22 118.24 0.64 7.19 3.9
180 | 1.897 1.22 0 0.26 9.24 27 3.48 16.24 4.76 27.2 0.02 2.49 0.94
181 | 2.083 1.695 0 0.44 11.28 56.4 6 29.28 16.68 54.8 0.05 6.36 3.38
182 | 3.673 4.278 0 1.015 7.36 34 9.28 44 19.28 70.4 0.07 2.5 3.16
183 | 2.731 3.002 0 0.485 6.6 32.44 9 27.32 20.92 57.96 0.03 2.14 2.92
184 | 4.264 3.391 0 2.828 79.2 135.2 11.16 32.64 24.96 132.8 2.24 107.08 15.09
185 | 3.792 2.707 0 1.38 6.44 45.6 8.16 26.92 17.12 55.2 0.09 2.94 3.72
186 | 3.39 1.048 0 1.66 24.6 57.28 10.12 42.92 29.32 123.32 0.41 14.09 5.8
187 | 3.184 5.075 0 0.685 11.36 23.68 7.08 33.76 16.32 53.6 0.08 2.69 1.68
188 | 3.644 2.677 0 0.93 6.77 51.2 9.56 37.4 23.12 56.4 0.06 3.47 4.89
189 | 3.504 5.13 0 5.129 14.76 36.8 8.6 39.24 18.28 135.6 0.76 5.43 3.16
190 | 2.242 3.036 0 0.725 17 34.08 10.32 26.32 12.72 56.72 0.12 5.79 3.52
191 | 3.332 4.628 0 0.74 96 59.2 4.52 35.92 17.2 83.2 0.71 56.83 2.68
192 | 3.498 3.196 0 0.99 14.5 36.24 15.12 32.8 22.92 65.6 0.14 5.25 5.48
193 | 1.883 1.176 0 0.195 25.12 49.6 3.92 21.8 7.52 43.2 0.05 12.46 1.94
194 | 3.322 3.001 0 1.34 25.3 44.4 14.32 35 23.12 81.2 0.34 11.23 6.36
195 | 1.047 1.922 0 1.24 18.32 52 14.2 43.6 22.52 83.2 0.23 9.53 7.38
196 | 3.843 3.121 0 1.84 33.32 44.4 10.8 39.52 35.28 86 0.61 14.79 4.8
197 | 1.301 0.599 0 0.91 21.2 64.8 13.24 32.84 18 75.2 0.19 13.74 8.58
198 | 1.106 1.548 0 1.27 19.12 65.2 9.16 52.8 19.44 65.2 0.24 12.47 5.97
199 | 1.114 1.535 0 1.48 106.8 226.4 9.12 58.8 26.16 140.4 1.58 241.8 20.65
200 | 1.511 0.734 0 1.245 22.64 64.4 7.84 47.2 21.96 71.2 0.28 14.58 5.05
201 | 1.317 1.501 0 1.385 120.8 66.4 6.44 42.8 19.64 94.8 1.67 80.21 4.28
202 | 1.439 1.523 0 1.72 16.4 52.4 7.24 54.8 16.52 75.6 0.28 8.59 3.79
203 | 1.651 1.157 0 0.525 26.28 46.4 3.88 20.84 8.36 49.6 0.14 12.19 1.8
204 | 1.701 1.169 0 0.69 17.04 52.4 4.24 23.48 9.04 45.6 0.12 8.93 2.22
205 | 1.857 0.659 0 3.53 66 118 10.08 52.8 24.44 124.8 2.33 77.88 11.89
206 | 1.346 1.954 0 0.93 9 38.12 10.56 39.04 20.24 69.2 0.08 3.43 4.03
207 | 1.354 1.966 0 1.165 8.64 38.32 10.72 43.6 24 59.6 0.1 3.31 4.11
208 | 1.35 1.97 0 3.81 17.92 64.8 10.12 60.8 27.08 102 0.68 11.61 6.56
209 | 1.932 1.004 0 0.135 10.44 37 4.52 15.08 5.24 32.56 0.01 3.86 1.67
210 | 1.837 1.037 0 0.215 23.44 46.8 3.88 23 8.16 44 0.05 10.97 1.82
211 | 1.69 1.858 0 1.775 29.76 54.8 12.96 38.72 22.36 91.6 0.53 16.31 7.1
212 | 1.72 1.833 0 0.585 24.36 50 11.6 31.68 15.96 76.8 0.14 12.18 5.8
213 | 1.543 2.537 0 1.563 26.72 52.4 10.4 45.2 28.72 104 0.42 14 5.45
214 | 2.353 1.274 0 0.275 8.24 32.56 4.32 15.4 4.2 37.88 0.02 2.68 1.41
215 | 1.889 2.462 0 2.505 12.16 65.2 10.2 48.4 31.04 78.4 0.3 7.93 6.65
216 | 2.327 2.417 0 1.385 58.72 116.48 9.68 39.72 22.6 123 0.81 68.4 11.28
217 | 2.504 1.965 0 1.79 19.92 62.36 10.44 41.84 25.64 80.32 0.36 12.42 6.51
218 | 2.599 1.996 0 2.115 61.32 172.12 13.16 43.08 53.2 133.88 1.3 105.54 22.65
219 | 2.561 1.984 0 1.63 18.08 63.16 13.56 51.36 42.92 77.4 0.29 11.42 8.56
220 | 2.898 1.274 0 2.7 15.56 38.28 6.52 32.76 15 99.6 0.42 5.96 2.5
221 | 2.902 1.263 0 4.495 10.24 32.92 10.32 39.16 22.64 101.68 0.46 3.37 3.4
222 | 3.085 1.214 0 0.765 37.6 68.4 7.68 18.52 11.28 86.2 0.29 25.72 5.25
223 | 3.046 1.205 0 0.4 9.6 32.76 11.16 21.64 13.36 44 0.04 3.14 3.66
224 | 3.025 1.201 0 0.32 12.92 40.2 5.6 18.52 7.2 43.72 0.04 5.19 2.25
225 | 2.04 3.153 0 0.655 17.2 41.88 5 16.56 8.24 51.24 0.11 7.2 2.09
226 | 2.234 2.737 0 1.11 10.28 47.8 14.6 39.28 24.44 71.12 0.11 4.91 6.98
227 | 2.22 2.732 0 0.77 16 44.4 12.28 43.48 23.88 62.28 0.12 7.1 5.45
228 | 2.224 2.728 0 1.205 11.36 41.04 13.8 46.84 27.44 85.52 0.14 4.66 5.66
229 | 2.58 2.311 0 1.555 15.4 51.24 8.84 40.16 23.92 77.56 0.24 7.89 4.53
230 | 2.254 3.045 0 0.575 31.8 54.28 9.68 27.12 13.2 66.92 0.18 17.26 5.25
231 | 2.656 2.656 0 0.525 79.2 138.56 12.52 26.12 18 91.48 0.42 109.74 17.35
232 | 3.465 1.393 0 0.705 48.72 86.68 12.52 28.72 17.6 96.6 0.34 42.23 10.85
233 | 2.553 3.314 0 0.99 9.28 38 8.8 38.72 15.72 60.12 0.09 3.53 3.34
234 | 2.538 3.314 0 1.655 31.52 90.36 8.96 50.6 17.32 81.6 0.52 28.48 8.1
235 | 2.402 3.979 0 0.515 13.12 26.96 4.08 30.12 8.2 43.2 0.07 3.54 1.1
236 | 2.456 3.99 0 0.35 11.6 27.68 3.27 26.32 4.92 37.16 0.04 3.21 0.91
237 | 2.537 3.768 0 0.23 8.72 26.84 3.79 18.2 5.68 32.08 0.02 2.34 1.02
238 | 2.584 3.649 0 0.305 17.12 48.4 3.72 18 5.6 44.8 0.05 8.29 1.8
239 | 3.887 1.663 0 1.535 29.6 56.8 15.2 40.72 32.4 85.6 0.45 16.81 8.63
240 | 4.412 1.088 0 1.53 17.72 47.6 17.72 39.52 26.4 80.8 0.27 8.43 8.43
241 | 2.795 3.645 0 0.3 13.4 37.76 4.24 17.32 6.32 27.12 0.04 5.06 1.6
242 | 2.837 3.679 0 0.425 4.68 22.56 5.08 22.72 8 31.48 0.02 1.06 1.15
243 | 2.832 3.676 0 0.36 4.44 18.96 6.68 26.12 11.8 28.92 0.02 0.84 1.27
244 | 3.308 2.963 0 1.06 28 50 17.32 36 23.92 78.4 0.3 14 8.66
245 | 3.422 2.851 0 0.9 49 70.4 9.52 38.72 26.2 94.8 0.44 34.5 6.7
246 | 3.692 2.43 0 1.61 9.44 42.8 5 19.4 8.76 31.16 0.15 4.04 2.14
247 | 4.331 1.449 0 0.95 19.6 37.88 12 29.2 18.72 61.2 0.19 7.42 4.55
248 | 4.333 1.455 0 0.82 32.1 63.2 10.32 29.8 16.72 67.6 0.26 20.29 6.52
249 | 4.502 1.167 0 0.86 12.7 37.08 12.12 28.4 20.12 61.6 0.11 4.71 4.49
250 | 3.228 3.617 0 1.835 45.92 80.4 13.32 47.4 24 90 0.84 36.92 10.71
251 | 3.768 2.775 0 0.22 6.67 31.88 10.8 26.32 17.52 45.2 0.01 2.13 3.44
252 | 3.768 2.675 0 1.095 6.2 46.8 12.12 41.32 28.8 56.8 0.07 2.9 5.67
253 | 3.798 2.694 0 0.995 5.38 51.2 9.68 32.8 19.12 54 0.05 2.75 4.96
254 | 4.59 1.414 0 0.96 16.4 30.76 11.72 35.2 21.92 64.8 0.16 5.04 3.61
255 | 4.571 1.407 0 1.4 15.24 38.4 10.72 38.64 26.4 70.8 0.21 5.85 4.12
256 | 4.745 1.372 0 0.69 16.44 34.12 11.96 35.64 23.68 66.4 0.11 5.61 4.08
257 | 4.788 1.647 0 0.72 11.4 32.68 8.8 34.08 26.72 63.2 0.08 3.73 2.88
258 | 2.974 4.937 0 2.26 12.64 36.28 5.88 36.44 21.52 77.6 0.29 4.59 2.13
259 | 2.906 4.922 0 1.13 5.92 21.6 4.32 20.32 13.2 32.84 0.07 1.28 0.93
260 | 3.109 4.729 0 0.645 8.4 28.56 3.12 22.68 8.88 42.4 0.05 2.4 0.89
261 | 3.04 4.713 0 0.63 7.24 26 3.66 23.96 9.36 36.64 0.05 1.88 0.95
262 | 3.919 3.466 0 0.86 12.8 28.6 9.76 28.4 17.48 58.8 0.11 3.66 2.79
263 | 4.189 3.045 0 1.645 35.6 67.6 8.08 46.4 20.32 90.4 0.59 24.07 5.46
264 | 3.652 4.312 0 3.149 8.24 56 10.72 51.2 27.72 98 0.26 4.61 6
265 | 3.894 3.805 0 0.552 50 91.2 14.32 29 20.12 79.2 0.28 45.6 13.06
266 | 3.917 3.773 0 1.568 18.4 43.6 13.56 30.36 22.28 71.6 0.29 8.02 5.91
267 | 3.925 3.779 0 0.855 11.4 29.68 14.24 29.2 21 59.6 0.1 3.38 4.23
268 | 4.252 3.292 0 0.733 39.2 65.6 11.8 26 22.24 74 0.29 25.72 7.74
269 | 4.292 3.29 0 2.08 71.6 52.8 11.92 31.68 28.64 110.8 1.49 37.8 6.29
270 | 4.283 3.278 0 0.844 21.04 34.68 13.88 37.12 26.48 90 0.18 7.3 4.81
271 | 3.53 4.999 0 0.49 4.64 31.64 7.44 34.52 16.76 56.8 0.02 1.47 2.35
272 | 4.07 4.157 0 1.916 45.6 50 14.36 47.6 28.44 90.8 0.87 22.8 7.18
273 | 4.61 3.315 0 1.384 7.48 48 12.68 30.76 20.72 46.8 0.1 3.59 6.09
274 | 3.605 5.345 0 0.849 18.4 35 9.04 29.48 17.56 58 0.16 6.44 3.16
275 | 2.672 3.558 0 1.57 18.6 38.2 8.28 37.12 18.6 65.2 0.29 7.11 3.16
276 | 3.589 4.443 0 2.045 11.48 33.36 10.8 40.8 21.52 112.8 0.23 3.83 3.6
277 | 4.01 4.713 0 1.203 13.04 26.56 12 53.2 23.92 91.6 0.16 3.46 3.19
278 | 2.942 3.137 0 0.49 5.64 25.88 10.92 23.4 14.6 41.2 0.03 1.46 2.83
279 | 1.409 2.748 0 0.692 10.32 31.16 8.12 27.16 14.64 50.4 0.07 3.22 2.53
280 | 3.978 2.91 0 1.75 8.36 37.72 9.12 35.48 26.4 63.2 0.15 3.15 3.44
281 | 2.715 2.1 0 0.415 4.44 41 9.12 30.32 24.24 53.16 0.02 1.82 3.74
282 | 3.87 0.762 0 0.685 10.92 30.84 11.72 31.92 13.12 49.28 0.07 3.37 3.61
283 | 2.445 2.521 0 0.92 30.28 68.12 10.56 49.04 31.52 102.72 0.28 20.63 7.19
284 | 3.827 2.219 0 2.12 7.35 54.4 6.36 23 14.52 72.4 0.16 4 3.46
285 | 2.488 1.064 0 0.495 17.08 46.8 8.52 31.4 16.12 57.6 0.08 7.99 3.99
286 | 1.646 0.524 0 1.06 18.88 55.2 14.44 37.28 25.24 76.4 0.2 10.42 7.97
287 | 3.136 2.37 0 0.79 3.98 35.28 5.2 33.12 14.92 32.6 0.03 1.4 1.83
288 | 3.74 5.134 0 0.772 8.16 30.16 10.84 39.04 24.24 56.8 0.06 2.46 3.27
289 | 1.678 2.327 0 1.188 31.36 72.4 9.68 37.44 22.36 108.4 0.37 22.7 7.01
290 | 4.399 3.18 0 1.615 91.2 108.8 11.96 34.56 30.2 156.8 1.47 99.23 13.01
291 | 3.935 4.368 0 3.023 19.72 45.6 12.76 40.8 25.36 105.2 0.6 8.99 5.82
292 | 3.33 1.604 0 2.315 113.12 144.36 9.92 56.2 25.4 147.4 2.62 163.3 14.32
293 | 3.557 2.64 0 2.65 12.3 54.4 8.84 25.72 18.92 58.4 0.33 6.69 4.81
294 | 1.376 0.945 0 3.78 32.76 94.4 9.68 42.8 23.52 175.2 1.24 30.93 9.14
295 | 2.024 2.251 0 1.805 55.6 142 12.6 38 23.12 124.8 1 78.95 17.89
296 | 3.31 4.594 0 1.58 56.4 93.6 5.8 40.4 22.52 108.8 0.89 52.79 5.43
297 | 4.097 1.798 0 1.93 19.3 46.4 13.8 45 35.72 90 0.37 8.96 6.4
298 | 2.326 3.633 0 0.415 18.32 31.92 2.36 20.12 6.28 40.72 0.08 5.85 0.75
299 | 3.514 4.098 0 0.675 9.24 27.24 6.56 26 11.64 50 0.06 2.52 1.79
300 | 3.168 4.173 0 0.745 8.52 30.28 3.94 26.56 15.4 52.4 0.06 2.58 1.19
301 | 4.292 1.039 0 1.42 18.8 36.48 11.12 27.52 20.6 63.2 0.27 6.86 4.06
302 | 2.834 0.988 0 1.425 13.32 53.6 15.24 49.2 25.56 108.8 0.19 7.14 8.17
303 | 4.443 1.723 0 1.31 17.7 48.4 12.72 34.8 19.6 80.4 0.23 8.57 6.16
304 | 3.482 2.295 0 1.765 127 300 10.32 40.52 30.8 192 2.24 381 30.96
305 | 3.665 4.789 0 0.647 9.76 21.76 8.72 31.12 13.88 60.8 0.06 2.12 1.9
306 | 4.173 2.144 0 1.81 17.9 48.8 13.2 44.12 29.6 92.8 0.32 8.74 6.44
307 | 2.143 1.139 0 0.394 39.56 105.6 4.44 21.64 8.92 72.4 0.16 41.78 4.69
308 | 3.061 2.025 0 1.6 20.6 35.72 10.92 37.72 25.32 92.64 0.33 7.36 3.9
309 | 2.985 1.679 0 1.675 22.92 61.44 14.4 46.28 43.68 111.08 0.38 14.08 8.85
310 | 3.438 3.752 0 1.28 13.04 43.6 6.36 31 18.6 65.2 0.17 5.69 2.77
311 | 4.637 0.956 0 0.87 16.5 35.32 12.8 33.52 22.52 78.4 0.14 5.83 4.52
312 | 3.049 5.285 0 0.8 7.68 48.4 12.4 49.2 27.16 60.4 0.06 3.72 6
313 | 1.106 1.366 0 0.475 22.68 55.2 3.96 22.16 7.92 46.8 0.11 12.52 2.19
314 | 3.633 2.986 0 0.855 25.5 51.6 12.4 32.92 22.32 80.4 0.22 13.16 6.4
315 | 3.708 3.331 0 1.34 10.32 41.2 9.32 28.48 23.28 58 0.14 4.25 3.84
316 | 2.909 1.334 0 1.805 28.92 74.36 6.12 24.8 11.24 111.32 0.52 21.5 4.55
317 | 2.102 2.597 0 0.825 31.2 70.4 15.32 36.52 25.36 75.44 0.26 21.96 10.79
318 | 1.797 1.215 0 0.545 33.08 58 4.24 21.8 8.88 47.2 0.18 19.19 2.46
319 | 3.255 1.253 0 1.78 154.6 239.96 11.4 41 24.52 259.84 2.75 370.98 27.36
320 | 4.129 3.601 0 2.566 7.88 55.2 10.6 32.84 23.6 59.2 0.2 4.35 5.85
321 | 3.363 3.407 0 0.61 7.86 34.84 14.8 28.52 19.32 53.2 0.05 2.74 5.16
322 | 1.452 1.29 0 0.585 15.16 56.4 5.8 39.88 13.2 51.2 0.09 8.55 3.27
323 | 4.745 3.105 0 1.436 14.2 32.68 5.24 19.44 9.52 44.8 0.2 4.64 1.71
324 | 0.491 1.862 0 2.415 21.32 48.4 7.88 32.72 18.16 49.2 0.51 10.32 3.81
325 | 2.369 2.176 0 0.75 73.12 139.16 15.6 29.76 20.2 95.68 0.55 101.75 21.71
326 | 3.676 1.528 0 0.805 38.72 88.32 11.12 32 19.52 88.16 0.31 34.2 9.82
327 | 1.257 2.057 0 0.65 12.8 41.6 11.44 37.08 19.64 52 0.08 5.32 4.76
328 | 3.903 2.565 0 0.51 5.96 62.4 1.65 3.32 1.98 60.4 0.03 3.72 1.03
329 | 1.603 1.981 0 0.705 16.04 38.24 13.04 29.84 17.92 70.4 0.11 6.13 4.99
330 | 3.395 5.21 0 1.112 13.12 25.56 9.8 36.56 19.48 65.6 0.15 3.35 2.5
331 | 2.564 1.409 0 1.31 117.6 152.8 8.44 41.6 20.4 145.2 1.54 179.69 12.9
332 | 0.912 2.132 0 2.2 11.88 51.6 10.48 60.4 30.8 78.4 0.26 6.13 5.41
333 | 3.093 3.828 0 0.45 11.5 30.92 7.96 23.2 9.36 43.2 0.05 3.56 2.46
334 | 0.836 1.787 0 0.825 12.96 50 14.32 40.8 22.84 80.4 0.11 6.48 7.16
335 | 2.758 0.643 0 1.245 13.08 88 8.08 39.56 18.64 86.8 0.16 11.51 7.11
336 | 3.017 3.482 0 1.09 8.8 26.32 12.8 38.72 18.8 59.2 0.1 2.32 3.37
337 | 3.212 2.716 0 0.78 29.8 60.4 12.52 35.52 24 75.6 0.23 18 7.56
338 | 4.022 1.453 0 1.95 22.6 52 10.6 47 36.72 100 0.44 11.75 5.51
339 | 4.054 3.256 0 1.31 21.16 52.8 8.92 35.04 20.08 78.8 0.28 11.17 4.71
340 | 2.521 2.867 0 1.585 11.4 39.36 13.2 42 33.12 75.64 0.18 4.49 5.2
341 | 3.319 4.864 0 0.52 6.04 21.12 5.08 32.68 15.4 37.52 0.03 1.28 1.07
342 | 2.823 4.249 0 1.005 7.08 35.4 5.36 18.12 8.2 51.6 0.07 2.51 1.9
343 | 1.722 0.869 0 0.57 21.36 67.2 4.08 24.88 9.68 56.8 0.12 14.35 2.74
344 | 2.251 3.288 0 0.33 5.72 18.68 1.92 14.92 4.68 26.8 0.02 1.07 0.36
345 | 1.182 1.711 0 2.535 8.72 55.6 12.56 70 26.24 71.6 0.22 4.85 6.98
346 | 1.83 3.018 0 2.685 32.68 69.32 10.12 43.52 27.88 111.76 0.88 22.65 7.02
347 | 3.752 1.874 0 0.69 20.8 55.6 13.6 37.6 28.4 80.4 0.14 11.56 7.56
348 | 2.218 1.485 0 0.375 19.36 45.2 12.04 34.08 16.36 70 0.07 8.75 5.44
349 | 1.873 1.56 0 1.955 26.08 60.4 9.68 37.88 20.88 110.8 0.51 15.75 5.85
350 | 3.6 1.183 0 1.185 22.72 49.72 10 34.2 27.4 89.88 0.27 11.3 4.97
351 | 2.887 4.889 0 1.325 5.4 37.52 3.74 27.64 14.44 46.4 0.07 2.03 1.4
352 | 1.527 1.636 0 0.795 42 84.8 7.92 27.4 13.2 78.8 0.33 35.62 6.72
353 | 1.333 2.407 0 1.63 20.56 46 13.4 43.6 37.52 98.4 0.34 9.46 6.16
354 | 2.413 0.718 0 0.677 11.92 38.16 12.48 34.52 23.92 69.2 0.08 4.55 4.76
355 | 1.948 1.906 0 1.298 22.24 45.6 12 49.6 26.04 96.4 0.29 10.14 5.47
356 | 1.754 2.672 0 1.53 16.24 43.6 10.36 46.4 29.8 77.2 0.25 7.08 4.52
357 | 2.294 1.83 0 0.67 8.72 32.76 9.72 46.8 23.24 81.6 0.06 2.86 3.18
358 | 2.639 1.755 0 1.01 5.96 67.36 9.96 28.68 17.44 52.48 0.06 4.01 6.71
359 | 1.905 3.363 0 0.5 16.68 39.76 4.8 23.12 9.36 46.4 0.08 6.63 1.91
360 | 2.175 2.942 0 1.665 37 43.8 14.8 40.28 30.08 87.84 0.62 16.21 6.48
361 | 2.791 2.446 0 1.52 16.32 57.52 9.16 36.2 24.12 84.4 0.25 9.39 5.27
362 | 2.866 2.791 0 1.315 14 45.96 11.2 30.92 24.32 79.08 0.18 6.43 5.15
363 | 3.407 1.953 0 1.325 9.92 38.4 9.12 37.32 24.6 84.08 0.13 3.81 3.5
364 | 3.946 1.107 0 0.495 7.52 33 8.28 33 20.6 48.8 0.04 2.48 2.73
365 | 2.452 3.995 0 0.395 12.72 28.24 3.56 24 5.6 39.64 0.05 3.59 1.01
366 | 2.747 3.903 0 0.38 3.55 21.12 5.44 25.52 11.4 25 0.01 0.75 1.15
367 | 3.287 3.061 0 2.085 39 52.4 13.2 45.92 26.4 104 0.81 20.44 6.92
368 | 4.367 1.377 0 2.61 24 47.2 20.6 37.2 29.4 86.4 0.63 11.33 9.72
369 | 4.713 1.302 0 0.845 10.28 33.64 9.68 29.92 23.8 65.6 0.09 3.46 3.26
370 | 4.248 2.489 0 1.22 5.52 48.8 5.24 27.04 21.04 46.4 0.07 2.69 2.56
371 | 3.784 3.677 0 0.64 6.68 34.32 13.92 28.32 18 55.2 0.04 2.29 4.78
372 | 4.324 2.835 0 1.65 8.88 60 8.72 33.36 22.72 80 0.15 5.33 5.23
373 | 3.859 4.022 0 1.433 43.6 60.8 13.32 47.6 29.12 87.2 0.62 26.51 8.1
374 | 2.593 3.312 0 0.325 8.08 26.2 10.6 30 14 54.96 0.03 2.12 2.78
375 | 


--------------------------------------------------------------------------------