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

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

bug ds xntuple.cc , petites correction ds virtual Histo/HProf::UpdateHisto() - Reza 23/8/2000
File size: 23.4 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 r_8[ndvar*sz] ;
49 if(nfvar) fdata = new r_4[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 r_8[mD*mBlkSz] ;
83 fread(blk->ddata, sizeof(r_8), mD*mBlkSz, swf) ;
84 }
85 if(mF) {
86 blk->fdata = new r_4[mF*mBlkSz] ;
87 fread(blk->fdata, sizeof(r_4), mF*mBlkSz, swf) ;
88 }
89 if(mI) {
90 blk->idata = new int_4[mI*mBlkSz] ;
91 fread(blk->idata, sizeof(int_4), 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 IOExc("XNTuple::swap() - Error opening swap File");
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(r_8), mD*mBlkSz, swf) ;
155 if(blk->fdata) fwrite(blk->fdata, sizeof(r_4), mF*mBlkSz, swf) ;
156 if(blk->idata) fwrite(blk->idata, sizeof(int_4), 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 "r_8", -
201// "nfvar" de type "r_4", "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) {
298 fclose(swf) ; swf = NULL ;
299 remove(swf_name) ;
300 delete swf_name ; swf_name = NULL ;
301 }
302 // tout le monde remis a 0
303 mNEnt = 0 ; mNBlk = 0 ;
304 mNSwBlk = 0 ; mBlkSz = 0 ;
305 mBlk = -1 ; mOff = 0 ;
306 mMaxBlk = 0 ; mStrSz = 0 ;
307 mD = 0 ; mF = 0 ;
308 mI = 0 ; mS = 0 ;
309 mNVars = 0 ;
310
311
312 if(mVarD) { delete[] mVarD ; mVarD = NULL ; }
313 if(mMin) { delete[] mMin ; mMin = NULL ; }
314 if(mMax) { delete[] mMax ; mMax = NULL ; }
315
316 if(mNames) {delete[] mNames ; mNames = NULL ; }
317 if (mInfo) delete mInfo;
318
319}
320
321
322//++
323// Titre Méthodes
324//--
325//++
326// void Fill(r_8* d_data, r_4* f_data, int* i_data, char** s_data)
327// Remplissage d'une ligne dans le NTuple
328// void Show(ostream& os) const
329// Impression de la liste des variables avec min-max sur le flot "os"
330// void Show() const
331// Identique à "Show(cout)"
332// XNTuple& operator = (XNTuple const& nt)
333// Opérateur égal (=) , copie "nt" dans le premier NTuple
334//--
335void XNTuple::Fill(r_8* d_data, r_4* f_data, int_4* i_data, char** s_data)
336{
337 // place disponible dans bloc courant ?
338 if( mOff==mBlkSz || mOff==0 ) {
339 add_blk() ; mOff = 0 ; mNBlk++ ; mBlk++ ;
340 }
341
342 if( mD && !ptr[mBlk]->ddata ||
343 mF && !ptr[mBlk]->fdata ||
344 mI && !ptr[mBlk]->idata ||
345 mS && !ptr[mBlk]->sdata )
346 throw ParmError("XNTuple::Fill(...) Missing (NULL) argument ");
347
348 r_8 x ;
349 // copie variables et update mMin, mMax
350 if(mD) {
351 memcpy(ptr[mBlk]->ddata+mOff*mD, d_data, mD*sizeof(r_8)) ;
352 for(int i = 0 ; i < mD ; i++) {
353 x = d_data[i] ;
354 if(x<mMin[i]) mMin[i] = x ;
355 if(x>mMax[i]) mMax[i] = x ;
356 }
357 }
358
359 if(mF) {
360 memcpy(ptr[mBlk]->fdata+mOff*mF, f_data, mF*sizeof(r_4)) ;
361 for(int i = 0 ; i < mF ; i++) {
362 x = f_data[i] ;
363 if(x<mMin[i+mD]) mMin[i+mD] = x ;
364 if(x>mMax[i+mD]) mMax[i+mD] = x ;
365 }
366 }
367
368 if(mI) {
369 memcpy(ptr[mBlk]->idata+mOff*mI, i_data, mI*sizeof(int_4)) ;
370 for(int i = 0 ; i < mI ; i++) {
371 x = i_data[i] ;
372 if(x<mMin[i+mD+mF]) mMin[i+mD+mF] = x ;
373 if(x>mMax[i+mD+mF]) mMax[i+mD+mF] = x ;
374 }
375 }
376 for(int i = 0 ; i < mS ; i++)
377 memcpy(ptr[mBlk]->sdata+(mOff*mS+i)*(mStrSz+1),
378 s_data[i], (strlen(s_data[i])+1)*sizeof(char)) ;
379 mOff++ ;
380 mNEnt++ ;
381}
382
383//
384// A quel index correspond mon nom ?
385//
386int XNTuple::IndexNom(char const* nom) const
387{
388 int i ;
389 for(i = 0 ; i < (mD+mF+mI+mS) ; i++)
390 if( !strncmp( mNames+i*(LENNAME+1), nom, LENNAME+1) )
391 return i ;
392 return -1 ;
393}
394
395string XNTuple::NomIndex(int k) const
396{
397 if( k<0 || k>=mNVars ) return "" ;
398 return mNames + k*(LENNAME+1) ;
399}
400
401
402//
403//
404//
405r_8 XNTuple::GetDVal(int i, int k) const
406{
407 if( i<0 || i>=mNEnt || k<0 || k>=mD )
408 throw RangeCheckError("XNTuple::GetDVal() Invalid line/column index");
409
410 // Bloc ?
411 int blk = (int)(i/mBlkSz) ;
412 int off = i%mBlkSz ;
413
414 // bloc swappe ?
415 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
416 return ptr[blk]->ddata[off*mD+k] ;
417}
418
419//
420//
421//
422r_4 XNTuple::GetFVal(int i, int k) const
423{
424 if( i<0 || i>=mNEnt || k<mD || k>=(mD+mF) )
425 throw RangeCheckError("XNTuple::GetFVal() Invalid line/column index");
426 k -= mD ;
427
428 // Bloc ?
429 int blk = (int)(i/mBlkSz) ;
430 int off = i%mBlkSz ;
431
432 // bloc swappe ?
433 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
434 return ptr[blk]->fdata[off*mF+k] ;
435}
436
437//
438//
439//
440int_4 XNTuple::GetIVal(int i, int k) const
441{
442 if( i<0 || i>=mNEnt || k<(mD+mF) || k>=(mD+mF+mI) )
443 throw RangeCheckError("XNTuple::GetIVal() Invalid line/column index");
444
445 k -= (mD+mF) ;
446
447 // Bloc ?
448 int blk = (int)(i/mBlkSz) ;
449 int off = i%mBlkSz ;
450
451 // bloc swappe ?
452 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
453
454 return ptr[blk]->idata[off*mI+k] ;
455}
456
457//
458//
459//
460string XNTuple::GetSVal(int i, int k) const
461{
462 if( i<0 || i>=mNEnt || k<(mD+mF+mI) || k>=(mD+mF+mI+mS) )
463 throw RangeCheckError("XNTuple::GetSVal() Invalid line/column index");
464
465 k -= (mD+mF+mI) ;
466
467 // Bloc ?
468 int blk = (int)(i/mBlkSz) ;
469 int off = i%mBlkSz ;
470
471 // bloc swappe ?
472 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
473
474 // copie de la chaine
475 // string ret = strdup(ptr[blk]->sdata + (off*mS+k)*(mStrSz+1)) ; // $CHECK$ EA fuite de memoire
476 // attention, strdup fait un malloc et on ne fait jamais de free...
477 // a quoi sert ce strdup ?????????
478 string ret = ptr[blk]->sdata + (off*mS+k)*(mStrSz+1) ;
479 // return ptr[blk]->sdata[k] ;
480 return ret ;
481}
482
483
484//
485// Copie bloc a bloc, avec meme parametres
486//
487void XNTuple::Copy(XNTuple const& nt)
488{
489 clean() ;
490 // Parametres
491 mNEnt = nt.mNEnt ;
492 mBlkSz = nt.mBlkSz ;
493 mOff = nt.mOff ;
494 mMaxBlk = nt.mMaxBlk ;
495 mStrSz = nt.mStrSz ;
496 mD = nt.mD ;
497 mF = nt.mF ;
498 mI = nt.mI ;
499 mS = nt.mS ;
500 mNVars = nt.mNVars ;
501
502 // noms
503 if(mNVars) {
504 mNames = new char[mNVars*(LENNAME+1)] ;
505 mVarD = new r_8[mNVars];
506 memcpy(mNames, nt.mNames, mNVars*(LENNAME+1)*sizeof(char)) ;
507 }
508 // MinMax
509 if(nt.mMin) {
510 mMin = new r_8[(mD+mF+mI)] ;
511 memcpy(mMin, nt.mMin, (mD+mF+mI)*sizeof(r_8)) ;
512 }
513 if(nt.mMax) {
514 mMax = new r_8[(mD+mF+mI)] ;
515 memcpy(mMax, nt.mMax, (mD+mF+mI)*sizeof(r_8)) ;
516 }
517
518 //dup blocs
519 mNBlk = 0 ;
520 mBlk = -1 ;
521 for(int i = 0 ; i < nt.mNBlk ; i++) {
522 add_blk() ; mBlk++ ; mNBlk++ ;
523 // si nt.ptr[i] swappe, on le relit
524 if(nt.ptr[i]->sw) nt.read_blk(nt.ptr[i]) ;
525 if(mD)
526 memcpy(ptr[i]->ddata, nt.ptr[i]->ddata, mD*mBlkSz*sizeof(r_8)) ;
527 if(mF)
528 memcpy(ptr[i]->fdata, nt.ptr[i]->fdata, mF*mBlkSz*sizeof(r_4)) ;
529 if(mI)
530 memcpy(ptr[i]->idata, nt.ptr[i]->idata, mF*mBlkSz*sizeof(int_4)) ;
531 if(mS)
532 memcpy(ptr[i]->sdata, nt.ptr[i]->sdata, mS*mBlkSz*sizeof(char)*(mStrSz+1)) ;
533 if(nt.ptr[i]->sw) nt.ptr[i]->free() ;
534 }
535
536 // DVList Info block
537 if(nt.mInfo!=NULL) {mInfo = new DVList; *mInfo = *(nt.mInfo);}
538
539}
540
541//++
542// DVList& Info()
543// Renvoie une référence sur l'objet DVList Associé
544//--
545
546DVList& XNTuple::Info()
547{
548 if (mInfo == NULL) mInfo = new DVList;
549 return(*mInfo);
550}
551
552void XNTuple::Print(int num, int nmax) const
553{
554 printf("XNTuple::Print() : \n") ;
555 printf(" Entrees = %d, Blocs = %d, Bloc Size = %d\n",
556 mNEnt, mNBlk, mBlkSz) ;
557 int i,j;
558 printf(" D_Vars = %d : ", mD) ;
559 for(i = 0 ; i < mD ; i++)
560 printf("%s ", NomIndex(i).c_str() ) ;
561 printf("\n") ;
562
563 printf(" F_Vars = %d : ", mF) ;
564 for(i = 0 ; i < mF ; i++)
565 printf("%s ", NomIndex(i+mD).c_str() ) ;
566 printf("\n") ;
567
568 printf(" I_Vars = %d : ", mI) ;
569 for(i = 0 ; i < mI ; i++)
570 printf("%s ", NomIndex(i+mD+mF).c_str() ) ;
571 printf("\n") ;
572
573 printf(" S_Vars = %d : ", mS) ;
574 for(i = 0 ; i < mS ; i++)
575 printf("%s ", NomIndex(i+mD+mF+mI).c_str() ) ;
576 printf("\n") ;
577
578 for(i = num ; i < num+nmax ; i++) {
579 for(j = 0 ; j < mD ; j++) printf("%f ", GetDVal(i,j)) ;
580 printf(" -- ") ;
581 for(j = 0 ; j < mF ; j++) printf("%f ", GetFVal(i,j+mD)) ;
582 printf(" -- ") ;
583 for(j = 0 ; j < mI ; j++) printf("%d ", GetIVal(i,j+mD+mF)) ;
584 printf(" -- ") ;
585 for(j = 0 ; j < mS ; j++) printf("%s ", GetSVal(i,j+mD+mF+mI).c_str()) ;
586 printf("\n") ;
587 }
588}
589
590
591void XNTuple::Show(ostream& os) const
592{
593 os << "XNTuple: NVar= " << mNVars << " NEnt= " << mNEnt
594 << " (BlkSz,NBlk= " << mBlkSz << ", " << mNBlk << ")"
595 << " (mNSwBlk= " << mNSwBlk << ")" << endl ;
596 os << "(Sw File= " ; if(swf_name) os << swf_name ; os << ")" << endl ;
597
598 char* buff = new char[80] ;
599 sprintf(buff, "Variables : Type Min Max \n") ;
600 os << buff ;
601
602 r_8 min, max ;
603 int i;
604 for(i = 0 ; i < mD ; i++) {
605 GetMinMax(i, min, max) ;
606 sprintf(buff, " %-10s: D %12.6g %12.6g \n",
607 NomIndex(i).c_str(), min, max) ;
608 os << buff ;
609 }
610 for(i = 0 ; i < mF ; i++) {
611 GetMinMax(i+mD, min, max) ;
612 sprintf(buff, " %-10s: F %12.6g %12.6g \n",
613 NomIndex(i+mD).c_str(), min, max) ;
614 os << buff ;
615 }
616 for(i = 0 ; i < mI ; i++) {
617 GetMinMax(i+mD+mF, min, max) ;
618 sprintf(buff, " %-10s: I %12.6g %12.6g \n",
619 NomIndex(i+mD+mF).c_str(), min, max) ;
620 os << buff ;
621 }
622 for(i = 0 ; i < mS ; i++) {
623 sprintf(buff, " %-10s: S ----- ----- \n",
624 NomIndex(i+mD+mF+mI).c_str()) ;
625 os << buff ;
626 }
627 delete[] buff ;
628}
629
630int XNTuple::FillFromASCIIFile(string const& fn, r_8 ddval, r_4 dfval,
631 int dival, const char * dsval)
632// Remplit le ntuple a partir d'un fichier ASCII.
633// Renvoie le nombre de lignes ajoutees.
634{
635// a faire
636return(0);
637}
638
639
640void XNTuple::SetSwapPath(char* p)
641{
642 if(!glob_swp) glob_swp = new char[MAXLEN+1] ;
643 strncpy(glob_swp, p, MAXLEN) ;
644}
645
646//
647//
648// Interface NTuple
649//
650//
651uint_4 XNTuple::NbLines() const
652{
653 return(NEntry());
654}
655
656uint_4 XNTuple::NbColumns() const
657{
658 return(NVar());
659}
660
661r_8* XNTuple::GetLineD(int n) const
662{
663 // memcpy() impossible
664 // il faut faire des GetVal
665 int i;
666 for(i = 0 ; i < mD ; i++)
667 mVarD[i] = GetDVal(n, i) ;
668 for(i = 0 ; i < mF ; i++)
669 mVarD[i+mD] = (r_8)GetFVal(n, i+mD) ;
670 for(i = 0 ; i < mI ; i++)
671 mVarD[i+mD+mF] = (r_8)GetIVal(n, i+mD+mF) ;
672 for(i = 0 ; i < mS ; i++)
673 mVarD[i+mD+mF+mI] = atof(GetSVal(n, i+mD+mF+mI).c_str()) ;
674 return mVarD ;
675}
676
677
678r_8 XNTuple::GetCell(int n, int k) const
679{
680 if( k<0 || k>=(mD+mF+mI+mS) ) return BADVAL ;
681 if(k<mD) return GetDVal(n,k) ;
682 if(k<(mF+mD)) return GetFVal(n,k) ;
683 if(k<(mF+mD+mI)) return GetIVal(n,k) ;
684 if(k<(mD+mF+mI+mS)) return atof(GetSVal(n,k).c_str()) ;
685 return BADVAL ;
686}
687
688
689r_8 XNTuple::GetCell(int n, string const& nom) const
690{
691 int k = IndexNom(nom.c_str()) ;
692 if(k<0) return BADVAL ;
693 if(k<mD) return GetDVal(n,k) ;
694 if(k<(mF+mD)) return GetFVal(n,k) ;
695 if(k<(mF+mD+mI)) return GetIVal(n,k) ;
696 if(k<(mD+mF+mI+mS)) return atof(GetSVal(n,k).c_str()) ;
697 return BADVAL ;
698}
699
700string XNTuple::GetCelltoString(int n, int k) const
701{
702 char buff[32];
703 if(k<0) return ("");
704 else if(k<mD)
705 { sprintf(buff, "%g", GetDVal(n,k)); return(buff) ; }
706 else if(k<(mF+mD))
707 { sprintf(buff, "%g", (double)GetFVal(n,k)); return(buff) ; }
708 else if(k<(mF+mD+mI))
709 { sprintf(buff, "%d", GetIVal(n,k)); return(buff) ; }
710 else if(k<(mD+mF+mI+mS))
711 return(GetSVal(n,k).c_str()) ;
712 return("");
713}
714
715void XNTuple::GetMinMax(int k, double& min, double& max) const
716{
717 min = 9E19 ; max = -9E19 ;
718 // variables string non traitees
719 if( k<0 || k>=(mD+mF+mI) ) return ;
720
721 min = mMin[k] ;
722 max = mMax[k] ;
723 return ;
724}
725
726
727void XNTuple::GetMinMax(string const & nom, double& min, double& max) const
728{
729 GetMinMax(IndexNom(nom.c_str()), min, max) ;
730}
731
732
733int XNTuple::ColumnIndex(string const& nom) const
734{
735 return IndexNom(nom.c_str()) ;
736}
737
738
739string XNTuple::ColumnName(int k) const
740{
741 return NomIndex(k) ;
742}
743
744
745string XNTuple::VarList_C(const char* nomx) const
746{
747 string rets = "" ;
748 rets += "/* r_8 type variables */ \n";
749 // variables r_8
750 int i;
751 for(i = 0 ; i < mD ; i++) {
752 if( i>0 && (i%5)==0 ) rets += ";" ;
753 if( (i%5)==0 ) rets+="\ndouble " ;
754 else rets += ", " ;
755 rets += NomIndex(i) ;
756 }
757 if(mD) rets += ";" ;
758
759 // variables r_4
760 rets += "/* r_4 type variables */ \n";
761 for(i = 0 ; i < mF ; i++) {
762 if( i>0 && (i%5)==0 ) rets += ";" ;
763 if( (i%5)==0 ) rets+="\ndouble " ;
764 else rets += ", " ;
765 rets += NomIndex(i+mD) ;
766 }
767 if(mF) rets += ";" ;
768
769 // variables int
770 rets += "/* int type variables */ \n";
771 for(i = 0 ; i < mI ; i++) {
772 if( i>0 && (i%5)==0 ) rets += ";" ;
773 if( (i%5)==0 ) rets+="\ndouble " ;
774 else rets += ", " ;
775 rets += NomIndex(i+mD+mF) ;
776 }
777 if(mI) rets += ";" ;
778
779 // variables string
780 rets += "/* string type variables */ \n";
781 for(i = 0 ; i < mS ; i++) {
782 if( i>0 && (i%5)==0 ) rets += ";" ;
783 if( (i%5)==0 ) rets+="\ndouble " ;
784 else rets += ", " ;
785 rets += NomIndex(i+mD+mF+mI) ;
786 }
787 rets += "; \n" ;
788
789 if(nomx) {
790 char buff[256] ;
791 for(i = 0 ; i < mNVars ; i++) {
792 sprintf(buff, "%s=%s[%d]; ", NomIndex(i).c_str(), nomx, i) ;
793 rets+=buff ;
794 if( (i%3 == 0) && (i>0) ) rets += "\n" ;
795 }
796 }
797 return rets ;
798}
799
800
801string XNTuple::LineHeaderToString() const
802{
803 char buff[32];
804 string rets=" Num ";
805 for(int i=0; i<mNVars; i++) {
806 sprintf(buff, "%8s ", NomIndex(i).c_str() );
807 rets += buff;
808 }
809 rets += '\n';
810 return(rets);
811
812}
813
814
815string XNTuple::LineToString(int n) const
816{
817 char buff[32];
818 r_8* val;
819 val = GetLineD(n);
820 sprintf(buff,"%6d: ",n);
821 string rets=buff;
822 int i;
823 for(i=0; i<(mD+mF+mI); i++) {
824 sprintf(buff, "%8.3g ", val[i]);
825 rets += buff;
826 }
827
828 for(i = mD+mF+mI ; i < mNVars ; i++) {
829 sprintf(buff, "%8s ", GetSVal(n,i).c_str() ) ;
830 rets += buff ;
831 }
832
833 rets += '\n';
834 return(rets);
835}
836
837
838void ObjFileIO<XNTuple>::WriteSelf(POutPersist& ppout) const
839{
840 if (dobj == NULL) return;
841// On ecrit 3 uint_4 ....
842// 0: Numero de version, 1 : non nul -> has info, 2 : reserve
843 uint_4 itab[3];
844 itab[0] = 1; // Numero de version a 1
845 itab[1] = itab[2] = 0;
846 if (dobj->mInfo) itab[1] = 1;
847 ppout.Put(itab,3);
848 if (dobj->mInfo) if (dobj->mInfo) ppout << (*(dobj->mInfo));
849
850 // variables internes
851 ppout.PutI4(dobj->mNEnt) ;
852 ppout.PutI4(dobj->mNBlk) ;
853 ppout.PutI4(dobj->mBlkSz) ;
854 ppout.PutI4(dobj->mBlk) ;
855 ppout.PutI4(dobj->mOff) ;
856 ppout.PutI4(dobj->mMaxBlk) ;
857 ppout.PutI4(dobj->mStrSz) ;
858 ppout.PutI4(dobj->mD) ;
859 ppout.PutI4(dobj->mF) ;
860 ppout.PutI4(dobj->mI) ;
861 ppout.PutI4(dobj->mS) ;
862 ppout.PutI4(dobj->mNVars) ;
863
864 // Noms
865 ppout.PutBytes(dobj->mNames, dobj->mNVars*(LENNAME+1)) ;
866
867 // MinMax
868 ppout.PutR8s(dobj->mMin, (dobj->mD+dobj->mF+dobj->mI)) ;
869 ppout.PutR8s(dobj->mMax, (dobj->mD+dobj->mF+dobj->mI)) ;
870
871 // Ecriture blocs N'ecrire que si datas existent
872 for(int i = 0 ; i < dobj->mNBlk ; i++) {
873 // si bloc swappe, on le relit en douce ...
874 if( dobj->ptr[i]->sw ) dobj->read_blk(dobj->ptr[i]) ;
875 ppout.PutR8s(dobj->ptr[i]->ddata, dobj->mD*dobj->mBlkSz) ;
876 ppout.PutR4s(dobj->ptr[i]->fdata, dobj->mF*dobj->mBlkSz) ;
877 ppout.PutI4s(dobj->ptr[i]->idata, dobj->mI*dobj->mBlkSz) ;
878 ppout.PutBytes(dobj->ptr[i]->sdata, dobj->mS*dobj->mBlkSz*(dobj->mStrSz+1)) ;
879 if(dobj->ptr[i]->sw) dobj->ptr[i]->free() ;
880 }
881}
882
883
884void ObjFileIO<XNTuple>::ReadSelf(PInPersist& ppin)
885{
886 if (dobj == NULL) dobj = new XNTuple;
887 else dobj->clean() ;
888// On lit 3 uint_4 ....
889// 0: Numero de version, 1 : non nul -> has info, 2 : reserve
890 uint_4 itab[3];
891 ppin.Get(itab,3);
892 if (itab[1] != 0) { // Lecture eventuelle du DVList Info
893 if (dobj->mInfo == NULL) dobj->mInfo = new DVList;
894 ppin >> (*(dobj->mInfo));
895 }
896
897 ppin.GetI4(dobj->mNEnt) ;
898 ppin.GetI4(dobj->mNBlk) ;
899 ppin.GetI4(dobj->mBlkSz) ;
900 ppin.GetI4(dobj->mBlk) ;
901 ppin.GetI4(dobj->mOff) ;
902 ppin.GetI4(dobj->mMaxBlk) ;
903 ppin.GetI4(dobj->mStrSz) ;
904 ppin.GetI4(dobj->mD) ;
905 ppin.GetI4(dobj->mF) ;
906 ppin.GetI4(dobj->mI) ;
907 ppin.GetI4(dobj->mS) ;
908 ppin.GetI4(dobj->mNVars) ;
909
910 // Noms
911 dobj->mNames = new char[dobj->mNVars*(LENNAME+1)] ;
912 dobj->mVarD = new r_8[dobj->mNVars];
913 ppin.GetBytes(dobj->mNames, dobj->mNVars*(LENNAME+1)) ;
914
915 // MinMax
916 dobj->mMin = new r_8[dobj->mD+dobj->mF+dobj->mI] ;
917 ppin.GetR8s(dobj->mMin, dobj->mD+dobj->mF+dobj->mI) ;
918 dobj->mMax = new r_8[dobj->mD+dobj->mF+dobj->mI] ;
919 ppin.GetR8s(dobj->mMax, dobj->mD+dobj->mF+dobj->mI) ;
920
921 // lecture Blocs
922 int nblk = dobj->mNBlk ;
923 dobj->mBlk = -1 ; dobj->mNBlk = 0 ;
924 for(int i = 0 ; i < nblk ; i++) {
925 dobj->add_blk() ; dobj->mBlk++ ; dobj->mNBlk++ ;
926 ppin.GetR8s(dobj->ptr[i]->ddata, dobj->mD*dobj->mBlkSz) ;
927 ppin.GetR4s(dobj->ptr[i]->fdata, dobj->mF*dobj->mBlkSz) ;
928 ppin.GetI4s(dobj->ptr[i]->idata, dobj->mI*dobj->mBlkSz) ;
929 ppin.GetBytes(dobj->ptr[i]->sdata, dobj->mS*dobj->mBlkSz*(dobj->mStrSz+1)) ;
930 }
931}
932
933
934
935
936
937#ifdef __CXX_PRAGMA_TEMPLATES__
938#pragma define_template ObjFileIO<XNTuple>
939#endif
940
941#if defined(ANSI_TEMPLATES) || defined(GNU_TEMPLATES)
942template class ObjFileIO<XNTuple>;
943#endif
944
945
946#ifdef __MWERKS__
947// Bricolo Dominique Yvon pour faire marcher sur Mac
948#include <stdio.h>
949#include <stdlib.h>
950 static long mktempMemory=0;
951 char * mktemp(char * Filename)
952 { sprintf(Filename,"TempFile%8i",mktempMemory);
953 mktempMemory++;
954 return Filename;
955 }
956#endif
Note: See TracBrowser for help on using the repository browser.