source: Sophya/trunk/SophyaLib/HiStats/basedtable.cc@ 2827

Last change on this file since 2827 was 2827, checked in by ansari, 20 years ago

Modifs code BaseDataTable , DataTable et SwPPFDataTable pour la prise en compte
de colonnes de type complex (complex<r_4> ComplexField et complex<r_8> DoubleComplexField ) Reza , 2 Nov 2005
File size: 18.7 KB
Line 
1#include "basedtable.h"
2#include <ctype.h>
3#include "sopnamsp.h"
4#include "pexceptions.h"
5
6/*!
7 \class SOPHYA::BaseDataTable
8 \ingroup HiStats
9 Base class for data tables. Each line represent a record
10 and the column contains a given data type.
11*/
12
13string BaseDataTable::ColTypeToString(FieldType ft, bool fgl)
14{
15 string rs;
16 switch (ft) {
17 case IntegerField :
18 if (fgl) rs = "Integer";
19 else rs = "I";
20 break;
21 case LongField :
22 if (fgl) rs = "Long Integer";
23 else rs = "L";
24 break;
25 case FloatField :
26 if (fgl) rs = "Float";
27 else rs = "F";
28 break;
29 case DoubleField :
30 if (fgl) rs = "Double";
31 else rs = "D";
32 break;
33 case ComplexField :
34 if (fgl) rs = "Complex";
35 else rs = "Zx4";
36 break;
37 case DoubleComplexField :
38 if (fgl) rs = "DoubleComplex";
39 else rs = "Zx8";
40 break;
41 case StringField :
42 if (fgl) rs = "String";
43 else rs = "S";
44 break;
45 case DateField :
46 if (fgl) rs = "DateTime";
47 else rs = "T";
48 break;
49 default:
50 rs = "??";
51 break;
52 }
53 return rs;
54}
55
56/* Constructeur */
57BaseDataTable::BaseDataTable(sa_size_t segsz)
58{
59 mNEnt = 0;
60 mSegSz = (segsz > 0) ? segsz : 16;
61 mNSeg = 0;
62 mVarD = NULL;
63 mVarMTV = NULL;
64 mInfo = NULL;
65}
66
67BaseDataTable::~BaseDataTable()
68{
69 if (mVarD) delete[] mVarD;
70 if (mVarMTV) delete[] mVarMTV;
71 if (mInfo) delete mInfo;
72}
73
74sa_size_t BaseDataTable::CopyStructure(BaseDataTable const & a)
75{
76 if (NVar() > 0)
77 throw ParmError("BaseDataTable::CopyStructure() Table already has columns");
78 if (a.NVar() == 0) {
79 cout << "BaseDataTable::CopyStructure(a)/Warning Table a is not initialized" << endl;
80 return 0;
81 }
82 for (size_t kk=0; kk<a.mNames.size(); kk++)
83 AddColumn(a.mNames[kk].type, a.mNames[kk].nom);
84 return NVar();
85}
86
87//! return true is same structure
88bool BaseDataTable::CompareStructure(BaseDataTable const & a)
89{
90 if (NVar() != a.NVar()) return false;
91 for (size_t kk=0; kk<mNames.size(); kk++)
92 if ( (mNames[kk].type != a.mNames[kk].type) ||
93 (mNames[kk].nom != a.mNames[kk].nom) ) return false;
94 return true;
95}
96
97bool BaseDataTable::CheckColName(string const & cnom)
98{
99 size_t l,k;
100 l = cnom.length();
101 if (l < 1)
102 throw ParmError("BaseDataTable::CheckColName() zero length column name");
103 if (!isalpha(cnom[0]))
104 throw ParmError("BaseDataTable::CheckColName() first character not alphabetical");
105 for(k=1; k<l; k++)
106 if ((!isalnum(cnom[k])) && (cnom[k] != '_'))
107 throw ParmError("BaseDataTable::CheckColName() Non alphanumeric char in name");
108 for(k=0; k<mNames.size(); k++)
109 if (cnom == mNames[k].nom)
110 throw ParmError("BaseDataTable::CheckColName() already existing name");
111 return true;
112}
113
114//
115// A quel index correspond mon nom ?
116//
117sa_size_t BaseDataTable::IndexNom(char const* nom) const
118{
119 for(sa_size_t k=0; k<NVar(); k++)
120 if ( mNames[k].nom == nom ) return k;
121 return -1;
122 // Reza:Avril 2005 : PINtuple se base sur le renvoi de -1 et pas d'une exception
123 // throw NotFoundExc("BaseDataTable::IndexNom() : column name not found ");
124}
125
126string BaseDataTable::NomIndex(sa_size_t k) const
127{
128 if ((k < 0) || (k >= NVar()))
129 throw RangeCheckError("BaseDataTable::NomIndex() out of range column index k");
130 return mNames[k].nom ;
131}
132
133//! Adds a line (or row to the table) with r_8* inout data
134/*!
135 The data to be added is provided as an array (vector) of double (r_8).
136 The necessary data conversion is performed, depending on each
137 column's data typeconverted to the data type.
138 Return the new number of table rows (lines / entries)
139 \param data : Data for each cell of the row to be appended
140 (data[k] k=0..NbColumns())
141*/
142sa_size_t BaseDataTable::AddLine(const r_8* data)
143{
144 if (NVar() == 0)
145 throw ParmError("BaseDataTable::AddLine(const r_8*) Table has no column !");
146 if (NEntry() == SegmentSize()*NbSegments()) Extend();
147 sa_size_t n = NEntry();
148 sa_size_t bid = n/mSegSz;
149 sa_size_t off = n%mSegSz;
150 for(sa_size_t k=0; k<mIColsP.size(); k++)
151 mIColsP[k]->GetSegment(bid)[off] = (int_4)data[mIColIdx[k]];
152 for(sa_size_t k=0; k<mLColsP.size(); k++)
153 mLColsP[k]->GetSegment(bid)[off] = (int_8)data[mLColIdx[k]];
154 for(sa_size_t k=0; k<mFColsP.size(); k++)
155 mFColsP[k]->GetSegment(bid)[off] = (r_4)data[mFColIdx[k]];
156 for(sa_size_t k=0; k<mDColsP.size(); k++)
157 mDColsP[k]->GetSegment(bid)[off] = data[mDColIdx[k]];
158 for(sa_size_t k=0; k<mYColsP.size(); k++)
159 mYColsP[k]->GetSegment(bid)[off] = complex<r_4>(data[mYColIdx[k]],0.);
160 for(sa_size_t k=0; k<mZColsP.size(); k++)
161 mZColsP[k]->GetSegment(bid)[off] = complex<r_8>(data[mZColIdx[k]],0.);
162 for(sa_size_t k=0; k<mSColsP.size(); k++)
163 mSColsP[k]->GetSegment(bid)[off] = (string)MuTyV(data[mSColIdx[k]]);
164
165 mNEnt++;
166 return mNEnt;
167}
168
169//! Adds a line (or row to the table) with input data as an array of MuTyV
170/*!
171 The data to be added is provided as an array (vector) of MuTyV.
172 The MuTyV class conversion operators are used to match against each
173 cell data type.
174 Return the new number of table rows (lines / entries)
175 \param data : Data (MuTyV*) for each cell of the row to be appended
176 (data[k] k=0..NbColumns())
177*/
178sa_size_t BaseDataTable::AddLine(const MuTyV* data)
179{
180 if (NVar() == 0)
181 throw ParmError("BaseDataTable::AddLine(const MuTyV*) Table has no column !");
182 if (NEntry() == SegmentSize()*NbSegments()) Extend();
183 sa_size_t n = NEntry();
184 sa_size_t bid = n/mSegSz;
185 sa_size_t off = n%mSegSz;
186 for(sa_size_t k=0; k<mIColsP.size(); k++)
187 mIColsP[k]->GetSegment(bid)[off] = (int_4)data[mIColIdx[k]];
188 for(sa_size_t k=0; k<mLColsP.size(); k++)
189 mLColsP[k]->GetSegment(bid)[off] = (int_8)data[mLColIdx[k]];
190 for(sa_size_t k=0; k<mSColsP.size(); k++)
191 mSColsP[k]->GetSegment(bid)[off] = (string)data[mSColIdx[k]];
192 for(sa_size_t k=0; k<mFColsP.size(); k++)
193 mFColsP[k]->GetSegment(bid)[off] = (r_4)data[mFColIdx[k]];
194 for(sa_size_t k=0; k<mDColsP.size(); k++)
195 mDColsP[k]->GetSegment(bid)[off] = (r_8)data[mDColIdx[k]];
196 for(sa_size_t k=0; k<mYColsP.size(); k++)
197 mYColsP[k]->GetSegment(bid)[off] =
198 complex<r_4>(data[mYColIdx[k]].GetRealPart(), data[mYColIdx[k]].GetImagPart());
199 for(sa_size_t k=0; k<mZColsP.size(); k++)
200 mZColsP[k]->GetSegment(bid)[off] =
201 complex<r_8>(data[mZColIdx[k]].GetRealPart(), data[mZColIdx[k]].GetImagPart());
202
203 mNEnt++;
204 return mNEnt;
205}
206
207sa_size_t BaseDataTable::Extend()
208{
209 for(sa_size_t k=0; k<mIColsP.size(); k++)
210 mIColsP[k]->Extend();
211 for(sa_size_t k=0; k<mLColsP.size(); k++)
212 mLColsP[k]->Extend();
213 for(sa_size_t k=0; k<mFColsP.size(); k++)
214 mFColsP[k]->Extend();
215 for(sa_size_t k=0; k<mDColsP.size(); k++)
216 mDColsP[k]->Extend();
217 for(sa_size_t k=0; k<mYColsP.size(); k++)
218 mYColsP[k]->Extend();
219 for(sa_size_t k=0; k<mZColsP.size(); k++)
220 mZColsP[k]->Extend();
221 for(sa_size_t k=0; k<mSColsP.size(); k++)
222 mSColsP[k]->Extend();
223 mNSeg++;
224 return mNSeg;
225}
226
227
228MuTyV* BaseDataTable::GetLine(sa_size_t n) const
229{
230 if ((n < 0) || (n >= NEntry()))
231 throw RangeCheckError("BaseDataTable::GetLine() out of range line index n");
232 if (mVarMTV == NULL) mVarMTV = new MuTyV[NVar()];
233
234 sa_size_t bid = n/mSegSz;
235 sa_size_t off = n%mSegSz;
236 for(sa_size_t k=0; k<mIColsP.size(); k++)
237 mVarMTV[mIColIdx[k]] = mIColsP[k]->GetCstSegment(bid)[off];
238 for(sa_size_t k=0; k<mLColsP.size(); k++)
239 mVarMTV[mLColIdx[k]] = mLColsP[k]->GetCstSegment(bid)[off];
240 for(sa_size_t k=0; k<mFColsP.size(); k++)
241 mVarMTV[mFColIdx[k]] = mFColsP[k]->GetCstSegment(bid)[off];
242 for(sa_size_t k=0; k<mDColsP.size(); k++)
243 mVarMTV[mDColIdx[k]] = mDColsP[k]->GetCstSegment(bid)[off];
244 for(sa_size_t k=0; k<mYColsP.size(); k++)
245 mVarMTV[mYColIdx[k]] = mYColsP[k]->GetCstSegment(bid)[off];
246 for(sa_size_t k=0; k<mZColsP.size(); k++)
247 mVarMTV[mZColIdx[k]] = mZColsP[k]->GetCstSegment(bid)[off];
248 for(sa_size_t k=0; k<mSColsP.size(); k++)
249 mVarMTV[mSColIdx[k]] = atof(mSColsP[k]->GetCstSegment(bid)[off].c_str());
250
251 return mVarMTV;
252}
253
254void BaseDataTable::CopyMerge(BaseDataTable const& a, bool cp)
255{
256 if (cp && (NEntry() > 0) )
257 throw ParmError("BaseDataTable::CopyMerge(a) Table has entries already");
258 if (a.NVar() == 0) throw ParmError("BaseDataTable::CopyMerge(a) Table a has no column");
259 if (NVar() == 0) CopyStructure(a);
260 else if (!CompareStructure(a))
261 throw SzMismatchError("BaseDataTable::CopyMerge(a) (this,a) have different table structure");
262 if (a.NEntry() == 0) {
263 cout << " BaseDataTable::CopyMerge(a)/Warning : table a has zero (0) entry ! " << endl;
264 return;
265 }
266 for(sa_size_t kk=0; kk<a.NEntry(); kk++)
267 AddLine(a.GetLine(kk));
268}
269
270
271//! Returns the associated DVList object
272DVList& BaseDataTable::Info() const
273{
274 if (mInfo == NULL) mInfo = new DVList;
275 return(*mInfo);
276}
277
278void BaseDataTable::Print(int num, int nmax) const
279{
280 // A faire
281 return;
282}
283
284/*! In addition to printing the number of entries and column names,
285 this method prints also minimum/maximum value for each column.
286 This information might be computed when the Show() method is called.
287 This may take some time for tables with large number of entries (>~ 10^6)
288*/
289void BaseDataTable::Show(ostream& os) const
290{
291 os << "BaseDataTable: NVar= " << NVar() << " NEnt= " << NEntry()
292 << " ( SegSize= " << SegmentSize() << " NbSegments= "
293 << NbSegments() << " )" << endl;
294 os << "--------------------------------------------------------------------" << endl;
295 os << setw(3) << "i" << ":" << setw(20) << " Name" << " ("
296 << setw(4) << "Type" << ") | "
297 << setw(15) << " Min " << " | " << setw(15) << " Max " << endl;
298 os << "--------------------------------------------------------------------" << endl;
299 r_8 min, max ;
300 for(sa_size_t i = 0 ; i < NVar() ; i++) {
301 GetMinMax(i, min, max) ;
302 string nom;
303 if (mNames[i].nom.length() > 20)
304 nom = mNames[i].nom.substr(20);
305 else nom = mNames[i].nom;
306 os << setw(3) << i << ":" << setw(20) << nom << " ("
307 << setw(4) << ColTypeToString(mNames[i].type) << ") | "
308 << setw(15) << min << " | " << setw(15) << max << endl;
309 }
310 os << "--------------------------------------------------------------------" << endl;
311 return;
312}
313
314//! NOT YET IMPLEMENTED ! - Fills table from an ascii file
315int BaseDataTable::FillFromASCIIFile(string const& fn)
316// Remplit le ntuple a partir d'un fichier ASCII.
317// Renvoie le nombre de lignes ajoutees.
318{
319// a faire
320return(0);
321}
322
323
324
325//
326// ------------------------------------
327// ------- Interface NTuple -----------
328// ------------------------------------
329//
330sa_size_t BaseDataTable::NbLines() const
331{
332 return(NEntry());
333}
334
335sa_size_t BaseDataTable::NbColumns() const
336{
337 return(NVar());
338}
339
340r_8* BaseDataTable::GetLineD(sa_size_t n) const
341{
342 if ((n < 0) || (n >= NEntry()))
343 throw RangeCheckError("BaseDataTable::GetLineD() out of range line index n");
344 if (mVarD == NULL) mVarD = new r_8[NVar()];
345
346 sa_size_t bid = n/mSegSz;
347 sa_size_t off = n%mSegSz;
348 for(sa_size_t k=0; k<mIColsP.size(); k++)
349 mVarD[mIColIdx[k]] = mIColsP[k]->GetCstSegment(bid)[off];
350 for(sa_size_t k=0; k<mLColsP.size(); k++)
351 mVarD[mLColIdx[k]] = mLColsP[k]->GetCstSegment(bid)[off];
352 for(sa_size_t k=0; k<mFColsP.size(); k++)
353 mVarD[mFColIdx[k]] = mFColsP[k]->GetCstSegment(bid)[off];
354 for(sa_size_t k=0; k<mDColsP.size(); k++)
355 mVarD[mDColIdx[k]] = mDColsP[k]->GetCstSegment(bid)[off];
356 for(sa_size_t k=0; k<mYColsP.size(); k++)
357 mVarD[mYColIdx[k]] = mYColsP[k]->GetCstSegment(bid)[off].real();
358 for(sa_size_t k=0; k<mZColsP.size(); k++)
359 mVarD[mZColIdx[k]] = mZColsP[k]->GetCstSegment(bid)[off].real();
360 for(sa_size_t k=0; k<mSColsP.size(); k++)
361 mVarD[mSColIdx[k]] = atof(mSColsP[k]->GetCstSegment(bid)[off].c_str());
362
363 return mVarD;
364}
365
366#define BADVAL -1.e39
367
368r_8 BaseDataTable::GetCell(sa_size_t n, sa_size_t k) const
369{
370 if ((n < 0) || (n >= NEntry()))
371 throw RangeCheckError("BaseDataTable::GetCell() out of range line index n");
372 if ((k < 0) || (k >= NVar()))
373 throw RangeCheckError("BaseDataTable::GetCell() out of range column index k");
374 double rv = BADVAL;
375 sa_size_t sk = mNames[k].ser;
376 sa_size_t bid = n/mSegSz;
377 sa_size_t off = n%mSegSz;
378
379 switch (mNames[k].type) {
380 case IntegerField :
381 rv = mIColsP[sk]->GetCstSegment(bid)[off];
382 break;
383 case LongField :
384 rv = mLColsP[sk]->GetCstSegment(bid)[off];
385 break;
386 case FloatField :
387 rv = mFColsP[sk]->GetCstSegment(bid)[off];
388 break;
389 case DoubleField :
390 case DateField :
391 rv = mDColsP[sk]->GetCstSegment(bid)[off];
392 break;
393 case ComplexField :
394 rv = mYColsP[sk]->GetCstSegment(bid)[off].real();
395 break;
396 case DoubleComplexField :
397 rv = mZColsP[sk]->GetCstSegment(bid)[off].real();
398 break;
399 case StringField :
400 rv = atof(mSColsP[sk]->GetCstSegment(bid)[off].c_str());
401 break;
402 default:
403 rv = BADVAL;
404 break;
405 }
406 return rv ;
407}
408
409
410r_8 BaseDataTable::GetCell(sa_size_t n, string const& nom) const
411{
412 return GetCell(n, IndexNom(nom));
413}
414
415string BaseDataTable::GetCelltoString(sa_size_t n, sa_size_t k) const
416{
417 if ((n < 0) || (n >= NEntry()))
418 throw RangeCheckError("BaseDataTable::GetCell() out of range line index n");
419 if ((k < 0) || (k >= NVar()))
420 throw RangeCheckError("BaseDataTable::GetCell() out of range column index k");
421 MuTyV rv;;
422 sa_size_t sk = mNames[k].ser;
423 sa_size_t bid = n/mSegSz;
424 sa_size_t off = n%mSegSz;
425 switch (mNames[k].type) {
426 case IntegerField :
427 rv = mIColsP[sk]->GetCstSegment(bid)[off];
428 break;
429 case LongField :
430 rv = mLColsP[sk]->GetCstSegment(bid)[off];
431 break;
432 case FloatField :
433 rv = mFColsP[sk]->GetCstSegment(bid)[off];
434 break;
435 case DoubleField :
436 rv = mDColsP[sk]->GetCstSegment(bid)[off];
437 break;
438 case ComplexField :
439 rv = mYColsP[sk]->GetCstSegment(bid)[off];
440 break;
441 case DoubleComplexField :
442 rv = mZColsP[sk]->GetCstSegment(bid)[off];
443 break;
444 case StringField :
445 rv = mSColsP[sk]->GetCstSegment(bid)[off];
446 break;
447 default:
448 rv = " ";
449 break;
450 }
451 return (string)rv ;
452}
453
454void BaseDataTable::GetMinMax(sa_size_t k, double& min, double& max) const
455{
456 min = 9E39 ; max = -9E39 ;
457 if ((k < 0) || (k >= NVar()))
458 throw RangeCheckError("BaseDataTable::GetCell() out of range column index k");
459 if (mMinMaxNEnt.size() < NVar()) {
460 mMin.clear();
461 mMax.clear();
462 mMinMaxNEnt.clear();
463 for(size_t kk=0; kk<NVar(); kk++) {
464 mMin.push_back(0.);
465 mMax.push_back(0.);
466 mMinMaxNEnt.push_back(0);
467 }
468 }
469 if (mMinMaxNEnt[k] == mNEnt) {
470 min = mMin[k];
471 max = mMax[k];
472 return;
473 }
474 sa_size_t sk = mNames[k].ser;
475
476 sa_size_t cnt = 0;
477 switch (mNames[k].type) {
478 case IntegerField :
479 for(size_t is=0; is<mIColsP[sk]->NbSegments(); is++) {
480 const int_4* sp = mIColsP[sk]->GetCstSegment(is);
481 for(size_t n=0; n<mIColsP[sk]->SegmentSize(); n++) {
482 if (cnt >= NEntry()) break;
483 if (sp[n] > max) max = sp[n];
484 if (sp[n] < min) min = sp[n];
485 cnt++;
486 }
487 }
488
489 break;
490 case LongField :
491 for(size_t is=0; is<mLColsP[sk]->NbSegments(); is++) {
492 const int_8* sp = mLColsP[sk]->GetCstSegment(is);
493 for(size_t n=0; n<mLColsP[sk]->SegmentSize(); n++) {
494 if (cnt >= NEntry()) break;
495 if (sp[n] > max) max = sp[n];
496 if (sp[n] < min) min = sp[n];
497 cnt++;
498 }
499 }
500 break;
501 case FloatField :
502 for(size_t is=0; is<mFColsP[sk]->NbSegments(); is++) {
503 const r_4* sp = mFColsP[sk]->GetCstSegment(is);
504 for(size_t n=0; n<mFColsP[sk]->SegmentSize(); n++) {
505 if (cnt >= NEntry()) break;
506 if (sp[n] > max) max = sp[n];
507 if (sp[n] < min) min = sp[n];
508 cnt++;
509 }
510 }
511 break;
512 case DoubleField :
513 for(size_t is=0; is<mDColsP[sk]->NbSegments(); is++) {
514 const r_8* sp = mDColsP[sk]->GetCstSegment(is);
515 for(size_t n=0; n<mDColsP[sk]->SegmentSize(); n++) {
516 if (cnt >= NEntry()) break;
517 if (sp[n] > max) max = sp[n];
518 if (sp[n] < min) min = sp[n];
519 cnt++;
520 }
521 }
522 break;
523 case ComplexField :
524 for(size_t is=0; is<mYColsP[sk]->NbSegments(); is++) {
525 const complex<r_4> * sp = mYColsP[sk]->GetCstSegment(is);
526 for(size_t n=0; n<mYColsP[sk]->SegmentSize(); n++) {
527 if (cnt >= NEntry()) break;
528 if (sp[n].real() > max) max = sp[n].real();
529 if (sp[n].real() < min) min = sp[n].real();
530 cnt++;
531 }
532 }
533 break;
534 case DoubleComplexField :
535 for(size_t is=0; is<mZColsP[sk]->NbSegments(); is++) {
536 const complex<r_8> * sp = mZColsP[sk]->GetCstSegment(is);
537 for(size_t n=0; n<mZColsP[sk]->SegmentSize(); n++) {
538 if (cnt >= NEntry()) break;
539 if (sp[n].real() > max) max = sp[n].real();
540 if (sp[n].real() < min) min = sp[n].real();
541 cnt++;
542 }
543 }
544 break;
545 case StringField :
546 return;
547 break;
548 default:
549 return;
550 break;
551 }
552
553 mMinMaxNEnt[k] = cnt;
554 mMin[k] = min;
555 mMax[k] = max;
556 return ;
557}
558
559
560void BaseDataTable::GetMinMax(string const & nom, double& min, double& max) const
561{
562 GetMinMax(IndexNom(nom), min, max) ;
563}
564
565
566sa_size_t BaseDataTable::ColumnIndex(string const& nom) const
567{
568 return IndexNom(nom) ;
569}
570
571
572string BaseDataTable::ColumnName(sa_size_t k) const
573{
574 return NomIndex(k) ;
575}
576
577
578string BaseDataTable::VarList_C(const char* nomx) const
579{
580 string rets="";
581 sa_size_t i;
582 for(i=0; i<NVar(); i++) {
583 if ( (i%5 == 0) && (i > 0) ) rets += ";";
584 if (i%5 == 0) rets += "\ndouble ";
585 else rets += ",";
586 rets += mNames[i].nom;
587 }
588 rets += "; \n";
589 if (nomx) {
590 char buff[256];
591 for(i=0; i<NVar(); i++) {
592 rets += mNames[i].nom;
593 rets += '=';
594
595 sprintf(buff,"%s[%ld]; ", nomx, (long)i);
596 rets += buff;
597 if ( (i%3 == 0) && (i > 0) ) rets += "\n";
598 }
599 }
600 return(rets);
601}
602
603
604string BaseDataTable::LineHeaderToString() const
605{
606 string rets,s;
607
608 for(int i=0; i<NVar(); i++) {
609 s = mNames[i].nom;
610 s += ' ';
611 size_t l = s.length();
612 for(size_t ii=l; ii<10; ii++) s += ' ';
613 rets += s;
614 }
615 return(rets);
616}
617
618
619string BaseDataTable::LineToString(sa_size_t n) const
620{
621 if ((n < 0) || (n >= NEntry()))
622 throw RangeCheckError("BaseDataTable::GetCell() out of range line index n");
623 string rs;
624 MuTyV rv;;
625 sa_size_t bid = n/mSegSz;
626 sa_size_t off = n%mSegSz;
627 for(sa_size_t k=0; k<NVar(); k++) {
628 sa_size_t sk = mNames[k].ser;
629 switch (mNames[k].type) {
630 case IntegerField :
631 rv = mIColsP[sk]->GetCstSegment(bid)[off];
632 break;
633 case LongField :
634 rv = mLColsP[sk]->GetCstSegment(bid)[off];
635 break;
636 case FloatField :
637 rv = mFColsP[sk]->GetCstSegment(bid)[off];
638 break;
639 case DoubleField :
640 rv = mDColsP[sk]->GetCstSegment(bid)[off];
641 break;
642 case ComplexField :
643 rv = mYColsP[sk]->GetCstSegment(bid)[off];
644 break;
645 case DoubleComplexField :
646 rv = mZColsP[sk]->GetCstSegment(bid)[off];
647 break;
648 case StringField :
649 rv = mSColsP[sk]->GetCstSegment(bid)[off];
650 break;
651 default:
652 rv = " ";
653 break;
654 }
655 string s = (string)rv;
656 s += ' ';
657 size_t l = s.length();
658 for(size_t ii=l; ii<10; ii++) s += ' ';
659 rs += s;
660 }
661 return rs;
662}
663
Note: See TracBrowser for help on using the repository browser.