source: Sophya/trunk/SophyaLib/HiStats/xntuple.cc@ 1009

Last change on this file since 1009 was 1009, checked in by ansari, 25 years ago

Suite a l'intervention de cmv, rend coherent le choix long a la place de int dans xntuple.
Que le magicien verifie, car tout n'est pas transparent. Changement necessaire pour faire compiler fitsxntuple.cc
qui defini iligne en int_4
PB
Dominique
File size: 24.6 KB
Line 
1// -*- C++ -*-
2//
3// xntuple.cc
4// N. Regnault - 98-99
5// Extended NTuples
6//
7#include <string.h>
8#include "ppersist.h"
9#include "perrors.h"
10#include "xntuple.h"
11
12#define LENNAME 31
13#define MAXLEN 128
14#define BADVAL -1.e19
15
16//++
17// Class XNTuple
18// Lib Outils++
19// include xntuple.h
20//
21// Classe de ntuples
22//--
23//++
24// Links Parents
25// PPersist
26// NTupleInterface
27//--
28//++
29// Links Voir aussi
30// NTuple
31//--
32
33
34char* XNTuple::glob_swp = NULL ;
35long int XNTuple::NbNT = 0 ;
36
37#ifdef __MWERKS__
38// mktemp() non connu sur Mac (?) - Dominique Yvon / R. Ansari
39char * mktemp(char * Filename);
40#endif
41
42NTBlk::NTBlk(int ndvar, int nfvar, int nivar, int nsvar, int strsz, int sz)
43 : sw(0), // pas swappe
44 swoff(-1),
45 ddata(NULL), fdata(NULL),
46 idata(NULL), sdata(NULL)
47{
48 if(ndvar) ddata = new double[ndvar*sz] ;
49 if(nfvar) fdata = new float[nfvar*sz] ;
50 if(nivar) idata = new int_4[nivar*sz] ;
51 if(nsvar) sdata = new char[nsvar*(strsz+1)*sz] ;
52}
53
54NTBlk::~NTBlk()
55{
56 free() ;
57}
58
59void NTBlk::free()
60{
61 if(ddata) delete[] ddata ; ddata = NULL ;
62 if(fdata) delete[] fdata ; fdata = NULL ;
63 if(idata) delete[] idata ; idata = NULL ;
64 if(sdata) delete[] sdata ; sdata = NULL ;
65}
66
67//
68// relit bloc ds fichier swap
69// (seulement si bloc n'est plus en memoire)
70//
71void XNTuple::read_blk(NTBlk* blk) const
72{
73 // deja en memoire ?
74 if( !blk->sw ) return ;
75
76 blk->free() ;
77
78 // On va --> blk
79 fseek(swf, blk->swoff, SEEK_SET) ;
80
81 if(mD) {
82 blk->ddata = new double[mD*mBlkSz] ;
83 fread(blk->ddata, sizeof(double), mD*mBlkSz, swf) ;
84 }
85 if(mF) {
86 blk->fdata = new float[mF*mBlkSz] ;
87 fread(blk->fdata, sizeof(float), mF*mBlkSz, swf) ;
88 }
89 if(mI) {
90 blk->idata = new int_4[mI*mBlkSz] ;
91 fread(blk->idata, sizeof(int), mI*mBlkSz, swf) ;
92 }
93 if(mS) {
94 blk->sdata = new char[mS*(mStrSz+1)*mBlkSz] ;
95 fread(blk->sdata, sizeof(char), mS*mBlkSz*(mStrSz+1), swf) ;
96 }
97}
98
99//
100// swappe le bloc present en memoire
101// depuis le + longtemps
102//
103void XNTuple::swap() const
104{
105 // fichier de swap ouvert ?
106 if(!swf) {
107 swf_name = new char[swp.length()+64] ;
108 strncpy(swf_name, swp.c_str(), swp.length()+1) ;
109 strcat(swf_name, "NTupleXXXXXX") ;
110 // swf_name = strdup("NTupleXXXXXX") ;
111 mktemp(swf_name) ;
112 swf = fopen(swf_name, "w+") ;
113 if(!swf) THROW(fileErr) ;
114 }
115
116 // bloc a swapper
117 NTBlk* blk = sw.front() ;
118
119 // bloc dans fichiers de swap ?
120 // if( blk->swoff > 0 )
121 write_blk(blk) ;
122 blk->free() ;
123
124 blk->sw = 1 ; // on marque le bloc swappe
125 sw.pop_front() ; // on le vire de la liste de swap
126 mNSwBlk++ ;
127}
128
129
130//
131// unswap()
132//
133void XNTuple::get_blk(int i) const
134{
135 if(i<0 || i>=mNBlk) return ;
136 read_blk(ptr[i]) ;
137 ptr[i]->sw = 0 ;
138 sw.push_back(ptr[i]) ;
139 mNSwBlk-- ;
140}
141
142
143//
144// ecrit le bloc en bout de fichier
145// (seulement si swoff < 0 )
146//
147void XNTuple::write_blk(NTBlk* blk) const
148{
149 // deja swappe ?
150 if( blk->swoff >= 0 ) return ;
151 fseek(swf, 0, SEEK_END) ;
152 // position debut du bloc
153 blk->swoff = ftell(swf) ;
154 if(blk->ddata) fwrite(blk->ddata, sizeof(double), mD*mBlkSz, swf) ;
155 if(blk->fdata) fwrite(blk->fdata, sizeof(float), mF*mBlkSz, swf) ;
156 if(blk->idata) fwrite(blk->idata, sizeof(int), mI*mBlkSz, swf) ;
157 if(blk->sdata) fwrite(blk->sdata, sizeof(char), mS*mBlkSz*(mStrSz+1), swf) ;
158}
159
160
161void XNTuple::add_blk()
162{
163 // l'ancien bloc en ecriture peut maintenant
164 // etre swappe (s'il existe)
165 if(mBlk>=0) sw.push_back(ptr[mBlk]) ;
166
167 // si pas de place, on swappe
168 if( mNBlk+1 >= mMaxBlk ) swap() ;
169
170 // nouveau bloc
171 NTBlk* tmp = new NTBlk(mD, mF, mI, mS, mStrSz, mBlkSz) ;
172 ptr.push_back(tmp) ;
173
174 // mNBlk++ ;
175 // mOff = 0 ;
176 // mBlk++ ;
177}
178
179
180XNTuple::XNTuple()
181 : mNEnt(0), mNBlk(0), mNSwBlk(0),
182 mBlkSz(0), mBlk(-1), mOff(0),
183 mMaxBlk(0), mStrSz(0),
184 mD(0), mF(0), mI(0), mS(0),
185 mVarD(NULL), mMin(NULL), mMax(NULL),
186 mNVars(0), mNames(NULL),
187 swf(NULL), swf_name(NULL), mInfo(NULL)
188{
189 if(!glob_swp) SetSwapPath("/tmp/") ;
190 swp = glob_swp ;
191 NbNT++ ;
192}
193
194//++
195// Titre Constructeurs
196//--
197//++
198// XNTuple(int ndvar, int nfvar, int nivar, int nsvar, char** vnames, -
199// int blk=512, int maxblk=100, int strsz=30)
200// Constructeur - Création d'un XNTuple de "ndvar" variables de type "double", -
201// "nfvar" de type "float", "nivar" de type "int" et "nsvar" de type -
202// "char*".
203//| * "blk" = taille blocs de données (en nombre d'entrées)
204//| * "maxblk" = nombre max de blocs présents en mémoire (non swappés)
205//| * "strsz" = taille des données de type char*
206// XNTuple(XNTuple const& nt)
207// Constructeur de copie.
208// XNTuple(string const& flnm)
209// Constructeur - lecture à partir d'un fichier PPersist.
210//--
211
212XNTuple::XNTuple(int ndvar, int nfvar, int nivar, int nsvar,
213 char** vnames,
214 int blk, int maxblk, int strsz)
215 : mNEnt(0), mNBlk(0), mNSwBlk(0),
216 mBlkSz(blk), mBlk(-1), mOff(0),
217 mMaxBlk(maxblk), mStrSz(strsz),
218 mD(ndvar), mF(nfvar), mI(nivar), mS(nsvar),
219 mVarD(NULL), mMin(NULL), mMax(NULL),
220 mNVars(ndvar+nfvar+nivar+nsvar), mNames(NULL),
221 swf(NULL), swf_name(NULL), mInfo(NULL)
222{
223 if(!glob_swp) SetSwapPath("/tmp/") ;
224 swp = glob_swp ;
225
226 mVarD = new r_8[mNVars] ;
227 mMin = new r_8[mD+mF+mI] ;
228 int i;
229 for(i = 0 ; i < (mD+mF+mI) ; i++) mMin[i] = 9E19 ;
230 mMax = new r_8[mD+mF+mI] ;
231 for(i = 0 ; i < (mD+mF+mI) ; i++) mMax[i] = -9E19 ;
232
233 if(mNVars) mNames = new char[mNVars*(LENNAME+1)] ;
234 memset(mNames, 0, mNVars*(LENNAME+1));
235 for(i = 0 ; i < mNVars ; i++)
236 strncpy(mNames+i*(LENNAME+1), vnames[i], LENNAME);
237
238 NbNT++ ;
239}
240
241
242
243XNTuple::XNTuple(string const& flnm)
244 : mNEnt(0), mNBlk(0), mNSwBlk(0),
245 mBlkSz(0), mBlk(-1), mOff(0),
246 mMaxBlk(0), mStrSz(0),
247 mD(0), mF(0), mI(0), mS(0),
248 mVarD(NULL), mMin(NULL), mMax(NULL),
249 mNVars(0), mNames(NULL),
250 swf(NULL), swf_name(NULL), mInfo(NULL)
251{
252 if(!glob_swp) SetSwapPath("/tmp/") ;
253 swp = glob_swp ;
254
255 PInPersist s(flnm);
256 ObjFileIO<XNTuple> fiont(this);
257 fiont.Read(s);
258 NbNT++ ;
259}
260
261
262XNTuple::XNTuple(XNTuple const& nt)
263 : mNEnt(0), mNBlk(0), mNSwBlk(0),
264 mBlkSz(0), mBlk(-1), mOff(0),
265 mMaxBlk(0), mStrSz(0),
266 mD(0), mF(0), mI(0), mS(0),
267 mVarD(NULL), mMin(NULL), mMax(NULL),
268 mNVars(0), mNames(NULL),
269 swf(NULL), swf_name(NULL), mInfo(NULL)
270{
271 if(!glob_swp) SetSwapPath("/tmp/") ;
272 swp = glob_swp ;
273 Copy(nt) ;
274 NbNT++ ;
275}
276
277
278
279XNTuple::~XNTuple()
280{
281 clean() ;
282 NbNT-- ;
283 if(NbNT==0) delete[] glob_swp ;
284}
285
286
287
288void XNTuple::clean()
289{
290 // On libere tous les blocs
291 for(int i = 0 ; i < mNBlk ; i++)
292 if(!ptr[i]->sw) delete ptr[i] ;
293 ptr.erase(ptr.begin(), ptr.end()) ;
294 sw.erase(sw.begin(), sw.end()) ;
295
296 // on ferme le fichier de swap
297 if(swf) fclose(swf) ; swf = NULL ;
298 remove(swf_name) ;
299 delete swf_name ; swf_name = NULL ;
300
301 // tout le monde remis a 0
302 mNEnt = 0 ; mNBlk = 0 ;
303 mNSwBlk = 0 ; mBlkSz = 0 ;
304 mBlk = -1 ; mOff = 0 ;
305 mMaxBlk = 0 ; mStrSz = 0 ;
306 mD = 0 ; mF = 0 ;
307 mI = 0 ; mS = 0 ;
308 mNVars = 0 ;
309
310
311 if(mVarD) { delete[] mVarD ; mVarD = NULL ; }
312 if(mMin) { delete[] mMin ; mMin = NULL ; }
313 if(mMax) { delete[] mMax ; mMax = NULL ; }
314
315 if(mNames) {delete[] mNames ; mNames = NULL ; }
316 if (mInfo) delete mInfo;
317
318}
319
320
321//++
322// Titre Méthodes
323//--
324//++
325// void Fill(double* d_data, float* f_data, int* i_data, char** s_data)
326// Remplissage d'une ligne dans le NTuple
327// void Show(ostream& os) const
328// Impression de la liste des variables avec min-max sur le flot "oß
329// void Show() const
330// Identique à "Show(cout)"
331// XNTuple& operator = (XNTuple const& nt)
332// Opérateur égal (=) , copie "nt" dans le premier NTuple
333//--
334void XNTuple::Fill(double* d_data, float* f_data, long* i_data, char** s_data)
335{
336 // place disponible dans bloc courant ?
337 if( mOff==mBlkSz || mOff==0 ) {
338 add_blk() ; mOff = 0 ; mNBlk++ ; mBlk++ ;
339 }
340
341 if( mD && !ptr[mBlk]->ddata ||
342 mF && !ptr[mBlk]->fdata ||
343 mI && !ptr[mBlk]->idata ||
344 mS && !ptr[mBlk]->sdata )
345 THROW(parmErr) ;
346
347 double x ;
348 // copie variables et update mMin, mMax
349 if(mD) {
350 memcpy(ptr[mBlk]->ddata+mOff*mD, d_data, mD*sizeof(double)) ;
351 for(int i = 0 ; i < mD ; i++) {
352 x = d_data[i] ;
353 if(x<mMin[i]) mMin[i] = x ;
354 if(x>mMax[i]) mMax[i] = x ;
355 }
356 }
357
358 if(mF) {
359 memcpy(ptr[mBlk]->fdata+mOff*mF, f_data, mF*sizeof(float)) ;
360 for(int i = 0 ; i < mF ; i++) {
361 x = f_data[i] ;
362 if(x<mMin[i+mD]) mMin[i+mD] = x ;
363 if(x>mMax[i+mD]) mMax[i+mD] = x ;
364 }
365 }
366
367 if(mI) {
368 memcpy(ptr[mBlk]->idata+mOff*mI, i_data, mI*sizeof(long)) ;
369 for(int i = 0 ; i < mI ; i++) {
370 x = i_data[i] ;
371 if(x<mMin[i+mD+mF]) mMin[i+mD+mF] = x ;
372 if(x>mMax[i+mD+mF]) mMax[i+mD+mF] = x ;
373 }
374 }
375 for(int i = 0 ; i < mS ; i++)
376 memcpy(ptr[mBlk]->sdata+(mOff*mS+i)*(mStrSz+1),
377 s_data[i], (strlen(s_data[i])+1)*sizeof(char)) ;
378 mOff++ ;
379 mNEnt++ ;
380}
381
382//
383// A quel index correspond mon nom ?
384//
385int XNTuple::IndexNom(char const* nom) const
386{
387 int i ;
388 for(i = 0 ; i < (mD+mF+mI+mS) ; i++)
389 if( !strncmp( mNames+i*(LENNAME+1), nom, LENNAME+1) )
390 return i ;
391 return -1 ;
392}
393
394string XNTuple::NomIndex(int k) const
395{
396 if( k<0 || k>=mNVars ) return "" ;
397 return mNames + k*(LENNAME+1) ;
398}
399
400
401//
402//
403//
404double XNTuple::GetDVal(int i, int k) const
405{
406 if( i<0 || i>=mNEnt || k<0 || k>=mD )
407 THROW(rangeCheckErr) ;
408
409 // Bloc ?
410 int blk = (int)(i/mBlkSz) ;
411 int off = i%mBlkSz ;
412
413 // bloc swappe ?
414 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
415 return ptr[blk]->ddata[off*mD+k] ;
416}
417
418//
419//
420//
421float XNTuple::GetFVal(int i, int k) const
422{
423 if( i<0 || i>=mNEnt || k<mD || k>=(mD+mF) )
424 THROW(rangeCheckErr) ;
425 k -= mD ;
426
427 // Bloc ?
428 int blk = (int)(i/mBlkSz) ;
429 int off = i%mBlkSz ;
430
431 // bloc swappe ?
432 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
433 return ptr[blk]->fdata[off*mF+k] ;
434}
435
436//
437//
438//
439long XNTuple::GetIVal(int i, int k) const
440{
441 if( i<0 || i>=mNEnt || k<(mD+mF) || k>=(mD+mF+mI) )
442 THROW(rangeCheckErr) ;
443 k -= (mD+mF) ;
444
445 // Bloc ?
446 int blk = (int)(i/mBlkSz) ;
447 int off = i%mBlkSz ;
448
449 // bloc swappe ?
450 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
451
452 return ptr[blk]->idata[off*mI+k] ;
453}
454
455//
456//
457//
458string XNTuple::GetSVal(int i, int k) const
459{
460 if( i<0 || i>=mNEnt || k<(mD+mF+mI) || k>=(mD+mF+mI+mS) )
461 THROW(rangeCheckErr) ;
462 k -= (mD+mF+mI) ;
463
464 // Bloc ?
465 int blk = (int)(i/mBlkSz) ;
466 int off = i%mBlkSz ;
467
468 // bloc swappe ?
469 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
470
471 // copie de la chaine
472 // string ret = strdup(ptr[blk]->sdata + (off*mS+k)*(mStrSz+1)) ; // $CHECK$ EA fuite de memoire
473 // attention, strdup fait un malloc et on ne fait jamais de free...
474 // a quoi sert ce strdup ?????????
475 string ret = ptr[blk]->sdata + (off*mS+k)*(mStrSz+1) ;
476 // return ptr[blk]->sdata[k] ;
477 return ret ;
478}
479
480
481//
482// Copie bloc a bloc, avec meme parametres
483//
484void XNTuple::Copy(XNTuple const& nt)
485{
486 clean() ;
487 // Parametres
488 mNEnt = nt.mNEnt ;
489 mBlkSz = nt.mBlkSz ;
490 mOff = nt.mOff ;
491 mMaxBlk = nt.mMaxBlk ;
492 mStrSz = nt.mStrSz ;
493 mD = nt.mD ;
494 mF = nt.mF ;
495 mI = nt.mI ;
496 mS = nt.mS ;
497 mNVars = nt.mNVars ;
498
499 // noms
500 if(mNVars) {
501 mNames = new char[mNVars*(LENNAME+1)] ;
502 mVarD = new double[mNVars];
503 memcpy(mNames, nt.mNames, mNVars*(LENNAME+1)*sizeof(char)) ;
504 }
505 // MinMax
506 if(nt.mMin) {
507 mMin = new double[(mD+mF+mI)] ;
508 memcpy(mMin, nt.mMin, (mD+mF+mI)*sizeof(double)) ;
509 }
510 if(nt.mMax) {
511 mMax = new double[(mD+mF+mI)] ;
512 memcpy(mMax, nt.mMax, (mD+mF+mI)*sizeof(double)) ;
513 }
514
515 //dup blocs
516 mNBlk = 0 ;
517 mBlk = -1 ;
518 for(int i = 0 ; i < nt.mNBlk ; i++) {
519 add_blk() ; mBlk++ ; mNBlk++ ;
520 // si nt.ptr[i] swappe, on le relit
521 if(nt.ptr[i]->sw) nt.read_blk(nt.ptr[i]) ;
522 if(mD)
523 memcpy(ptr[i]->ddata, nt.ptr[i]->ddata, mD*mBlkSz*sizeof(double)) ;
524 if(mF)
525 memcpy(ptr[i]->fdata, nt.ptr[i]->fdata, mF*mBlkSz*sizeof(float)) ;
526 if(mI)
527 memcpy(ptr[i]->idata, nt.ptr[i]->idata, mF*mBlkSz*sizeof(int)) ;
528 if(mS)
529 memcpy(ptr[i]->sdata, nt.ptr[i]->sdata, mS*mBlkSz*sizeof(char)*(mStrSz+1)) ;
530 if(nt.ptr[i]->sw) nt.ptr[i]->free() ;
531 }
532
533 // DVList Info block
534 if(nt.mInfo!=NULL) {mInfo = new DVList; *mInfo = *(nt.mInfo);}
535
536}
537
538//++
539// DVList& Info()
540// Renvoie une référence sur l'objet DVList Associé
541//--
542
543DVList& XNTuple::Info()
544{
545 if (mInfo == NULL) mInfo = new DVList;
546 return(*mInfo);
547}
548
549void XNTuple::Print(int num, int nmax) const
550{
551 printf("XNTuple::Print() : \n") ;
552 printf(" Entrees = %d, Blocs = %d, Bloc Size = %d\n",
553 mNEnt, mNBlk, mBlkSz) ;
554 int i,j;
555 printf(" D_Vars = %d : ", mD) ;
556 for(i = 0 ; i < mD ; i++)
557 printf("%s ", NomIndex(i).c_str() ) ;
558 printf("\n") ;
559
560 printf(" F_Vars = %d : ", mF) ;
561 for(i = 0 ; i < mF ; i++)
562 printf("%s ", NomIndex(i+mD).c_str() ) ;
563 printf("\n") ;
564
565 printf(" I_Vars = %d : ", mI) ;
566 for(i = 0 ; i < mI ; i++)
567 printf("%s ", NomIndex(i+mD+mF).c_str() ) ;
568 printf("\n") ;
569
570 printf(" S_Vars = %d : ", mS) ;
571 for(i = 0 ; i < mS ; i++)
572 printf("%s ", NomIndex(i+mD+mF+mI).c_str() ) ;
573 printf("\n") ;
574
575 for(i = num ; i < num+nmax ; i++) {
576 for(j = 0 ; j < mD ; j++) printf("%f ", GetDVal(i,j)) ;
577 printf(" -- ") ;
578 for(j = 0 ; j < mF ; j++) printf("%f ", GetFVal(i,j+mD)) ;
579 printf(" -- ") ;
580 for(j = 0 ; j < mI ; j++) printf("%d ", GetIVal(i,j+mD+mF)) ;
581 printf(" -- ") ;
582 for(j = 0 ; j < mS ; j++) printf("%s ", GetSVal(i,j+mD+mF+mI).c_str()) ;
583 printf("\n") ;
584 }
585}
586
587
588void XNTuple::Show(ostream& os) const
589{
590 os << "XNTuple: NVar= " << mNVars << " NEnt= " << mNEnt
591 << " (BlkSz,NBlk= " << mBlkSz << ", " << mNBlk << ")"
592 << " (mNSwBlk= " << mNSwBlk << ")" << endl ;
593 os << "(Sw File= " ; if(swf_name) os << swf_name ; os << ")" << endl ;
594
595 char* buff = new char[80] ;
596 sprintf(buff, "Variables : Type Min Max \n") ;
597 os << buff ;
598
599 double min, max ;
600 int i;
601 for(i = 0 ; i < mD ; i++) {
602 GetMinMax(i, min, max) ;
603 sprintf(buff, " %-10s: D %12.6g %12.6g \n",
604 NomIndex(i).c_str(), min, max) ;
605 os << buff ;
606 }
607 for(i = 0 ; i < mF ; i++) {
608 GetMinMax(i+mD, min, max) ;
609 sprintf(buff, " %-10s: F %12.6g %12.6g \n",
610 NomIndex(i+mD).c_str(), min, max) ;
611 os << buff ;
612 }
613 for(i = 0 ; i < mI ; i++) {
614 GetMinMax(i+mD+mF, min, max) ;
615 sprintf(buff, " %-10s: I %12.6g %12.6g \n",
616 NomIndex(i+mD+mF).c_str(), min, max) ;
617 os << buff ;
618 }
619 for(i = 0 ; i < mS ; i++) {
620 sprintf(buff, " %-10s: S ----- ----- \n",
621 NomIndex(i+mD+mF+mI).c_str()) ;
622 os << buff ;
623 }
624 delete[] buff ;
625}
626
627int XNTuple::FillFromASCIIFile(string const& fn, double ddval, float dfval,
628 int dival, const char * dsval)
629// Remplit le ntuple a partir d'un fichier ASCII.
630// Renvoie le nombre de lignes ajoutees.
631{
632// a faire
633return(0);
634}
635
636
637void XNTuple::SetSwapPath(char* p)
638{
639 if(!glob_swp) glob_swp = new char[MAXLEN+1] ;
640 strncpy(glob_swp, p, MAXLEN) ;
641}
642
643//
644//
645// Interface NTuple
646//
647//
648uint_4 XNTuple::NbLines() const
649{
650 return(NEntry());
651}
652
653uint_4 XNTuple::NbColumns() const
654{
655 return(NVar());
656}
657
658r_8* XNTuple::GetLineD(int n) const
659{
660 // memcpy() impossible
661 // il faut faire des GetVal
662 int i;
663 for(i = 0 ; i < mD ; i++)
664 mVarD[i] = GetDVal(n, i) ;
665 for(i = 0 ; i < mF ; i++)
666 mVarD[i+mD] = (double)GetFVal(n, i+mD) ;
667 for(i = 0 ; i < mI ; i++)
668 mVarD[i+mD+mF] = (double)GetIVal(n, i+mD+mF) ;
669 for(i = 0 ; i < mS ; i++)
670 mVarD[i+mD+mF+mI] = atof(GetSVal(n, i+mD+mF+mI).c_str()) ;
671 return mVarD ;
672}
673
674
675r_8 XNTuple::GetCell(int n, int k) const
676{
677 if( k<0 || k>=(mD+mF+mI+mS) ) return BADVAL ;
678 if(k<mD) return GetDVal(n,k) ;
679 if(k<(mF+mD)) return GetFVal(n,k) ;
680 if(k<(mF+mD+mI)) return GetIVal(n,k) ;
681 if(k<(mD+mF+mI+mS)) return atof(GetSVal(n,k).c_str()) ;
682 return BADVAL ;
683}
684
685
686r_8 XNTuple::GetCell(int n, string const& nom) const
687{
688 int k = IndexNom(nom.c_str()) ;
689 if(k<0) return BADVAL ;
690 if(k<mD) return GetDVal(n,k) ;
691 if(k<(mF+mD)) return GetFVal(n,k) ;
692 if(k<(mF+mD+mI)) return GetIVal(n,k) ;
693 if(k<(mD+mF+mI+mS)) return atof(GetSVal(n,k).c_str()) ;
694 return BADVAL ;
695}
696
697string XNTuple::GetCelltoString(int n, int k) const
698{
699 char buff[32];
700 if(k<0) return ("");
701 else if(k<mD)
702 { sprintf(buff, "%g", GetDVal(n,k)); return(buff) ; }
703 else if(k<(mF+mD))
704 { sprintf(buff, "%g", (double)GetFVal(n,k)); return(buff) ; }
705 else if(k<(mF+mD+mI))
706 { sprintf(buff, "%d", GetIVal(n,k)); return(buff) ; }
707 else if(k<(mD+mF+mI+mS))
708 return(GetSVal(n,k).c_str()) ;
709 return("");
710}
711
712void XNTuple::GetMinMax(int k, double& min, double& max) const
713{
714 min = 9E19 ; max = -9E19 ;
715 // variables string non traitees
716 if( k<0 || k>=(mD+mF+mI) ) return ;
717
718 min = mMin[k] ;
719 max = mMax[k] ;
720 return ;
721}
722
723
724void XNTuple::GetMinMax(string const & nom, double& min, double& max) const
725{
726 GetMinMax(IndexNom(nom.c_str()), min, max) ;
727}
728
729
730int XNTuple::ColumnIndex(string const& nom) const
731{
732 return IndexNom(nom.c_str()) ;
733}
734
735
736string XNTuple::ColumnName(int k) const
737{
738 return NomIndex(k) ;
739}
740
741
742string XNTuple::VarList_C(const char* nomx) const
743{
744 string rets = "" ;
745 rets += "/* double type variables */ \n";
746 // variables double
747 int i;
748 for(i = 0 ; i < mD ; i++) {
749 if( i>0 && (i%5)==0 ) rets += ";" ;
750 if( (i%5)==0 ) rets+="\ndouble " ;
751 else rets += ", " ;
752 rets += NomIndex(i) ;
753 }
754 if(mD) rets += ";" ;
755
756 // variables float
757 rets += "/* float type variables */ \n";
758 for(i = 0 ; i < mF ; i++) {
759 if( i>0 && (i%5)==0 ) rets += ";" ;
760 if( (i%5)==0 ) rets+="\ndouble " ;
761 else rets += ", " ;
762 rets += NomIndex(i+mD) ;
763 }
764 if(mF) rets += ";" ;
765
766 // variables int
767 rets += "/* int type variables */ \n";
768 for(i = 0 ; i < mI ; i++) {
769 if( i>0 && (i%5)==0 ) rets += ";" ;
770 if( (i%5)==0 ) rets+="\ndouble " ;
771 else rets += ", " ;
772 rets += NomIndex(i+mD+mF) ;
773 }
774 if(mI) rets += ";" ;
775
776 // variables string
777 rets += "/* string type variables */ \n";
778 for(i = 0 ; i < mS ; i++) {
779 if( i>0 && (i%5)==0 ) rets += ";" ;
780 if( (i%5)==0 ) rets+="\ndouble " ;
781 else rets += ", " ;
782 rets += NomIndex(i+mD+mF+mI) ;
783 }
784 rets += "; \n" ;
785
786 if(nomx) {
787 char buff[256] ;
788 for(i = 0 ; i < mNVars ; i++) {
789 sprintf(buff, "%s=%s[%d]; ", NomIndex(i).c_str(), nomx, i) ;
790 rets+=buff ;
791 if( (i%3 == 0) && (i>0) ) rets += "\n" ;
792 }
793 }
794 return rets ;
795}
796
797
798string XNTuple::LineHeaderToString() const
799{
800 char buff[32];
801 string rets=" Num ";
802 for(int i=0; i<mNVars; i++) {
803 sprintf(buff, "%8s ", NomIndex(i).c_str() );
804 rets += buff;
805 }
806 rets += '\n';
807 return(rets);
808
809}
810
811
812string XNTuple::LineToString(int n) const
813{
814 char buff[32];
815 double* val;
816 val = GetLineD(n);
817 sprintf(buff,"%6d: ",n);
818 string rets=buff;
819 int i;
820 for(i=0; i<(mD+mF+mI); i++) {
821 sprintf(buff, "%8.3g ", val[i]);
822 rets += buff;
823 }
824
825 for(i = mD+mF+mI ; i < mNVars ; i++) {
826 sprintf(buff, "%8s ", GetSVal(n,i).c_str() ) ;
827 rets += buff ;
828 }
829
830 rets += '\n';
831 return(rets);
832}
833
834
835void ObjFileIO<XNTuple>::WriteSelf(POutPersist& ppout) const
836{
837 if (dobj == NULL) return;
838// On ecrit 3 uint_4 ....
839// 0: Numero de version, 1 : non nul -> has info, 2 : reserve
840 uint_4 itab[3];
841 itab[0] = 1; // Numero de version a 1
842 itab[1] = itab[2] = 0;
843 if (dobj->mInfo) itab[1] = 1;
844 ppout.Put(itab,3);
845 if (dobj->mInfo) if (dobj->mInfo) ppout << (*(dobj->mInfo));
846
847 // variables internes
848 ppout.PutI4(dobj->mNEnt) ;
849 ppout.PutI4(dobj->mNBlk) ;
850 ppout.PutI4(dobj->mBlkSz) ;
851 ppout.PutI4(dobj->mBlk) ;
852 ppout.PutI4(dobj->mOff) ;
853 ppout.PutI4(dobj->mMaxBlk) ;
854 ppout.PutI4(dobj->mStrSz) ;
855 ppout.PutI4(dobj->mD) ;
856 ppout.PutI4(dobj->mF) ;
857 ppout.PutI4(dobj->mI) ;
858 ppout.PutI4(dobj->mS) ;
859 ppout.PutI4(dobj->mNVars) ;
860
861 // Noms
862 ppout.PutBytes(dobj->mNames, dobj->mNVars*(LENNAME+1)) ;
863
864 // MinMax
865 ppout.PutR8s(dobj->mMin, (dobj->mD+dobj->mF+dobj->mI)) ;
866 ppout.PutR8s(dobj->mMax, (dobj->mD+dobj->mF+dobj->mI)) ;
867
868 // Ecriture blocs N'ecrire que si datas existent
869 for(int i = 0 ; i < dobj->mNBlk ; i++) {
870 // si bloc swappe, on le relit en douce ...
871 if( dobj->ptr[i]->sw ) dobj->read_blk(dobj->ptr[i]) ;
872 ppout.PutR8s(dobj->ptr[i]->ddata, dobj->mD*dobj->mBlkSz) ;
873 ppout.PutR4s(dobj->ptr[i]->fdata, dobj->mF*dobj->mBlkSz) ;
874 ppout.PutI4s(dobj->ptr[i]->idata, dobj->mI*dobj->mBlkSz) ;
875 ppout.PutBytes(dobj->ptr[i]->sdata, dobj->mS*dobj->mBlkSz*(dobj->mStrSz+1)) ;
876 if(dobj->ptr[i]->sw) dobj->ptr[i]->free() ;
877 }
878}
879
880
881void ObjFileIO<XNTuple>::ReadSelf(PInPersist& ppin)
882{
883 if (dobj == NULL) dobj = new XNTuple;
884 else dobj->clean() ;
885// On lit 3 uint_4 ....
886// 0: Numero de version, 1 : non nul -> has info, 2 : reserve
887 uint_4 itab[3];
888 ppin.Get(itab,3);
889 if (itab[1] != 0) { // Lecture eventuelle du DVList Info
890 if (dobj->mInfo == NULL) dobj->mInfo = new DVList;
891 ppin >> (*(dobj->mInfo));
892 }
893
894 ppin.GetI4(dobj->mNEnt) ;
895 ppin.GetI4(dobj->mNBlk) ;
896 ppin.GetI4(dobj->mBlkSz) ;
897 ppin.GetI4(dobj->mBlk) ;
898 ppin.GetI4(dobj->mOff) ;
899 ppin.GetI4(dobj->mMaxBlk) ;
900 ppin.GetI4(dobj->mStrSz) ;
901 ppin.GetI4(dobj->mD) ;
902 ppin.GetI4(dobj->mF) ;
903 ppin.GetI4(dobj->mI) ;
904 ppin.GetI4(dobj->mS) ;
905 ppin.GetI4(dobj->mNVars) ;
906
907 // Noms
908 dobj->mNames = new char[dobj->mNVars*(LENNAME+1)] ;
909 dobj->mVarD = new double[dobj->mNVars];
910 ppin.GetBytes(dobj->mNames, dobj->mNVars*(LENNAME+1)) ;
911
912 // MinMax
913 dobj->mMin = new r_8[dobj->mD+dobj->mF+dobj->mI] ;
914 ppin.GetR8s(dobj->mMin, dobj->mD+dobj->mF+dobj->mI) ;
915 dobj->mMax = new r_8[dobj->mD+dobj->mF+dobj->mI] ;
916 ppin.GetR8s(dobj->mMax, dobj->mD+dobj->mF+dobj->mI) ;
917
918 // lecture Blocs
919 int nblk = dobj->mNBlk ;
920 dobj->mBlk = -1 ; dobj->mNBlk = 0 ;
921 for(int i = 0 ; i < nblk ; i++) {
922 dobj->add_blk() ; dobj->mBlk++ ; dobj->mNBlk++ ;
923 ppin.GetR8s(dobj->ptr[i]->ddata, dobj->mD*dobj->mBlkSz) ;
924 ppin.GetR4s(dobj->ptr[i]->fdata, dobj->mF*dobj->mBlkSz) ;
925 ppin.GetI4s(dobj->ptr[i]->idata, dobj->mI*dobj->mBlkSz) ;
926 ppin.GetBytes(dobj->ptr[i]->sdata, dobj->mS*dobj->mBlkSz*(dobj->mStrSz+1)) ;
927 }
928}
929////////////// methodes supplementaires pour leserveur de fichiers fits//////
930//
931// (protected)
932//
933void XNTuple::SetDVal(int i, int k, double v)
934{
935 if( i<0 || i>=mNEnt || k<0 || k>=mD )
936 THROW(rangeCheckErr) ;
937
938 // Bloc ?
939 int blk = (int)(i/mBlkSz) ;
940 int off = i%mBlkSz ;
941
942 // bloc swappe ?
943 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
944 ptr[blk]->ddata[off*mD+k]=v ;
945}
946void XNTuple::SetFVal(int i, int k, float v)
947{
948 if( i<0 || i>=mNEnt || k<mD || k>=(mD+mF) )
949 THROW(rangeCheckErr) ;
950 k -= mD ;
951
952 // Bloc ?
953 int blk = (int)(i/mBlkSz) ;
954 int off = i%mBlkSz ;
955
956 // bloc swappe ?
957 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
958 ptr[blk]->fdata[off*mF+k]=v ;
959}
960void XNTuple::SetIVal(int i, int k, int v)
961{
962 if( i<0 || i>=mNEnt || k<(mD+mF) || k>=(mD+mF+mI) )
963 THROW(rangeCheckErr) ;
964 k -= (mD+mF) ;
965
966 // Bloc ?
967 int blk = (int)(i/mBlkSz) ;
968 int off = i%mBlkSz ;
969
970 // bloc swappe ?
971 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
972
973 ptr[blk]->idata[off*mI+k]=v ;
974}
975void XNTuple::SetSVal(int i, int k, char* v)
976{
977 if( i<0 || i>=mNEnt || k<(mD+mF+mI) || k>=(mD+mF+mI+mS) )
978 THROW(rangeCheckErr) ;
979 k -= (mD+mF+mI) ;
980
981 // Bloc ?
982 int blk = (int)(i/mBlkSz) ;
983 int off = i%mBlkSz ;
984
985 // bloc swappe ?
986 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
987
988 // copie de la chaine
989 strncpy(ptr[blk]->sdata + (off*mS+k)*(mStrSz+1),v, mStrSz+1) ;
990}
991
992
993
994
995
996
997#ifdef __CXX_PRAGMA_TEMPLATES__
998#pragma define_template ObjFileIO<XNTuple>
999#endif
1000
1001#if defined(ANSI_TEMPLATES) || defined(GNU_TEMPLATES)
1002template class ObjFileIO<XNTuple>;
1003#endif
1004
1005
1006#ifdef __MWERKS__
1007// Bricolo Dominique Yvon pour faire marcher sur Mac
1008#include <stdio.h>
1009#include <stdlib.h>
1010 static long mktempMemory=0;
1011 char * mktemp(char * Filename)
1012 { sprintf(Filename,"TempFile%8i",mktempMemory);
1013 mktempMemory++;
1014 return Filename;
1015 }
1016#endif
Note: See TracBrowser for help on using the repository browser.