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

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

int_4 r_4 r_8 ds XNTuple , Reza 19/5/2000
File size: 25.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#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) 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(r_8* d_data, r_4* 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 "os"
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(r_8* d_data, r_4* f_data, int_4* 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 ParmError("XNTuple::Fill(...) Missing (NULL) argument ");
346
347 r_8 x ;
348 // copie variables et update mMin, mMax
349 if(mD) {
350 memcpy(ptr[mBlk]->ddata+mOff*mD, d_data, mD*sizeof(r_8)) ;
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(r_4)) ;
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(int_4)) ;
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//
404r_8 XNTuple::GetDVal(int i, int k) const
405{
406 if( i<0 || i>=mNEnt || k<0 || k>=mD )
407 throw RangeCheckError("XNTuple::GetDVal() Invalid line/column index");
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//
421r_4 XNTuple::GetFVal(int i, int k) const
422{
423 if( i<0 || i>=mNEnt || k<mD || k>=(mD+mF) )
424 throw RangeCheckError("XNTuple::GetFVal() Invalid line/column index");
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//
439int_4 XNTuple::GetIVal(int i, int k) const
440{
441 if( i<0 || i>=mNEnt || k<(mD+mF) || k>=(mD+mF+mI) )
442 throw RangeCheckError("XNTuple::GetIVal() Invalid line/column index");
443
444 k -= (mD+mF) ;
445
446 // Bloc ?
447 int blk = (int)(i/mBlkSz) ;
448 int off = i%mBlkSz ;
449
450 // bloc swappe ?
451 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
452
453 return ptr[blk]->idata[off*mI+k] ;
454}
455
456//
457//
458//
459string XNTuple::GetSVal(int i, int k) const
460{
461 if( i<0 || i>=mNEnt || k<(mD+mF+mI) || k>=(mD+mF+mI+mS) )
462 throw RangeCheckError("XNTuple::GetSVal() Invalid line/column index");
463
464 k -= (mD+mF+mI) ;
465
466 // Bloc ?
467 int blk = (int)(i/mBlkSz) ;
468 int off = i%mBlkSz ;
469
470 // bloc swappe ?
471 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
472
473 // copie de la chaine
474 // string ret = strdup(ptr[blk]->sdata + (off*mS+k)*(mStrSz+1)) ; // $CHECK$ EA fuite de memoire
475 // attention, strdup fait un malloc et on ne fait jamais de free...
476 // a quoi sert ce strdup ?????????
477 string ret = ptr[blk]->sdata + (off*mS+k)*(mStrSz+1) ;
478 // return ptr[blk]->sdata[k] ;
479 return ret ;
480}
481
482
483//
484// Copie bloc a bloc, avec meme parametres
485//
486void XNTuple::Copy(XNTuple const& nt)
487{
488 clean() ;
489 // Parametres
490 mNEnt = nt.mNEnt ;
491 mBlkSz = nt.mBlkSz ;
492 mOff = nt.mOff ;
493 mMaxBlk = nt.mMaxBlk ;
494 mStrSz = nt.mStrSz ;
495 mD = nt.mD ;
496 mF = nt.mF ;
497 mI = nt.mI ;
498 mS = nt.mS ;
499 mNVars = nt.mNVars ;
500
501 // noms
502 if(mNVars) {
503 mNames = new char[mNVars*(LENNAME+1)] ;
504 mVarD = new r_8[mNVars];
505 memcpy(mNames, nt.mNames, mNVars*(LENNAME+1)*sizeof(char)) ;
506 }
507 // MinMax
508 if(nt.mMin) {
509 mMin = new r_8[(mD+mF+mI)] ;
510 memcpy(mMin, nt.mMin, (mD+mF+mI)*sizeof(r_8)) ;
511 }
512 if(nt.mMax) {
513 mMax = new r_8[(mD+mF+mI)] ;
514 memcpy(mMax, nt.mMax, (mD+mF+mI)*sizeof(r_8)) ;
515 }
516
517 //dup blocs
518 mNBlk = 0 ;
519 mBlk = -1 ;
520 for(int i = 0 ; i < nt.mNBlk ; i++) {
521 add_blk() ; mBlk++ ; mNBlk++ ;
522 // si nt.ptr[i] swappe, on le relit
523 if(nt.ptr[i]->sw) nt.read_blk(nt.ptr[i]) ;
524 if(mD)
525 memcpy(ptr[i]->ddata, nt.ptr[i]->ddata, mD*mBlkSz*sizeof(r_8)) ;
526 if(mF)
527 memcpy(ptr[i]->fdata, nt.ptr[i]->fdata, mF*mBlkSz*sizeof(r_4)) ;
528 if(mI)
529 memcpy(ptr[i]->idata, nt.ptr[i]->idata, mF*mBlkSz*sizeof(int_4)) ;
530 if(mS)
531 memcpy(ptr[i]->sdata, nt.ptr[i]->sdata, mS*mBlkSz*sizeof(char)*(mStrSz+1)) ;
532 if(nt.ptr[i]->sw) nt.ptr[i]->free() ;
533 }
534
535 // DVList Info block
536 if(nt.mInfo!=NULL) {mInfo = new DVList; *mInfo = *(nt.mInfo);}
537
538}
539
540//++
541// DVList& Info()
542// Renvoie une référence sur l'objet DVList Associé
543//--
544
545DVList& XNTuple::Info()
546{
547 if (mInfo == NULL) mInfo = new DVList;
548 return(*mInfo);
549}
550
551void XNTuple::Print(int num, int nmax) const
552{
553 printf("XNTuple::Print() : \n") ;
554 printf(" Entrees = %d, Blocs = %d, Bloc Size = %d\n",
555 mNEnt, mNBlk, mBlkSz) ;
556 int i,j;
557 printf(" D_Vars = %d : ", mD) ;
558 for(i = 0 ; i < mD ; i++)
559 printf("%s ", NomIndex(i).c_str() ) ;
560 printf("\n") ;
561
562 printf(" F_Vars = %d : ", mF) ;
563 for(i = 0 ; i < mF ; i++)
564 printf("%s ", NomIndex(i+mD).c_str() ) ;
565 printf("\n") ;
566
567 printf(" I_Vars = %d : ", mI) ;
568 for(i = 0 ; i < mI ; i++)
569 printf("%s ", NomIndex(i+mD+mF).c_str() ) ;
570 printf("\n") ;
571
572 printf(" S_Vars = %d : ", mS) ;
573 for(i = 0 ; i < mS ; i++)
574 printf("%s ", NomIndex(i+mD+mF+mI).c_str() ) ;
575 printf("\n") ;
576
577 for(i = num ; i < num+nmax ; i++) {
578 for(j = 0 ; j < mD ; j++) printf("%f ", GetDVal(i,j)) ;
579 printf(" -- ") ;
580 for(j = 0 ; j < mF ; j++) printf("%f ", GetFVal(i,j+mD)) ;
581 printf(" -- ") ;
582 for(j = 0 ; j < mI ; j++) printf("%d ", GetIVal(i,j+mD+mF)) ;
583 printf(" -- ") ;
584 for(j = 0 ; j < mS ; j++) printf("%s ", GetSVal(i,j+mD+mF+mI).c_str()) ;
585 printf("\n") ;
586 }
587}
588
589
590void XNTuple::Show(ostream& os) const
591{
592 os << "XNTuple: NVar= " << mNVars << " NEnt= " << mNEnt
593 << " (BlkSz,NBlk= " << mBlkSz << ", " << mNBlk << ")"
594 << " (mNSwBlk= " << mNSwBlk << ")" << endl ;
595 os << "(Sw File= " ; if(swf_name) os << swf_name ; os << ")" << endl ;
596
597 char* buff = new char[80] ;
598 sprintf(buff, "Variables : Type Min Max \n") ;
599 os << buff ;
600
601 r_8 min, max ;
602 int i;
603 for(i = 0 ; i < mD ; i++) {
604 GetMinMax(i, min, max) ;
605 sprintf(buff, " %-10s: D %12.6g %12.6g \n",
606 NomIndex(i).c_str(), min, max) ;
607 os << buff ;
608 }
609 for(i = 0 ; i < mF ; i++) {
610 GetMinMax(i+mD, min, max) ;
611 sprintf(buff, " %-10s: F %12.6g %12.6g \n",
612 NomIndex(i+mD).c_str(), min, max) ;
613 os << buff ;
614 }
615 for(i = 0 ; i < mI ; i++) {
616 GetMinMax(i+mD+mF, min, max) ;
617 sprintf(buff, " %-10s: I %12.6g %12.6g \n",
618 NomIndex(i+mD+mF).c_str(), min, max) ;
619 os << buff ;
620 }
621 for(i = 0 ; i < mS ; i++) {
622 sprintf(buff, " %-10s: S ----- ----- \n",
623 NomIndex(i+mD+mF+mI).c_str()) ;
624 os << buff ;
625 }
626 delete[] buff ;
627}
628
629int XNTuple::FillFromASCIIFile(string const& fn, r_8 ddval, r_4 dfval,
630 int dival, const char * dsval)
631// Remplit le ntuple a partir d'un fichier ASCII.
632// Renvoie le nombre de lignes ajoutees.
633{
634// a faire
635return(0);
636}
637
638
639void XNTuple::SetSwapPath(char* p)
640{
641 if(!glob_swp) glob_swp = new char[MAXLEN+1] ;
642 strncpy(glob_swp, p, MAXLEN) ;
643}
644
645//
646//
647// Interface NTuple
648//
649//
650uint_4 XNTuple::NbLines() const
651{
652 return(NEntry());
653}
654
655uint_4 XNTuple::NbColumns() const
656{
657 return(NVar());
658}
659
660r_8* XNTuple::GetLineD(int n) const
661{
662 // memcpy() impossible
663 // il faut faire des GetVal
664 int i;
665 for(i = 0 ; i < mD ; i++)
666 mVarD[i] = GetDVal(n, i) ;
667 for(i = 0 ; i < mF ; i++)
668 mVarD[i+mD] = (r_8)GetFVal(n, i+mD) ;
669 for(i = 0 ; i < mI ; i++)
670 mVarD[i+mD+mF] = (r_8)GetIVal(n, i+mD+mF) ;
671 for(i = 0 ; i < mS ; i++)
672 mVarD[i+mD+mF+mI] = atof(GetSVal(n, i+mD+mF+mI).c_str()) ;
673 return mVarD ;
674}
675
676
677r_8 XNTuple::GetCell(int n, int k) const
678{
679 if( k<0 || k>=(mD+mF+mI+mS) ) return BADVAL ;
680 if(k<mD) return GetDVal(n,k) ;
681 if(k<(mF+mD)) return GetFVal(n,k) ;
682 if(k<(mF+mD+mI)) return GetIVal(n,k) ;
683 if(k<(mD+mF+mI+mS)) return atof(GetSVal(n,k).c_str()) ;
684 return BADVAL ;
685}
686
687
688r_8 XNTuple::GetCell(int n, string const& nom) const
689{
690 int k = IndexNom(nom.c_str()) ;
691 if(k<0) return BADVAL ;
692 if(k<mD) return GetDVal(n,k) ;
693 if(k<(mF+mD)) return GetFVal(n,k) ;
694 if(k<(mF+mD+mI)) return GetIVal(n,k) ;
695 if(k<(mD+mF+mI+mS)) return atof(GetSVal(n,k).c_str()) ;
696 return BADVAL ;
697}
698
699string XNTuple::GetCelltoString(int n, int k) const
700{
701 char buff[32];
702 if(k<0) return ("");
703 else if(k<mD)
704 { sprintf(buff, "%g", GetDVal(n,k)); return(buff) ; }
705 else if(k<(mF+mD))
706 { sprintf(buff, "%g", (double)GetFVal(n,k)); return(buff) ; }
707 else if(k<(mF+mD+mI))
708 { sprintf(buff, "%d", GetIVal(n,k)); return(buff) ; }
709 else if(k<(mD+mF+mI+mS))
710 return(GetSVal(n,k).c_str()) ;
711 return("");
712}
713
714void XNTuple::GetMinMax(int k, double& min, double& max) const
715{
716 min = 9E19 ; max = -9E19 ;
717 // variables string non traitees
718 if( k<0 || k>=(mD+mF+mI) ) return ;
719
720 min = mMin[k] ;
721 max = mMax[k] ;
722 return ;
723}
724
725
726void XNTuple::GetMinMax(string const & nom, double& min, double& max) const
727{
728 GetMinMax(IndexNom(nom.c_str()), min, max) ;
729}
730
731
732int XNTuple::ColumnIndex(string const& nom) const
733{
734 return IndexNom(nom.c_str()) ;
735}
736
737
738string XNTuple::ColumnName(int k) const
739{
740 return NomIndex(k) ;
741}
742
743
744string XNTuple::VarList_C(const char* nomx) const
745{
746 string rets = "" ;
747 rets += "/* r_8 type variables */ \n";
748 // variables r_8
749 int i;
750 for(i = 0 ; i < mD ; i++) {
751 if( i>0 && (i%5)==0 ) rets += ";" ;
752 if( (i%5)==0 ) rets+="\ndouble " ;
753 else rets += ", " ;
754 rets += NomIndex(i) ;
755 }
756 if(mD) rets += ";" ;
757
758 // variables r_4
759 rets += "/* r_4 type variables */ \n";
760 for(i = 0 ; i < mF ; i++) {
761 if( i>0 && (i%5)==0 ) rets += ";" ;
762 if( (i%5)==0 ) rets+="\ndouble " ;
763 else rets += ", " ;
764 rets += NomIndex(i+mD) ;
765 }
766 if(mF) rets += ";" ;
767
768 // variables int
769 rets += "/* int type variables */ \n";
770 for(i = 0 ; i < mI ; i++) {
771 if( i>0 && (i%5)==0 ) rets += ";" ;
772 if( (i%5)==0 ) rets+="\ndouble " ;
773 else rets += ", " ;
774 rets += NomIndex(i+mD+mF) ;
775 }
776 if(mI) rets += ";" ;
777
778 // variables string
779 rets += "/* string type variables */ \n";
780 for(i = 0 ; i < mS ; i++) {
781 if( i>0 && (i%5)==0 ) rets += ";" ;
782 if( (i%5)==0 ) rets+="\ndouble " ;
783 else rets += ", " ;
784 rets += NomIndex(i+mD+mF+mI) ;
785 }
786 rets += "; \n" ;
787
788 if(nomx) {
789 char buff[256] ;
790 for(i = 0 ; i < mNVars ; i++) {
791 sprintf(buff, "%s=%s[%d]; ", NomIndex(i).c_str(), nomx, i) ;
792 rets+=buff ;
793 if( (i%3 == 0) && (i>0) ) rets += "\n" ;
794 }
795 }
796 return rets ;
797}
798
799
800string XNTuple::LineHeaderToString() const
801{
802 char buff[32];
803 string rets=" Num ";
804 for(int i=0; i<mNVars; i++) {
805 sprintf(buff, "%8s ", NomIndex(i).c_str() );
806 rets += buff;
807 }
808 rets += '\n';
809 return(rets);
810
811}
812
813
814string XNTuple::LineToString(int n) const
815{
816 char buff[32];
817 r_8* val;
818 val = GetLineD(n);
819 sprintf(buff,"%6d: ",n);
820 string rets=buff;
821 int i;
822 for(i=0; i<(mD+mF+mI); i++) {
823 sprintf(buff, "%8.3g ", val[i]);
824 rets += buff;
825 }
826
827 for(i = mD+mF+mI ; i < mNVars ; i++) {
828 sprintf(buff, "%8s ", GetSVal(n,i).c_str() ) ;
829 rets += buff ;
830 }
831
832 rets += '\n';
833 return(rets);
834}
835
836
837void ObjFileIO<XNTuple>::WriteSelf(POutPersist& ppout) const
838{
839 if (dobj == NULL) return;
840// On ecrit 3 uint_4 ....
841// 0: Numero de version, 1 : non nul -> has info, 2 : reserve
842 uint_4 itab[3];
843 itab[0] = 1; // Numero de version a 1
844 itab[1] = itab[2] = 0;
845 if (dobj->mInfo) itab[1] = 1;
846 ppout.Put(itab,3);
847 if (dobj->mInfo) if (dobj->mInfo) ppout << (*(dobj->mInfo));
848
849 // variables internes
850 ppout.PutI4(dobj->mNEnt) ;
851 ppout.PutI4(dobj->mNBlk) ;
852 ppout.PutI4(dobj->mBlkSz) ;
853 ppout.PutI4(dobj->mBlk) ;
854 ppout.PutI4(dobj->mOff) ;
855 ppout.PutI4(dobj->mMaxBlk) ;
856 ppout.PutI4(dobj->mStrSz) ;
857 ppout.PutI4(dobj->mD) ;
858 ppout.PutI4(dobj->mF) ;
859 ppout.PutI4(dobj->mI) ;
860 ppout.PutI4(dobj->mS) ;
861 ppout.PutI4(dobj->mNVars) ;
862
863 // Noms
864 ppout.PutBytes(dobj->mNames, dobj->mNVars*(LENNAME+1)) ;
865
866 // MinMax
867 ppout.PutR8s(dobj->mMin, (dobj->mD+dobj->mF+dobj->mI)) ;
868 ppout.PutR8s(dobj->mMax, (dobj->mD+dobj->mF+dobj->mI)) ;
869
870 // Ecriture blocs N'ecrire que si datas existent
871 for(int i = 0 ; i < dobj->mNBlk ; i++) {
872 // si bloc swappe, on le relit en douce ...
873 if( dobj->ptr[i]->sw ) dobj->read_blk(dobj->ptr[i]) ;
874 ppout.PutR8s(dobj->ptr[i]->ddata, dobj->mD*dobj->mBlkSz) ;
875 ppout.PutR4s(dobj->ptr[i]->fdata, dobj->mF*dobj->mBlkSz) ;
876 ppout.PutI4s(dobj->ptr[i]->idata, dobj->mI*dobj->mBlkSz) ;
877 ppout.PutBytes(dobj->ptr[i]->sdata, dobj->mS*dobj->mBlkSz*(dobj->mStrSz+1)) ;
878 if(dobj->ptr[i]->sw) dobj->ptr[i]->free() ;
879 }
880}
881
882
883void ObjFileIO<XNTuple>::ReadSelf(PInPersist& ppin)
884{
885 if (dobj == NULL) dobj = new XNTuple;
886 else dobj->clean() ;
887// On lit 3 uint_4 ....
888// 0: Numero de version, 1 : non nul -> has info, 2 : reserve
889 uint_4 itab[3];
890 ppin.Get(itab,3);
891 if (itab[1] != 0) { // Lecture eventuelle du DVList Info
892 if (dobj->mInfo == NULL) dobj->mInfo = new DVList;
893 ppin >> (*(dobj->mInfo));
894 }
895
896 ppin.GetI4(dobj->mNEnt) ;
897 ppin.GetI4(dobj->mNBlk) ;
898 ppin.GetI4(dobj->mBlkSz) ;
899 ppin.GetI4(dobj->mBlk) ;
900 ppin.GetI4(dobj->mOff) ;
901 ppin.GetI4(dobj->mMaxBlk) ;
902 ppin.GetI4(dobj->mStrSz) ;
903 ppin.GetI4(dobj->mD) ;
904 ppin.GetI4(dobj->mF) ;
905 ppin.GetI4(dobj->mI) ;
906 ppin.GetI4(dobj->mS) ;
907 ppin.GetI4(dobj->mNVars) ;
908
909 // Noms
910 dobj->mNames = new char[dobj->mNVars*(LENNAME+1)] ;
911 dobj->mVarD = new r_8[dobj->mNVars];
912 ppin.GetBytes(dobj->mNames, dobj->mNVars*(LENNAME+1)) ;
913
914 // MinMax
915 dobj->mMin = new r_8[dobj->mD+dobj->mF+dobj->mI] ;
916 ppin.GetR8s(dobj->mMin, dobj->mD+dobj->mF+dobj->mI) ;
917 dobj->mMax = new r_8[dobj->mD+dobj->mF+dobj->mI] ;
918 ppin.GetR8s(dobj->mMax, dobj->mD+dobj->mF+dobj->mI) ;
919
920 // lecture Blocs
921 int nblk = dobj->mNBlk ;
922 dobj->mBlk = -1 ; dobj->mNBlk = 0 ;
923 for(int i = 0 ; i < nblk ; i++) {
924 dobj->add_blk() ; dobj->mBlk++ ; dobj->mNBlk++ ;
925 ppin.GetR8s(dobj->ptr[i]->ddata, dobj->mD*dobj->mBlkSz) ;
926 ppin.GetR4s(dobj->ptr[i]->fdata, dobj->mF*dobj->mBlkSz) ;
927 ppin.GetI4s(dobj->ptr[i]->idata, dobj->mI*dobj->mBlkSz) ;
928 ppin.GetBytes(dobj->ptr[i]->sdata, dobj->mS*dobj->mBlkSz*(dobj->mStrSz+1)) ;
929 }
930}
931////////////// methodes supplementaires pour leserveur de fichiers fits//////
932//
933// (protected)
934//
935void XNTuple::SetDVal(int i, int k, r_8 v)
936{
937 if( i<0 || i>=mNEnt || k<0 || k>=mD )
938 throw RangeCheckError("XNTuple::SetDVal() Invalid line/column index");
939
940 // Bloc ?
941 int blk = (int)(i/mBlkSz) ;
942 int off = i%mBlkSz ;
943
944 // bloc swappe ?
945 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
946 ptr[blk]->ddata[off*mD+k]=v ;
947}
948
949void XNTuple::SetFVal(int i, int k, r_4 v)
950{
951 if( i<0 || i>=mNEnt || k<mD || k>=(mD+mF) )
952 throw RangeCheckError("XNTuple::SetFVal() Invalid line/column index");
953
954 k -= mD ;
955
956 // Bloc ?
957 int blk = (int)(i/mBlkSz) ;
958 int off = i%mBlkSz ;
959
960 // bloc swappe ?
961 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
962 ptr[blk]->fdata[off*mF+k]=v ;
963}
964void XNTuple::SetIVal(int i, int k, int v)
965{
966 if( i<0 || i>=mNEnt || k<(mD+mF) || k>=(mD+mF+mI) )
967 throw RangeCheckError("XNTuple::SetIVal() Invalid line/column index");
968
969 k -= (mD+mF) ;
970
971 // Bloc ?
972 int blk = (int)(i/mBlkSz) ;
973 int off = i%mBlkSz ;
974
975 // bloc swappe ?
976 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
977
978 ptr[blk]->idata[off*mI+k]=v ;
979}
980void XNTuple::SetSVal(int i, int k, char* v)
981{
982 if( i<0 || i>=mNEnt || k<(mD+mF+mI) || k>=(mD+mF+mI+mS) )
983 throw RangeCheckError("XNTuple::SetSVal() Invalid line/column index");
984
985 k -= (mD+mF+mI) ;
986
987 // Bloc ?
988 int blk = (int)(i/mBlkSz) ;
989 int off = i%mBlkSz ;
990
991 // bloc swappe ?
992 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
993
994 // copie de la chaine
995 strncpy(ptr[blk]->sdata + (off*mS+k)*(mStrSz+1),v, mStrSz+1) ;
996}
997
998
999
1000
1001
1002
1003#ifdef __CXX_PRAGMA_TEMPLATES__
1004#pragma define_template ObjFileIO<XNTuple>
1005#endif
1006
1007#if defined(ANSI_TEMPLATES) || defined(GNU_TEMPLATES)
1008template class ObjFileIO<XNTuple>;
1009#endif
1010
1011
1012#ifdef __MWERKS__
1013// Bricolo Dominique Yvon pour faire marcher sur Mac
1014#include <stdio.h>
1015#include <stdlib.h>
1016 static long mktempMemory=0;
1017 char * mktemp(char * Filename)
1018 { sprintf(Filename,"TempFile%8i",mktempMemory);
1019 mktempMemory++;
1020 return Filename;
1021 }
1022#endif
Note: See TracBrowser for help on using the repository browser.