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

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

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