Index: trunk/SophyaLib/TArray/basarr.cc
===================================================================
--- trunk/SophyaLib/TArray/basarr.cc	(revision 1103)
+++ trunk/SophyaLib/TArray/basarr.cc	(revision 1156)
@@ -21,9 +21,9 @@
      {"???", "Size(int )", "IsPacked(int )"
      ,"Stride(int )", "ElemCheckBound()", "operator()" };
-uint_4 BaseArray::max_nprt_ = 50;
-uint_4 BaseArray::prt_lev_ = 0;
+int_4  BaseArray::max_nprt_ = 50;
+int_4  BaseArray::prt_lev_ = 0;
 short  BaseArray::default_memory_mapping = CMemoryMapping;
 short  BaseArray::default_vector_type = ColumnVector;
-uint_8 BaseArray::openmp_size_threshold = 200000;
+sa_size_t BaseArray::openmp_size_threshold = 200000;
 
 // ------ Methodes statiques globales --------
@@ -34,5 +34,5 @@
   \param lev  : print level
 */
-void BaseArray::SetMaxPrint(uint_4 nprt, uint_4 lev)
+void BaseArray::SetMaxPrint(int_4 nprt, int_4 lev)
 {
   max_nprt_ = nprt;
@@ -44,5 +44,5 @@
   \param thr : thresold value
 */
-void BaseArray::SetOpenMPSizeThreshold(uint_8 thr)
+void BaseArray::SetOpenMPSizeThreshold(sa_size_t thr)
 {
   openmp_size_threshold = thr;
@@ -58,8 +58,8 @@
   \return Total size of the array
 */
-uint_8 BaseArray::ComputeTotalSize(uint_4 ndim, const uint_4 * siz, uint_4 step, uint_8 offset)
-{
-  uint_8 rs = step;
-  for(uint_4 k=0; k<ndim; k++) rs *= siz[k];
+sa_size_t BaseArray::ComputeTotalSize(int_4 ndim, const sa_size_t * siz, sa_size_t step, sa_size_t offset)
+{
+  sa_size_t rs = step;
+  for(sa_size_t k=0; k<ndim; k++) rs *= siz[k];
   return(rs+offset);
 }
@@ -251,5 +251,5 @@
 {
   ndim_ = 0;
-  for(int k=0; k<BASEARRAY_MAXNDIMS; k++) step_[k] = size_[k] = 0;
+  for(int_4 k=0; k<BASEARRAY_MAXNDIMS; k++) step_[k] = size_[k] = 0;
   totsize_ = 0;
   minstep_ = 0;
@@ -295,5 +295,5 @@
   if (arrtype_ == 0) {  // Simple TArray, not a matrix 
     smo = true;
-    for(uint_4 k=0; k<ndim_; k++) 
+    for(int_4 k=0; k<ndim_; k++) 
       if (size_[k] != a.size_[k])  return(false);
     return(true);
@@ -304,5 +304,5 @@
 	 (size_[macoli_] != a.size_[a.macoli_])  ) return(false);
     if (ndim_ > 2)  
-      for(uint_4 k=2; k<ndim_; k++) 
+      for(int_4 k=2; k<ndim_; k++) 
 	if (size_[k] != a.size_[k])  return(false);
     if ( (macoli_ == a.macoli_) && (marowi_ == a.marowi_) ||
@@ -316,8 +316,8 @@
 {
   if (ndim_ < 2)  return;
-  uint_4 ndim = 0;
-  uint_4 size[BASEARRAY_MAXNDIMS];
-  uint_4 step[BASEARRAY_MAXNDIMS];
-  for(uint_4 k=0; k<ndim_; k++) {
+  int_4 ndim = 0;
+  sa_size_t size[BASEARRAY_MAXNDIMS];
+  sa_size_t step[BASEARRAY_MAXNDIMS];
+  for(int_4 k=0; k<ndim_; k++) {
     if (size_[k] < 2)  continue;
     size[ndim] = size_[k];
@@ -339,8 +339,8 @@
 {
   if (ndim_ < 2)  return;
-  uint_4 ndim = 0;
-  uint_4 size[BASEARRAY_MAXNDIMS];
-  uint_4 step[BASEARRAY_MAXNDIMS];
-  for(uint_4 k=0; k<ndim_; k++) {
+  int_4 ndim = 0;
+  sa_size_t size[BASEARRAY_MAXNDIMS];
+  sa_size_t step[BASEARRAY_MAXNDIMS];
+  for(int_4 k=0; k<ndim_; k++) {
     size[ndim] = size_[k];
     step[ndim] = step_[k];
@@ -354,7 +354,7 @@
 
 //! return minimum value for step[ndim]
-int  BaseArray::MinStepKA() const
-{
-  for(uint_4 ka=0; ka<ndim_; ka++)
+int_4  BaseArray::MinStepKA() const
+{
+  for(int_4 ka=0; ka<ndim_; ka++)
     if (step_[ka] == minstep_) return((int)ka);
   return(0);
@@ -362,9 +362,9 @@
 
 //! return maximum value for step[ndim]
-int  BaseArray::MaxSizeKA() const
-{
-  int ka = 0;
-  uint_4 mx = size_[0];
-  for(uint_4 k=1; k<ndim_; k++)  
+int_4  BaseArray::MaxSizeKA() const
+{
+  int_4 ka = 0;
+  sa_size_t mx = size_[0];
+  for(int_4 k=1; k<ndim_; k++)  
     if (size_[k] > mx) {  ka = k;  mx = size_[k]; } 
   return(ka);
@@ -377,5 +377,5 @@
 // --------------------------------------------------
 //! return position of first element for vector \b i alond \b ka th axe.
-uint_8 BaseArray::Offset(uint_4 ka, uint_8 i) const
+sa_size_t BaseArray::Offset(int_4 ka, sa_size_t i) const
 {
 
@@ -383,11 +383,11 @@
   //#ifdef SO_BOUNDCHECKING
   if (ka >= ndim_) 
-    throw RangeCheckError("BaseArray::Offset(uint_4 ka, uint_8 i) Axe KA Error");
+    throw RangeCheckError("BaseArray::Offset(int_4 ka, sa_size_t i) Axe KA Error");
   if ( i*size_[ka] >= totsize_ )  
-    throw RangeCheckError("BaseArray::Offset(uint_4 ka, uint_8 i) Index Error");
+    throw RangeCheckError("BaseArray::Offset(int_4 ka, sa_size_t i) Index Error");
   //#endif
-  uint_4 idx[BASEARRAY_MAXNDIMS];
-  uint_4 k;
-  uint_8 rest = i;
+  sa_size_t idx[BASEARRAY_MAXNDIMS];
+  int_4 k;
+  sa_size_t rest = i;
   idx[ka] = 0;
   for(k=0; k<ndim_; k++) {
@@ -395,5 +395,5 @@
     idx[k] = rest%size_[k];   rest /= size_[k];
   }
-  uint_8 off = offset_;
+  sa_size_t off = offset_;
   for(k=0; k<ndim_; k++)  off += idx[k]*step_[k];
   return (off);
@@ -401,15 +401,15 @@
 
 //! return position of element \b ip.
-uint_8 BaseArray::Offset(uint_8 ip) const
+sa_size_t BaseArray::Offset(sa_size_t ip) const
 {
   if ( (ndim_ < 1) || (ip == 0) )  return(offset_);
   //#ifdef SO_BOUNDCHECKING
   if (ip >= totsize_)
-    throw RangeCheckError("BaseArray::Offset(uint_8 ip) Out of range index ip");
+    throw RangeCheckError("BaseArray::Offset(sa_size_t ip) Out of range index ip");
   //#endif
 
-  uint_4 idx[BASEARRAY_MAXNDIMS];
-  uint_4 k;
-  uint_8 rest = ip;
+  sa_size_t idx[BASEARRAY_MAXNDIMS];
+  int_4 k;
+  sa_size_t rest = ip;
   for(k=0; k<ndim_; k++) {
     idx[k] = rest%size_[k];   rest /= size_[k];
@@ -417,5 +417,5 @@
   //#ifdef SO_BOUNDCHECKING
   if (rest != 0) 
-    throw PError("BaseArray::Offset(uint_8 ip) GUG !!! rest != 0");
+    throw PError("BaseArray::Offset(sa_size_t ip) GUG !!! rest != 0");
   //#endif
 //   if (rest != 0) cerr << " BUG ---- BaseArray::Offset( " << ip << " )" << rest << endl;
@@ -423,5 +423,5 @@
 //   for(k=0; k<ndim_; k++) cerr << idx[k] << "," ;
 //   cerr << " ZZZZ " << endl;
-  uint_8 off = offset_;
+  sa_size_t off = offset_;
   for(k=0; k<ndim_; k++)  off += idx[k]*step_[k];
   return (off);
@@ -429,6 +429,6 @@
 
 //! return various parameters for double loop operations on two arrays.
-void BaseArray::GetOpeParams(const BaseArray& a, bool smo, int& ax, int& axa, uint_8& step,
-			     uint_8& stepa, uint_8& gpas, uint_8& naxa)
+void BaseArray::GetOpeParams(const BaseArray& a, bool smo, int_4& ax, int_4& axa, sa_size_t& step,
+			     sa_size_t& stepa, sa_size_t& gpas, sa_size_t& naxa)
 {
   if (smo) { // Same memory organisation
@@ -465,5 +465,5 @@
   os << "\n--- " << InfoString() ; 
   os << " ND=" << ndim_ << " SizeX*Y*...= " ;
-  for(uint_4 k=0; k<ndim_; k++) { 
+  for(int_4 k=0; k<ndim_; k++) { 
     os << size_[k];
     if (k<ndim_-1)  os << "x";
@@ -472,5 +472,5 @@
   if (prt_lev_ > 0) {
     os <<  " TotSize= " << totsize_ << " Step(X Y ...)="  ;
-    for(uint_4 k=0; k<ndim_; k++)     os << step_[k] << "  " ;
+    for(int_4 k=0; k<ndim_; k++)     os << step_[k] << "  " ;
     os << " Offset= " << offset_  << endl;
   }
@@ -509,5 +509,5 @@
   \return string \b exmsg for explanation in case of problems
  */
-bool BaseArray::UpdateSizes(uint_4 ndim, const uint_4 * siz, uint_4 step, uint_8 offset, string & exmsg)
+bool BaseArray::UpdateSizes(int_4 ndim, const sa_size_t * siz, sa_size_t step, sa_size_t offset, string & exmsg)
 {
   if (ndim >= BASEARRAY_MAXNDIMS) {
@@ -524,5 +524,5 @@
 
   totsize_ = 1;
-  uint_4 k;
+  int_4 k;
   for(k=0; k<BASEARRAY_MAXNDIMS; k++) {
     size_[k] = 1;
@@ -560,5 +560,5 @@
   \return string \b exmsg for explanation in case of problems
  */
-bool BaseArray::UpdateSizes(uint_4 ndim, const uint_4 * siz, const uint_4 * step, uint_8 offset, string & exmsg)
+bool BaseArray::UpdateSizes(int_4 ndim, const sa_size_t * siz, const sa_size_t * step, sa_size_t offset, string & exmsg)
 {
   if (ndim >= BASEARRAY_MAXNDIMS) {
@@ -570,10 +570,10 @@
 
   totsize_ = 1;
-  uint_4 k;
+  int_4 k;
   for(k=0; k<BASEARRAY_MAXNDIMS; k++) {
     size_[k] = 1;
     step_[k] = 0;
   }
-  uint_4 minstep = step[0];
+  sa_size_t minstep = step[0];
   for(k=0; k<ndim; k++) {
     size_[k] = siz[k] ;
@@ -588,5 +588,5 @@
     exmsg += " Size Error";  return false;
   }
-  uint_8 plast = 0;
+  sa_size_t plast = 0;
   for(k=0; k<ndim; k++)   plast += (siz[k]-1)*step[k];
   if (plast == minstep*totsize_ )  moystep_ = minstep;
@@ -623,10 +623,10 @@
 
   totsize_ = 1;
-  uint_4 k;
+  int_4 k;
   for(k=0; k<BASEARRAY_MAXNDIMS; k++) {
     size_[k] = 1;
     step_[k] = 0;
   }
-  uint_4 minstep = a.step_[0];
+  sa_size_t minstep = a.step_[0];
   for(k=0; k<a.ndim_; k++) {
     size_[k] = a.size_[k] ;
@@ -663,13 +663,13 @@
   \return string \b exmsg for explanation in case of problems
  */
-void BaseArray::UpdateSubArraySizes(BaseArray & ra, uint_4 ndim, uint_4 * siz, uint_4 * pos, uint_4 * step) const
+void BaseArray::UpdateSubArraySizes(BaseArray & ra, int_4 ndim, sa_size_t * siz, sa_size_t * pos, sa_size_t * step) const
 {
   if ( (ndim > ndim_) || (ndim < 1) ) 
     throw(SzMismatchError("BaseArray::UpdateSubArraySizes( ... ) NDim Error") );
-  uint_4 k;
+  int_4 k;
   for(k=0; k<ndim; k++) 
     if ( (siz[k]*step[k]+pos[k]) > size_[k] )  
       throw(SzMismatchError("BaseArray::UpdateSubArraySizes( ... ) Size/Pos Error") );
-  uint_8 offset = offset_;
+  sa_size_t offset = offset_;
   for(k=0; k<ndim_; k++) { 
     offset += pos[k]*step_[k]; 
