utils/multiindex.h

// -*- c++ -*-

// +--------------------------------------------------------------------+
// | This file is part of MathTL - the Mathematical Template Library    |
// |                                                                    |
// | Copyright (c) 2002-2009                                            |
// | Thorsten Raasch, Manuel Werner, Ulrich Friedrich                   |
// +--------------------------------------------------------------------+

#ifndef _MATHTL_MULTIINDEX_H
#define _MATHTL_MULTIINDEX_H

#include <iostream>
#include <set>
#include <map>
#include <utils/fixed_array1d.h>

namespace MathTL
{
  template <class I, unsigned int DIMENSION>
  class MultiIndex
    : public FixedArray1D<I, DIMENSION>
  {
  public:
    MultiIndex();

    MultiIndex(const MultiIndex& lambda);

    explicit MultiIndex(const I& i0);

    MultiIndex(const I& i0, const I& i1);
  
    bool operator == (const MultiIndex& lambda) const;

    inline bool operator != (const MultiIndex& lambda) const
    { return !(*this == lambda); }

    /*
     * MultiIndices are ordered same as \N^dim is ordered.
     * This is not the lexicographic order!
     * This does not work for multiindices with negative entries.
     * Explicitly: indices are ordered primarily by their 1 norm, secondly lexicographically.
     */
    bool operator < (const MultiIndex& lambda) const;

    /*
     * Lexicographical ordering
     */
    bool lex (const MultiIndex& lambda) const;

    bool operator <= (const MultiIndex& lambda) const
    { return (*this < lambda || *this == lambda); }

    bool operator >= (const MultiIndex& lambda) const
    { return (lambda < *this || *this == lambda); }
 
    /*
     * Preincrement. Works only for nonnegative entries!
     * Ordering given by numbering of \N^dim, i.e.
     * (0,0,0),(0,0,1),(0,1,0),(1,0,0),(0,0,2),(0,1,1),(0,2,0),(1,0,1),(1,1,0),(2,0,0),(0,0,3),...
     * This ordering is used for the operator <.
     */
    MultiIndex& operator ++ ();
    
        // Postincrement. Works only for nonnegative entries!
    MultiIndex operator ++ (int)    
    {
        MultiIndex temp (*this);
        ++*this;
        return temp;
    };

    /*
     * Return Number of MulitiIndex with respect to the ordering "<"
     * Counting begins at 0.
     */
    unsigned long int number();
    
  };


  /*
   * Returns the mapping from the multiindices to the natural numbers according 
   * to the ordering <.
   * Output contains multiindices ranging from 0 to lambda, excluding lambda.
   */
  template <class I, unsigned int DIMENSION>
  std::map<MultiIndex<I, DIMENSION>,int>
  indexmapping(const MultiIndex<I, DIMENSION>& lambda);

  template <class I, unsigned int DIMENSION>
  std::set<MultiIndex<I, DIMENSION> >
  cuboid_indices(const MultiIndex<I, DIMENSION>& alpha,
                 const MultiIndex<I, DIMENSION>& beta);

  template <class I, unsigned int DIMENSION>
  unsigned int multi_degree(const MultiIndex<I, DIMENSION>& alpha);

  template <class I, unsigned int DIMENSION>
  unsigned int multi_factorial(const MultiIndex<I, DIMENSION>& alpha);

  template <class I, unsigned int DIMENSION>
  int multi_power(const MultiIndex<I, DIMENSION>& alpha,
                  const MultiIndex<I, DIMENSION>& beta);
  
  template <class I, unsigned int DIMENSION>
  int multi_binomial(const MultiIndex<I, DIMENSION>& beta,
                     const MultiIndex<I, DIMENSION>& alpha);

  template <class I, unsigned int DIMENSION>
  std::set<MultiIndex<I, DIMENSION> >
  degree_indices(const unsigned int k);  
  
  template<class I, unsigned int DIMENSION>
  inline std::ostream&
  operator << (std::ostream& os, const MultiIndex<I, DIMENSION>& lambda)
  {
    using namespace std;
    os << "(";
    for (unsigned int i(0); i < DIMENSION; i++)
      {
        os << lambda[i];
        if (i < DIMENSION-1)
          os << ",";
        else
          os << ")";
      }
    
    return os;
  }  

}

#include <utils/multiindex.cpp>

#endif