10 const int OPT_LOG = 0x01;
\r
11 const int OPT_EXP = 0x02;
\r
12 const int OPT_ZERO_BASED = 0x04;
\r
13 const float MINUS_INFINITY = -9e9f;
\r
14 const float UNINIT = -8e8f;
\r
18 template<class T> const char *TypeToStr(T t)
\r
20 Die("Unspecialised TypeToStr() called");
\r
24 template<> inline const char *TypeToStr<unsigned short>(unsigned short f)
\r
28 sprintf(s, "%12u", f);
\r
32 template<> inline const char *TypeToStr<short>(short f)
\r
36 sprintf(s, "%12d", f);
\r
40 template<> inline const char *TypeToStr<int>(int f)
\r
44 sprintf(s, "%5d", f);
\r
48 template<> inline const char *TypeToStr<float>(float f)
\r
53 sprintf(s, "%12.12s", "?");
\r
54 else if (f < MINUS_INFINITY/2)
\r
55 sprintf(s, "%12.12s", "*");
\r
57 sprintf(s, "%12.12s", ".");
\r
58 else if (f >= -1e5 && f <= 1e5)
\r
59 sprintf(s, "%12.5f", f);
\r
61 sprintf(s, "%12.4g", f);
\r
65 template<> inline const char *TypeToStr<double>(double f)
\r
70 sprintf(s, "%12.12s", "*");
\r
72 sprintf(s, "%12.12s", ".");
\r
73 else if (f >= -1e-5 && f <= 1e5)
\r
74 sprintf(s, "%12.5f", f);
\r
76 sprintf(s, "%12.4g", f);
\r
80 static inline const char *FloatToStr(float f, string &s)
\r
82 s = TypeToStr<float>(f);
\r
86 template<> inline const char *TypeToStr<char>(char c)
\r
93 template<> inline const char *TypeToStr<byte>(byte c)
\r
100 template<> inline const char *TypeToStr<bool>(bool tof)
\r
103 s[0] = tof ? 'T' : 'F';
\r
112 MxBase(const MxBase &rhs);
\r
113 MxBase &operator=(const MxBase &rhs);
\r
119 unsigned m_RowCount;
\r
120 unsigned m_ColCount;
\r
121 unsigned m_AllocatedRowCount;
\r
122 unsigned m_AllocatedColCount;
\r
123 const SeqDB *m_SeqDB;
\r
126 const SeqData *m_SA;
\r
127 const SeqData *m_SB;
\r
129 static list<MxBase *> *m_Matrices;
\r
130 //static MxBase *Get(const string &Name);
\r
131 //static float **Getf(const string &Name);
\r
132 //static double **Getd(const string &Name);
\r
133 //static char **Getc(const string &Name);
\r
135 static unsigned m_AllocCount;
\r
136 static unsigned m_ZeroAllocCount;
\r
137 static unsigned m_GrowAllocCount;
\r
138 static double m_TotalBytes;
\r
139 static double m_MaxBytes;
\r
141 static void OnCtor(MxBase *Mx);
\r
142 static void OnDtor(MxBase *Mx);
\r
146 m_AllocatedRowCount = 0;
\r
147 m_AllocatedColCount = 0;
\r
160 virtual unsigned GetTypeSize() const = 0;
\r
161 virtual unsigned GetBytes() const = 0;
\r
166 m_AllocatedRowCount = 0;
\r
167 m_AllocatedColCount = 0;
\r
178 return m_RowCount == 0;
\r
181 virtual void AllocData(unsigned RowCount, unsigned ColCount) = 0;
\r
182 virtual void FreeData() = 0;
\r
183 virtual const char *GetAsStr(unsigned i, unsigned j) const = 0;
\r
185 void SetAlpha(const char *Alpha)
\r
187 unsigned n = sizeof(m_Alpha);
\r
188 strncpy(m_Alpha, Alpha, n);
\r
192 void Alloc(const char *Name, unsigned RowCount, unsigned ColCount,
\r
193 const SeqDB *DB, unsigned IdA, unsigned IdB,
\r
194 const SeqData *SA, const SeqData *SB);
\r
196 void Alloc(const char *Name, unsigned RowCount, unsigned ColCount,
\r
197 const SeqDB *DB = 0, unsigned IdA = UINT_MAX, unsigned IdB = UINT_MAX);
\r
199 void Alloc(const char *Name, unsigned RowCount, unsigned ColCount,
\r
200 const SeqData *SA, const SeqData *SB);
\r
202 static void LogAll()
\r
205 if (m_Matrices == 0)
\r
207 Log("MxBase::m_Matrices=0\n");
\r
211 Log("AllRows AllCols Sz MB Name\n");
\r
212 Log("------- ------- ---- -------- ----\n");
\r
213 double TotalMB = 0;
\r
214 for (list<MxBase *>::const_iterator p = m_Matrices->begin();
\r
215 p != m_Matrices->end(); ++p)
\r
217 const MxBase *Mx = *p;
\r
220 //if (Mx->m_RowCount != 0 || ShowEmpty)
\r
221 // Mx->LogMe(WithData);
\r
222 unsigned ar = Mx->m_AllocatedRowCount;
\r
225 unsigned ac = Mx->m_AllocatedColCount;
\r
226 unsigned sz = Mx->GetTypeSize();
\r
227 double MB = (double) ar*(double) ac*(double) sz/1e6;
\r
229 Log("%7u %7u %4u %8.2f %s\n", ar, ac, sz, MB, Mx->m_Name);
\r
231 Log(" --------\n");
\r
232 Log("%7.7s %7.7s %4.4s %8.2f\n", "", "", "", TotalMB);
\r
235 void LogMe(bool WithData = true, int Opts = 0) const;
\r
236 static void LogCounts();
\r
239 template<class T> struct Mx : public MxBase
\r
241 // Disable unimplemented stuff
\r
244 Mx &operator=(Mx &rhs);
\r
245 // const Mx &operator=(const Mx &rhs) const;
\r
260 virtual void AllocData(unsigned RowCount, unsigned ColCount)
\r
262 if (opt_logmemgrows)
\r
263 Log("MxBase::AllocData(%u,%u) %s bytes, Name=%s\n",
\r
264 RowCount, ColCount, IntToStr(GetBytes()), m_Name);
\r
265 // m_Data = myalloc<T *>(RowCount);
\r
266 m_Data = MYALLOC(T *, RowCount, Mx);
\r
267 for (unsigned i = 0; i < RowCount; ++i)
\r
268 // m_Data[i] = myalloc<T>(ColCount);
\r
269 m_Data[i] = MYALLOC(T, ColCount, Mx);
\r
270 AddBytes("Mx_AllocData", RowCount*sizeof(T *) + RowCount*ColCount*sizeof(T));
\r
272 m_AllocatedRowCount = RowCount;
\r
273 m_AllocatedColCount = ColCount;
\r
276 virtual void FreeData()
\r
278 for (unsigned i = 0; i < m_AllocatedRowCount; ++i)
\r
279 MYFREE(m_Data[i], m_AllocatedColCount, Mx);
\r
280 MYFREE(m_Data, m_AllocatedRowCount, Mx);
\r
281 SubBytes("Mx_AllocData",
\r
282 m_AllocatedRowCount*sizeof(T *) + m_AllocatedRowCount*m_AllocatedColCount*sizeof(T));
\r
287 m_AllocatedRowCount = 0;
\r
288 m_AllocatedColCount = 0;
\r
293 return (T **) m_Data;
\r
296 T Get(unsigned i, unsigned j) const
\r
298 assert(i < m_RowCount);
\r
299 assert(j < m_ColCount);
\r
300 return m_Data[i][j];
\r
303 void Put(unsigned i, unsigned j, T x) const
\r
305 assert(i < m_RowCount);
\r
306 assert(j < m_ColCount);
\r
310 T GetOffDiagAvgs(vector<T> &Avgs) const
\r
312 if (m_RowCount != m_ColCount)
\r
313 Die("GetOffDiagAvgs, not symmetrical");
\r
316 for (unsigned i = 0; i < m_RowCount; ++i)
\r
319 for (unsigned j = 0; j < m_ColCount; ++j)
\r
323 Sum += m_Data[i][j];
\r
325 T Avg = Sum/(m_RowCount-1);
\r
327 Avgs.push_back(Avg);
\r
329 return m_RowCount == 0 ? T(0) : Total/m_RowCount;
\r
332 unsigned GetTypeSize() const
\r
337 virtual unsigned GetBytes() const
\r
339 return m_AllocatedRowCount*m_AllocatedColCount*GetTypeSize() +
\r
340 m_AllocatedRowCount*sizeof(T *);
\r
343 const char *GetAsStr(unsigned i, unsigned j) const
\r
345 return TypeToStr<T>(Get(i, j));
\r
348 const T *const *const GetData() const
\r
350 return (const T *const *) m_Data;
\r
353 void Copy(const Mx<T> &rhs)
\r
355 Alloc("Copy", rhs.m_RowCount, rhs.m_ColCount, rhs.m_SeqDB, rhs.m_IdA, rhs.m_IdB);
\r
356 const T * const *Data = rhs.GetData();
\r
357 for (unsigned i = 0; i < m_RowCount; ++i)
\r
358 for (unsigned j = 0; j < m_ColCount; ++j)
\r
359 m_Data[i][j] = Data[i][j];
\r
364 for (unsigned i = 0; i < m_RowCount; ++i)
\r
365 for (unsigned j = 0; j < m_ColCount; ++j)
\r
369 bool Eq(const Mx &rhs, bool Bwd = false) const
\r
371 if (rhs.m_ColCount != m_ColCount)
\r
373 if (rhs.m_RowCount != m_RowCount)
\r
375 const T * const*d = rhs.GetData();
\r
376 int i1 = Bwd ? m_RowCount : 0;
\r
377 int j1 = Bwd ? m_ColCount : 0;
\r
378 int i2 = Bwd ? -1 : m_RowCount;
\r
379 int j2 = Bwd ? -1 : m_ColCount;
\r
380 for (int i = i1; i != i2; Bwd ? --i : ++i)
\r
381 for (int j = j1; j != j2; Bwd ? --j : ++j)
\r
383 float x = m_Data[i][j];
\r
385 if (x < -1e10 && y < -1e10)
\r
389 Warning("%s[%d][%d] = %g, %s = %g",
\r
390 m_Name, i, j, x, rhs.m_Name, y);
\r
397 bool EqMask(const Mx &rhs, const Mx<bool> &Mask) const
\r
399 if (rhs.m_ColCount != m_ColCount)
\r
401 if (rhs.m_RowCount != m_RowCount)
\r
404 if (Mask.m_ColCount != m_ColCount)
\r
406 if (Mask.m_RowCount != m_RowCount)
\r
409 const T * const*d = rhs.GetData();
\r
411 int i1 = Bwd ? m_RowCount : 0;
\r
412 int j1 = Bwd ? m_ColCount : 0;
\r
413 int i2 = Bwd ? -1 : m_RowCount;
\r
414 int j2 = Bwd ? -1 : m_ColCount;
\r
415 for (int i = i1; i != i2; Bwd ? --i : ++i)
\r
416 for (int j = j1; j != j2; Bwd ? --j : ++j)
\r
418 if (!Mask.m_Data[i][j])
\r
420 float x = m_Data[i][j];
\r
422 if (x < -1e10 && y < -1e10)
\r
426 Warning("%s[%d][%d] = %g, %s = %g",
\r
427 m_Name, i, j, x, rhs.m_Name, y);
\r
436 for (unsigned i = 0; i < m_RowCount; ++i)
\r
437 for (unsigned j = 0; j < m_ColCount; ++j)
\r
442 void WriteMx(const string &Name, Mx<float> &Mxf);
\r
444 template<class T> void ReserveMx(Mx<T> &Mxf, unsigned N = UINT_MAX)
\r
446 if (Mxf.m_AllocatedRowCount > 0)
\r
448 extern unsigned g_MaxInputSeqLength;
\r
450 N = g_MaxInputSeqLength+1;
\r
451 Mxf.Alloc("(Reserved)", N, N);
\r