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

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

Defition de mktemp dans xntuple.cc avec compilation conditionnelle pour le mac.
Faudrais inclure cela proprement dans unixmax. Je laisse ce soin a Eric A.

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