laindex.h

Go to the documentation of this file.

// -*-C++-*- 

// Copyright (C) 2004 
// Christian Stimming <stimming@tuhh.de>

// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2, or (at
// your option) any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public License along
// with this library; see the file COPYING.  If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.

//      LAPACK++ (V. 1.1)
//      (C) 1992-1996 All Rights Reserved.

#ifndef _LA_INDEX_H_
#define _LA_INDEX_H_

#include <iostream>
#include "arch.h"

class DLLIMPORT LaIndex
{
   private:
      friend class LaGenMatDouble;
      friend class LaGenMatFloat;
      friend class LaGenMatInt;
      friend class LaGenMatLongInt;
      friend class LaGenMatComplex;
      int start_;
      int inc_;
      int end_;
   public:
      inline LaIndex()
         : start_(0)
         , inc_(0)
         , end_(0)
      {}
      
      inline LaIndex(int start) 
         : start_(start)
         , inc_(1)
         , end_(start)
      {}

      LaIndex(int start, int end);

      LaIndex(int start, int end, int increment);

      inline LaIndex(const LaIndex &s)
         : start_(s.start_)
         , inc_(s.inc_)
         , end_(s.end_)
      {}

   protected:
      // must have multply defined start(), inc() and end() member
      // functions for both const and non-const objects because
      // compiler complains in LaVector*.h, for example, about
      // assignment to const member.  (LaVector*.h line 112, 113,
      // 114) FIXME: Probably we should return by-value, not
      // by-reference!
      inline int& start() { return start_;}
      inline int& inc() { return inc_;}
      inline int& end() { return end_;}
   public:

      inline int start() const { return start_;}

      inline int inc() const { return inc_;}

      inline int end() const { return end_;}

      inline int length() const { return ((end()-start())/inc() + 1);}

      inline bool null() const { return (start() == 0 && 
                                         inc() == 0 && end() == 0);}

   protected:
      inline LaIndex& operator()(int start, int end){
         start_=start; inc_=1; end_=end; return *this;}
   public:

      inline LaIndex& set(int start, int end) {
         start_=start; inc_=1; end_=end; return *this;}

      LaIndex& set(int start, int end, int increment);

      inline LaIndex& operator+(int i) {
         start_+=i; end_+=i; return *this;}

      inline LaIndex& operator=(const LaIndex& i) {
         start_=i.start_; inc_=i.inc_; end_=i.end_; 
         return *this;}

      inline bool operator==(const LaIndex& s) {
         return start_ == s.start_ && inc_ == s.inc_ && end_ == s.end_;
      }
      inline bool operator!=(const LaIndex& s) {
         return !operator==(s);
      }
};

inline std::ostream& operator<<(std::ostream& s, const LaIndex& i)
{
    s << "(" << i.start() << ":" << i.inc() << ":" << i.end() << ")";

    return s;
}

#endif  
//  LA_INDEX_H_

---