}

  bool Matrix::Inplace_SortColumnIndexed( const unsigned col, Matrix &Index )
  {
    if( MTX_SortColumnIndexed( &m_Matrix, col, &Index.m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_SortColumnIndexed returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_SortByColumn( const unsigned col )
  {
    if( MTX_SortByColumn( &m_Matrix, col ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_SortByColumn returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_Invert()
  {
    if( MTX_InvertInPlace( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_InvertInPlace returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_InvertRobust()
  {
    if( MTX_InvertInPlaceRobust( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_InvertInPlaceRobust returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_LowerTriangularInverse()
  {
    if( MTX_LowerTriangularInverseInplace( &m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_LowerTriangularInverseInplace returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_FFT()
  {
    if( MTX_FFT_Inplace( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_FFT_Inplace returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_FFT2()
  {
    if( MTX_FFT2_Inplace( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_FFT2_Inplace returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_IFFT()
  {
    if( MTX_IFFT_Inplace( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_IFFT_Inplace returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_IFFT2()
  {
    if( MTX_IFFT2_Inplace( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_IFFT2_Inplace returned false." );
      return false;
    }
  }
  
  bool Matrix::Add( const Matrix &B, const Matrix &C )
  {
    if( MTX_Add( &m_Matrix, &B.m_Matrix, &C.m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Add returned false." );
      return false;
    }
  }

  bool Matrix::Subtract( const Matrix &B, const Matrix &C )
  {
    if( MTX_Subtract( &m_Matrix, &B.m_Matrix, &C.m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Subtract returned false." );
      return false;
    }
  }

  bool Matrix::Multiply( const Matrix &B, const Matrix &C )
  {
    if( MTX_Multiply( &m_Matrix, &B.m_Matrix, &C.m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Multiply returned false." );
      return false;
    }
  }

  bool Matrix::TransposeMultiply( const Matrix &B, const Matrix &C )
  {
    if( MTX_TransposeMultiply( &m_Matrix, &B.m_Matrix, &C.m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_TranposeMultiply returned false." );
      return false;
    }
  }

  bool Matrix::MultiplyTranspose( const Matrix &B, const Matrix &C )
  {
    if( MTX_MultiplyTranspose( &m_Matrix, &B.m_Matrix, &C.m_Matrix ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_MultiplyTranspose returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_abs()
  {
    if( MTX_Abs( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_Abs returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_colon( double start, double increment, double end )
  {
    if( MTX_Colon( &m_Matrix, start, increment, end) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_Colon returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_conj()
  {
    if( MTX_Conjugate( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_Conjugate returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_cos()
  {
    if( MTX_cos( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_cos returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_cosh()
  {
    if( MTX_cosh( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_cosh returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_cot()
  {
    if( MTX_cot( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_cot returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_coth()
  {
    if( MTX_coth( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_coth returned false." );
      return false;
    }
  }
  
  bool Matrix::Inplace_imag()
  {
    if( MTX_ConvertComplexToImag( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_ConvertComplexToImag returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_exp()
  {
    if( MTX_Exp( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_Exp returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_eye( const unsigned nrows, const unsigned ncols )
  {
    if( MTX_Eye( &m_Matrix, nrows, ncols ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_Eye returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_log2()
  {
    if( MTX_Ln( &m_Matrix ) )
    {
      if( MTX_Divide_Scalar( &m_Matrix, log(2.0) ) )
      {
        return true;
      }
      else
      {
        return false;
        MTX_ERROR_MSG( "MTX_Divide_Scalar returned false." );      
      }
    }
    else
    {
      MTX_ERROR_MSG( "MTX_Ln returned false." );      
      return false;
    }
  }

  bool Matrix::Inplace_log10()
  {
    if( MTX_Ln( &m_Matrix ) )
    {
      if( MTX_Divide_Scalar( &m_Matrix, log(10.0) ) )
      {
        return true;
      }
      else
      {
        MTX_ERROR_MSG( "MTX_Divide_Scalar returned false." );
        return false;
      }
    }
    else
    {
      MTX_ERROR_MSG( "MTX_Ln returned false." );
      return false;
    }
  }


  bool Matrix::Inplace_ones( const unsigned nrows, const unsigned ncols )
  {
    if( m_Matrix.nrows == nrows && m_Matrix.ncols == ncols && m_Matrix.isReal )
    { 
      if( !MTX_Fill( &m_Matrix, 1.0 ) )
      {
        MTX_ERROR_MSG( "MTX_Fill returned false." );
        return false;
      }
    }
    else
    {
      if( !MTX_Malloc( &m_Matrix, nrows, ncols, TRUE ) )
      {
        MTX_ERROR_MSG( "MTX_Malloc returned false." );
        return false;
      }
      if( !MTX_Fill( &m_Matrix, 1.0 ) )
      {
        MTX_ERROR_MSG( "MTX_Fill returned false." );
        return false;
      }
    }
    return true;
  }

  bool Matrix::Inplace_real()
  {
    if( MTX_ConvertComplexToReal( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_ConvertComplexToReal returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_rand( const unsigned nrows, const unsigned ncols, const unsigned seed )
  {
    if( MTX_rand( &m_Matrix, nrows, ncols, seed ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_rand returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_randn( const unsigned nrows, const unsigned ncols, const unsigned seed )
  {
    if( MTX_randn( &m_Matrix, nrows, ncols, seed ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_randn returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_sin()
  {
    if( MTX_sin( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_sin returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_sinc()
  {
    if( MTX_sinc( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_sinc returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_sinh()
  {
    if( MTX_sinh( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_sinh returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_sqrt()
  {
    if( MTX_Sqrt( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_Sqrt returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_tan()
  {
    if( MTX_tan( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_tan returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_tanh()
  {
    if( MTX_tanh( &m_Matrix ) )
    {
      return true;
    }
    else
    {
      MTX_ERROR_MSG( "MTX_tanh returned false." );
      return false;
    }
  }

  bool Matrix::Inplace_zeros( const unsigned nrows, const unsigned ncols )
  {
    if( m_Matrix.nrows == nrows && m_Matrix.ncols == ncols && m_Matrix.isReal )
    { 
      if( !MTX_Fill( &m_Matrix, 0.0 ) )
      {
        MTX_ERROR_MSG( "MTX_Fill returned false." );
        return false;
      }
    }
    else
    {
      if( !MTX_Malloc( &m_Matrix, nrows, ncols, TRUE ) )
      {
        MTX_ERROR_MSG( "MTX_Malloc returned false." );
        return false;
      }
      if( !MTX_Fill( &m_Matrix, 0.0 ) )
      {
        MTX_ERROR_MSG( "MTX_Fill returned false." );
        return false;
      }
    }
    return true;
  }
  

  bool Matrix::GetStats_MaxAbs(unsigned &row, unsigned &col, double &value )
  {
    if( MTX_MaxAbsIndex( &m_Matrix, &value, &row, &col ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_MaxAbsIndex returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_Max(unsigned &row, unsigned &col, double &re, double &im )
  {
    if( MTX_MaxIndex( &m_Matrix, &re, &im, &row, &col ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_MaxIndex returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_MaxVal(double &re, double &im )
  {
    if( MTX_Max( &m_Matrix, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_Max returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_MaxAbsCol(const unsigned col, double &value, unsigned &row )
  {
    if( MTX_MaxAbsColIndex( &m_Matrix, col, &value, &row ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_MaxAbsColIndex returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_MaxCol(const unsigned col, double &re, double &im, unsigned &row )
  {
    if( MTX_MaxColIndex( &m_Matrix, col, &re, &im, &row ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_MaxColIndex returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_MaxColVal(const unsigned col, double &re, double &im )
  {
    if( MTX_MaxColumn( &m_Matrix, col, &re, &im ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_MaxColumn returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_MaxAbsRow(const unsigned row, double &value, unsigned &col )
  {
    if( MTX_MaxAbsRowIndex( &m_Matrix, row, &value, &col ) )
    {
      return true;
    }
    else 
    {
      MTX_ERROR_MSG( "MTX_MaxAbsRowIndex returned false." );
      return false;
    }
  }

  bool Matrix::GetStats_MaxRow(const unsigned row, double &re, double &im, unsigned &col )
  {