fx_matr2.h

可重用的向量/矩阵类代码,这是一个灵活的向量/矩阵类代码

           << "First matrix : " 
           << rowsVector_.gstrObjectLocationShow () 
           << endl;
	
      cerr << endl
           << "Second matrix : " 
           << ((ClassFlexibleMatrix&)instance_i).rowsVector_.gstrObjectLocationShow () 
           << endl;
	

      return *this;
      ASSERT (0);	// Currently unused
    } // if (!((totalRows () == ... 

    emptyRow_ = ((ClassFlexibleMatrix&)instance_i).emptyRow_;
    rowsVector_ = ((ClassFlexibleMatrix&)instance_i).rowsVector_;

  } // else - if (empty ())

  return *this;
} // ClassFlexibleMatrix<T>& ClassFlexibleMatrix<T>::operator= (const ClassFlexibleMatrix& instance_i)



//==================
template <class T>
ClassFlexibleMatrix<T>& ClassFlexibleMatrix<T>::softAssign (const ClassFlexibleMatrix& instance_i)
//==================
{
  if (empty ())
  {
    for (int thatRowsIndex = ((ClassFlexibleMatrix&)instance_i).rowsVector_.Get_minIndex (); 
             thatRowsIndex <= ((ClassFlexibleMatrix&)instance_i).rowsVector_.Get_maxIndex (); 
             thatRowsIndex++)
    {
      emptyRow_.softAssign (((ClassFlexibleMatrix&)instance_i).rowsVector_ [thatRowsIndex]);
      rowsVector_.push_back (emptyRow_);

    }
  }
  else
  {
    if (!((totalRows () == ((ClassFlexibleMatrix&)instance_i).totalRows ()) && (totalColumns () == ((ClassFlexibleMatrix&)instance_i).totalColumns ()))) 
    {
      BUG_Matrix_MESSAGE(<< endl);

      cerr << endl << "======================================================================= " 
           << endl
           << "Operator= : Matrixes' Sizes are not idendical : " << endl 
           << "\tFirst Matrix range is " 
           << " [" 
           << rowsVector_.Get_minIndex () 
           << "-" 
           << rowsVector_.Get_maxIndex ()
           << ", "
           << getFirstMatrixRow ().Get_minIndex ()
           << "-" 
           << getFirstMatrixRow ().Get_maxIndex ()
           << "]" 
           << endl
           << "\tSecond Matrix range is " 
           << " [" 
           << ((ClassFlexibleMatrix&)instance_i).rowsVector_.Get_minIndex () 
           << "-" 
           << ((ClassFlexibleMatrix&)instance_i).rowsVector_.Get_maxIndex ()
           << ", "
           << ((ClassFlexibleMatrix&)instance_i).getFirstMatrixRow ().Get_minIndex ()
           << "-" 
           << ((ClassFlexibleMatrix&)instance_i).getFirstMatrixRow ().Get_maxIndex ()
           << "]" 
           << endl
           << "======================================================================= " 
           << endl;
		
	
      cerr <<endl 
           << "First matrix : " 
           << rowsVector_.gstrObjectLocationShow () 
           << endl;
	
      cerr << endl
           << "Second matrix : " 
           << ((ClassFlexibleMatrix&)instance_i).rowsVector_.gstrObjectLocationShow () 
           << endl;
	
		
      return *this;
      ASSERT (0);	// Currently unused
    } // if (!((totalRows () == ... 

    emptyRow_.softAssign (((ClassFlexibleMatrix&)instance_i).emptyRow_);
    rowsVector_.softAssign (((ClassFlexibleMatrix&)instance_i).rowsVector_);

  } // else - if (empty ())

  return *this;
} // ClassFlexibleMatrix<T>& ClassFlexibleMatrix<T>::softAssign (const ClassFlexibleMatrix& instance_i)




//==================
template <class T>
ClassFlexibleMatrix<T>& ClassFlexibleMatrix<T>::hardAssign (const ClassFlexibleMatrix& instance_i)
//==================
{
  if (!empty ())
  {
    if (!((totalRows () == ((ClassFlexibleMatrix&)instance_i).totalRows ()) && (totalColumns () == ((ClassFlexibleMatrix&)instance_i).totalColumns ()))) 
    {
      BUG_Matrix_MESSAGE(<< endl);
      cerr << endl << "======================================================================= " 
           << endl
           << "Operator= : Matrixes' Sizes are not idendical : " << endl 
           << "\tFirst Matrix range is " 
           << " [" 
           << rowsVector_.Get_minIndex () 
           << "-" 
           << rowsVector_.Get_maxIndex ()
           << ", "
           << getFirstMatrixRow ().Get_minIndex ()
           << "-" 
           << getFirstMatrixRow ().Get_maxIndex ()
           << "]" 
           << endl
           << "\tSecond Matrix range is " 
           << " [" 
           << ((ClassFlexibleMatrix&)instance_i).rowsVector_.Get_minIndex () 
           << "-" 
           << ((ClassFlexibleMatrix&)instance_i).rowsVector_.Get_maxIndex ()
           << ", "
           << ((ClassFlexibleMatrix&)instance_i).getFirstMatrixRow ().Get_minIndex ()
           << "-" 
           << ((ClassFlexibleMatrix&)instance_i).getFirstMatrixRow ().Get_maxIndex ()
           << "]" 
           << endl
           << "======================================================================= " 
           << endl;
		
	
      cerr <<endl 
           << "First matrix : " 
           << rowsVector_.gstrObjectLocationShow () 
           << endl;
	
      cerr << endl
           << "Second matrix : " 
           << ((ClassFlexibleMatrix&)instance_i).rowsVector_.gstrObjectLocationShow () 
           << endl;
	
		
      return *this;
      ASSERT (0);	// Currently unused
    } // if (!((totalRows () == ... 
  } // else - if (empty ())

  emptyRow_.hardAssign (((ClassFlexibleMatrix&)instance_i).emptyRow_);
  rowsVector_.hardAssign (((ClassFlexibleMatrix&)instance_i).rowsVector_);

  return *this;

} // ClassFlexibleMatrix<T>& ClassFlexibleMatrix<T>::hardAssign (const ClassFlexibleMatrix& instance_i)


//==================
template <class T>
string ClassFlexibleMatrix<T>::getErrorMsgAboutMatrixRowOutOfRange (
							int		externalRowIndex_i, 
							const string&	theFuncName_i,
							const string 	fileName_i = "", 
							const int	lineNo_i = 0, 
							const string	compilationDate_i = "", 
							const string	compilationTime_i = ""
							) const
//==================
{
string          ret_stringValue;
strstream       tmp_strstream;

  tmp_strstream << endl 
                << "======================================================================= " 
	        << endl
	        << "### "
	        << theFuncName_i
	        << endl
	        << "Matrix Row index " 
	        << externalRowIndex_i 
	        << " out of range [" 
	        << rowsVector_.Get_minIndex () 
	        << "," 
	        << rowsVector_.Get_maxIndex ()
	        << "]"; 

  if (empty ())
  {
    tmp_strstream << "  (Range is Empty)"; 
  }

  tmp_strstream << endl
	        << "======================================================================= " 
	        << endl;

  tmp_strstream << rowsVector_.gstrObjectLocationShow () << endl;


  if (!fileName_i.empty ())
  {
    tmp_strstream << endl;
    tmp_strstream << "\t#################################################" <<  endl;
    tmp_strstream << "\t### See : " << fileName_i << ", line#" << lineNo_i << endl;
    tmp_strstream << "\t###     : (Compilation - " << compilationDate_i << ",   " << compilationTime_i << ")" << endl;
    tmp_strstream << "\t#################################################" <<  endl;
    tmp_strstream << endl;
  }

  tmp_strstream << ends;
  ret_stringValue = tmp_strstream.str(); tmp_strstream.rdbuf()->freeze (0);

  return ret_stringValue;

} // string ClassFlexibleMatrix<T>::getErrorMsgAboutMatrixRowOutOfRange


//==================
template <class T>
ClassFlexibleVector<T>& ClassFlexibleMatrix<T>::operator[] (int externalRowIndex_i)
//==================
{

  if (!(checkExternalRowIndex (externalRowIndex_i)))
  {
    BUG_Matrix_MESSAGE (<< getErrorMsgAboutMatrixRowOutOfRange (externalRowIndex_i, __PRETTY_FUNCTION__));
    return dummy_vector_;
  }

  return rowsVector_ [externalRowIndex_i];

} // ClassFlexibleVector<T>& ClassFlexibleMatrix<T>::operator[] (int externalRowIndex_i



//==================
template <class T>
ClassFlexibleVector<T> ClassFlexibleMatrix<T>::operator[] (int externalRowIndex_i) const
//==================
{

  if (!(checkExternalRowIndex (externalRowIndex_i)))
  {
    BUG_Matrix_MESSAGE (<< getErrorMsgAboutMatrixRowOutOfRange (externalRowIndex_i, __PRETTY_FUNCTION__));
    return dummy_vector_;
  }

  return rowsVector_ [externalRowIndex_i];

} // ClassFlexibleVector<T> ClassFlexibleMatrix<T>::operator[] (int externalRowIndex_i


//==================
template <class T>
ClassFlexibleVector<T>& ClassFlexibleMatrix<T>::at (int 		externalRowIndex_i,
				const string 	fileName_i, 
				const int	lineNo_i, 
				const string	compilationDate_i, 
				const string	compilationTime_i
				)
//==================
{
  if (!(checkExternalRowIndex (externalRowIndex_i)))
  {
    BUG_Matrix_MESSAGE (<< getErrorMsgAboutMatrixRowOutOfRange (externalRowIndex_i, __PRETTY_FUNCTION__, fileName_i, lineNo_i, compilationDate_i, compilationTime_i));
    return dummy_vector_;
  }

  return rowsVector_ [externalRowIndex_i];

} // T& ClassFlexibleMatrix<T>::at




//==================
template <class T>
ClassFlexibleVector<T> ClassFlexibleMatrix<T>::at (int externalRowIndex_i,
				const string 	fileName_i, 
				const int	lineNo_i, 
				const string	compilationDate_i, 
				const string	compilationTime_i
				) const
//==================
{
  if (!(checkExternalRowIndex (externalRowIndex_i)))
  {
    BUG_Matrix_MESSAGE (<< getErrorMsgAboutMatrixRowOutOfRange (externalRowIndex_i, __PRETTY_FUNCTION__, fileName_i, lineNo_i, compilationDate_i, compilationTime_i));
    return dummy_vector_;
  }

  return rowsVector_ [externalRowIndex_i];
} // T ClassFlexibleMatrix<T>::at 




//==================
template <class T>
ClassFlexibleVector<T> ClassFlexibleMatrix<T>::getFirstMatrixRow () const
//==================
{
  if (rowsVector_.empty ())
  {
		return emptyRow_;
  }
  return (*this) [rowsVector_.Get_minIndex ()];
} // ClassFlexibleVector<T> ClassFlexibleMatrix<T>::getFirstMatrixRow () const 



//==================
template <class T>
void ClassFlexibleMatrix<T>::push_row (const ClassFlexibleVector<T>& rowVector_i)
//==================
{
  // maybe will be deleted : softASSERT (totalColumns () == rowVector_i.size ());
  ClassFlexibleVector<T> tmpRow (getFirstMatrixRow ().Get_minIndex (), LOCATION);
  tmpRow = rowVector_i;
  rowsVector_.push_back (tmpRow);

const int	lastRowNo = rowsVector_.Get_maxIndex ();
  rowsVector_ [lastRowNo].setAboveOrdinalNumber (lastRowNo);
  rowsVector_ [lastRowNo].setPtrAboveVector (&rowsVector_);

} // void ClassFlexibleMatrix<T>::push_row (const ClassFlexibleVector<T>& rowVector_i) 




//==================
template <class T>
void ClassFlexibleMatrix<T>::push_column (const ClassFlexibleVector<T>& columnVector_i)
//==================
{
  ASSERT (totalRows () == columnVector_i.size ());
  ClassFlexibleVector<T> tmpColumn (rowsVector_.Get_minIndex (), LOCATION);
  tmpColumn = columnVector_i;
  for (int rowsIndex = rowsVector_.Get_minIndex (); 
           rowsIndex <= rowsVector_.Get_maxIndex (); 
           rowsIndex++)
  {
    rowsVector_[rowsIndex].push_back (tmpColumn [rowsIndex]);
  }

} // void ClassFlexibleMatrix<T>::push_column (const ClassFlexibleVector<T>& columnVector_i) 



//==================
template <class T>
bool ClassFlexibleMatrix<T>::checkExternalRowIndex (int externalRowIndex_i) const
//==================
{
  return ((externalRowIndex_i >= rowsVector_.Get_minIndex ()) && (externalRowIndex_i <= rowsVector_.Get_maxIndex ()));
} // bool ClassFlexibleMatrix<T>::checkExternalRowIndex (int externalRowIndex_i) const


//==================
template <class T>
bool ClassFlexibleMatrix<T>::empty () const
//==================
{
bool ret_boolValue = absolutelyEmpty ();

  if (!ret_boolValue)
  {
    //===============================
    // i.e. ret_boolValue = false
    //===============================

    //================================================
    // Only rectangular matrixes are used !!!!
    //================================================
    ASSERT (isRectangular ());
    ret_boolValue = getFirstMatrixRow ().empty ();
  }
  return ret_boolValue;
	
} // bool ClassFlexibleMatrix<T>::empty () const


//==================
template <class T>
bool ClassFlexibleMatrix<T>::absolutelyEmpty () const
//==================
{
  return rowsVector_.empty ();
} // bool ClassFlexibleMatrix<T>::absolutelyEmpty () const


//==================
template <class T>
bool ClassFlexibleMatrix<T>::allRowsAreEmpty () const
//==================
{
bool ret_boolValue = absolutelyEmpty ();

  if (!ret_boolValue)
  {
    // i.e. ret_boolValue = false
    ret_boolValue = true;

    for (int rowIndex = rowsVector_.Get_minIndex (); 
             rowIndex <= rowsVector_.Get_maxIndex (); 
             rowIndex++)
    {
      if (!(rowsVector_ [rowIndex].empty ()))
      {
        ret_boolValue = false;
        break;
      }
    } // for ...
		//################################################
  } // if (!ret_boolValue)

  return ret_boolValue;
	
} // bool ClassFlexibleMatrix<T>::allRowsAreEmpty () const



//####################################################################
//==================
template <class T>
bool ClassFlexibleMatrix<T>::isRectangular () const
//==================
{
bool ret_boolValue = absolutelyEmpty ();

  if (!ret_boolValue)
  {
    // i.e. ret_boolValue = false
    ret_boolValue = true;
    int	firstRowIndex = rowsVector_.Get_minIndex (); 

    for (int rowIndex = rowsVector_.Get_minIndex (); 
             rowIndex <= rowsVector_.Get_maxIndex (); 
             rowIndex++)
    {
      if (rowsVector_ [rowIndex].Get_minIndex() != rowsVector_ [firstRowIndex].Get_minIndex())
      {
        ret_boolValue = false;
        break;
      }

      if (rowsVector_ [rowIndex].Get_maxIndex() != rowsVector_ [firstRowIndex].Get_maxIndex())
      {
        ret_boolValue = false;
        break;
      }
    } // for ...
		//################################################
  } // if (!ret_boolValue)

  return ret_boolValue;
	
} // bool ClassFlexibleMatrix<T>::isRectangular () const

//==================
template <class T>
int ClassFlexibleMatrix<T>::totalColumns () const
//==================
{
  if (rowsVector_.empty ())   return 0;
  return getFirstMatrixRow ().size ();
} // int ClassFlexibleMatrix<T>::totalColumns () const 


//==================
template <class T>
ClassFlexibleMatrix<T> ClassFlexibleMatrix<T>::slice (
		const int& minRowIndexSlice_i, 
		const int& maxRowIndexSlice_i, 
		const int& minColumnIndexSlice_i, 
		const int& maxColumnIndexSlice_i
		)
//==================
{
ClassFlexibleVector< ClassFlexibleVector<T> >	tmpRowsVector;	
  tmpRowsVector = rowsVector_.slice (minRowIndexSlice_i, maxRowIndexSlice_i);

ClassFlexibleMatrix<T>  ret_ClassFlexibleMatrixObject (minRowIndexSlice_i, minColumnIndexSlice_i, LOCATION);
  for (int rowsIndex = tmpRowsVector.Get_minIndex (); 
           rowsIndex <= tmpRowsVector.Get_maxIndex(); 
           rowsIndex++)
  {
    ret_ClassFlexibleMatrixObject.rowsVector_.push_back (tmpRowsVector[rowsIndex].slice (minColumnIndexSlice_i, maxColumnIndexSlice_i));
  }

  return ret_ClassFlexibleMatrixObject;
} // ClassFlexibleMatrix<T> ClassFlexibleMatrix<T>::slice





//################################################################

#endif



//################################################################
//#                          END OF FILE                         # 
//################################################################


// ------------------- C++ code : END ----------------------
// === File #7 of 15 : fx_matr2.h ==========================