ShMatrix.hpp

// Sh: A GPU metaprogramming language.
//
// Copyright 2003-2006 Serious Hack Inc.
// 
// 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.1 of the License, 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; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 
// MA  02110-1301, USA
#ifndef SH_SHMATRIX_HPP
#define SH_SHMATRIX_HPP

#include "ShMeta.hpp"
#include "ShVariable.hpp"
#include "ShAttrib.hpp"
#include "ShRefCount.hpp"

namespace SH {

template<int Rows, int Cols, ShBindingType Binding, typename T>
class ShMatrix;

template<int Rows, int Cols, typename T>
class ShMatrixRows;

template<int Rows, int Cols, ShBindingType Binding, typename T>
class ShMatrix: public virtual ShMeta {
public:
  typedef T storage_type;
  typedef typename ShHostType<T>::type host_type;
  typedef typename ShMemType<T>::type mem_type;
  static const ShValueType value_type = ShStorageTypeInfo<T>::value_type;
  static const ShBindingType binding_type = Binding;
  static const int rows = Rows;
  static const int cols = Cols;
  static const int typesize = Rows * Cols;

  typedef ShMatrix<Rows, Cols, SH_INPUT, T> InputType;
  typedef ShMatrix<Rows, Cols, SH_OUTPUT, T> OutputType;
  typedef ShMatrix<Rows, Cols, SH_INOUT, T> InOutType;
  typedef ShMatrix<Rows, Cols, SH_TEMP, T> TempType;
  typedef ShMatrix<Rows, Cols, SH_CONST, T> ConstType;

  ShMatrix();

  template<ShBindingType Binding2>
  ShMatrix(const ShMatrix<Rows, Cols, Binding2, T>& other);
  
  ~ShMatrix();

  ShMatrix& operator=(const ShMatrix<Rows, Cols, Binding, T>& other);

  template<ShBindingType Binding2>
  ShMatrix& operator=(const ShMatrix<Rows, Cols, Binding2, T>& other);

  ShMatrix& operator=(const T& scalar);

  ShMatrix& operator=(const ShGeneric<1, T>& scalar);

  ShAttrib<Cols, Binding, T>& operator[](int i);

  const ShAttrib<Cols, Binding, T>& operator[](int i) const;

  template<ShBindingType Binding2>
  ShMatrix& operator+=(const ShMatrix<Rows, Cols, Binding2, T>& other);

  template<ShBindingType Binding2>
  ShMatrix& operator-=(const ShMatrix<Rows, Cols, Binding2, T>& other);


  template<ShBindingType Binding2>
  ShMatrix& operator/=(const ShMatrix<Rows, Cols, Binding2, T>& other);    

  template<ShBindingType Binding2>
  ShMatrix& operator*=(const ShMatrix<Rows, Cols, Binding2, T>& other);    
   
  ShMatrix& operator-();

  ShMatrix<Rows - 1, Cols -1, SH_TEMP, T> subMatrix(int,int) const;

  void setTranslation(const ShGeneric<Rows-1, T>& trans);
  
  void setScaling(const ShGeneric<Rows-1, T>& scale);


  ShMatrix& operator*=(const ShGeneric<1, T>& a);
    
  ShMatrix& operator/=(const ShGeneric<1, T>& a);

  ShMatrixRows<Rows, Cols, T> operator()() const; 
  ShMatrixRows<1, Cols, T> operator()(int) const;
  ShMatrixRows<2, Cols, T> operator()(int, int) const;
  ShMatrixRows<3, Cols, T> operator()(int, int, int) const;
  ShMatrixRows<4, Cols, T> operator()(int, int, int, int) const;
  

  void range(host_type low, host_type high);

  
  virtual std::string name() const;
  virtual void name(const std::string& n);
  virtual bool has_name() const;
  
  virtual bool internal() const;
  virtual void internal(bool);

  virtual std::string title() const;
  virtual void title(const std::string& t);

  virtual std::string description() const;
  virtual void description(const std::string& d);

  virtual std::string meta(const std::string& key) const;
  virtual void meta(const std::string& key, const std::string& value);

  int size() const { return Rows * Cols; }
  
  virtual void getValues(host_type dest[]) const;

private:
  ShAttrib<Cols, Binding, T> m_data[Rows];
  
};
template<int R, int C, ShBindingType B, typename Ty>
std::ostream& operator<<(std::ostream& out,
                         const ShMatrix<R, C, B, Ty>& m);

template<int Rows, int Cols, typename T>
class ShMatrixRows {
public:
  template<ShBindingType Binding>
  ShMatrixRows(const ShMatrix<Rows, Cols, Binding, T>& source);
  
  template<int OR, ShBindingType Binding>
  ShMatrixRows(const ShMatrix<OR, Cols, Binding, T>& source,
               int idx0);
  template<int OR, ShBindingType Binding>
  ShMatrixRows(const ShMatrix<OR, Cols, Binding, T>& source,
               int idx0, int idx1);
  template<int OR, ShBindingType Binding>
  ShMatrixRows(const ShMatrix<OR, Cols, Binding, T>& source,
               int idx0, int idx1, int idx2);
  template<int OR, ShBindingType Binding>
  ShMatrixRows(const ShMatrix<OR, Cols, Binding, T>& source,
               int idx0, int idx1, int idx2, int idx3);

  ShMatrixRows(const ShMatrixRows<Rows, Cols, T>& other);
  
  ShMatrixRows& operator=(const ShMatrixRows<Rows, Cols, T>& other);

  ShMatrix<Rows, Cols, SH_TEMP, T> operator()() const; 
  ShMatrix<Rows, 1, SH_TEMP, T> operator()(int) const;
  ShMatrix<Rows, 2, SH_TEMP, T> operator()(int, int) const;
  ShMatrix<Rows, 3, SH_TEMP, T> operator()(int, int, int) const;
  ShMatrix<Rows, 4, SH_TEMP, T> operator()(int, int, int, int) const;
private:
  ShAttrib<Cols, SH_TEMP, T> m_data[Rows];
};


typedef ShMatrix<1, 1, SH_INPUT, float> ShInputMatrix1x1f;
typedef ShMatrix<1, 1, SH_OUTPUT, float> ShOutputMatrix1x1f;
typedef ShMatrix<1, 1, SH_INOUT, float> ShInOutMatrix1x1f;
typedef ShMatrix<1, 1, SH_TEMP, float> ShMatrix1x1f;
typedef ShMatrix<1, 2, SH_INPUT, float> ShInputMatrix1x2f;
typedef ShMatrix<1, 2, SH_OUTPUT, float> ShOutputMatrix1x2f;
typedef ShMatrix<1, 2, SH_INOUT, float> ShInOutMatrix1x2f;
typedef ShMatrix<1, 2, SH_TEMP, float> ShMatrix1x2f;
typedef ShMatrix<1, 3, SH_INPUT, float> ShInputMatrix1x3f;
typedef ShMatrix<1, 3, SH_OUTPUT, float> ShOutputMatrix1x3f;
typedef ShMatrix<1, 3, SH_INOUT, float> ShInOutMatrix1x3f;
typedef ShMatrix<1, 3, SH_TEMP, float> ShMatrix1x3f;
typedef ShMatrix<1, 4, SH_INPUT, float> ShInputMatrix1x4f;
typedef ShMatrix<1, 4, SH_OUTPUT, float> ShOutputMatrix1x4f;
typedef ShMatrix<1, 4, SH_INOUT, float> ShInOutMatrix1x4f;
typedef ShMatrix<1, 4, SH_TEMP, float> ShMatrix1x4f;

typedef ShMatrix<2, 1, SH_INPUT, float> ShInputMatrix2x1f;
typedef ShMatrix<2, 1, SH_OUTPUT, float> ShOutputMatrix2x1f;
typedef ShMatrix<2, 1, SH_INOUT, float> ShInOutMatrix2x1f;
typedef ShMatrix<2, 1, SH_TEMP, float> ShMatrix2x1f;
typedef ShMatrix<2, 2, SH_INPUT, float> ShInputMatrix2x2f;
typedef ShMatrix<2, 2, SH_OUTPUT, float> ShOutputMatrix2x2f;
typedef ShMatrix<2, 2, SH_INOUT, float> ShInOutMatrix2x2f;
typedef ShMatrix<2, 2, SH_TEMP, float> ShMatrix2x2f;
typedef ShMatrix<2, 3, SH_INPUT, float> ShInputMatrix2x3f;
typedef ShMatrix<2, 3, SH_OUTPUT, float> ShOutputMatrix2x3f;
typedef ShMatrix<2, 3, SH_INOUT, float> ShInOutMatrix2x3f;
typedef ShMatrix<2, 3, SH_TEMP, float> ShMatrix2x3f;
typedef ShMatrix<2, 4, SH_INPUT, float> ShInputMatrix2x4f;
typedef ShMatrix<2, 4, SH_OUTPUT, float> ShOutputMatrix2x4f;
typedef ShMatrix<2, 4, SH_INOUT, float> ShInOutMatrix2x4f;
typedef ShMatrix<2, 4, SH_TEMP, float> ShMatrix2x4f;

typedef ShMatrix<3, 1, SH_INPUT, float> ShInputMatrix3x1f;
typedef ShMatrix<3, 1, SH_OUTPUT, float> ShOutputMatrix3x1f;
typedef ShMatrix<3, 1, SH_INOUT, float> ShInOutMatrix3x1f;
typedef ShMatrix<3, 1, SH_TEMP, float> ShMatrix3x1f;
typedef ShMatrix<3, 2, SH_INPUT, float> ShInputMatrix3x2f;
typedef ShMatrix<3, 2, SH_OUTPUT, float> ShOutputMatrix3x2f;
typedef ShMatrix<3, 2, SH_INOUT, float> ShInOutMatrix3x2f;
typedef ShMatrix<3, 2, SH_TEMP, float> ShMatrix3x2f;
typedef ShMatrix<3, 3, SH_INPUT, float> ShInputMatrix3x3f;
typedef ShMatrix<3, 3, SH_OUTPUT, float> ShOutputMatrix3x3f;
typedef ShMatrix<3, 3, SH_INOUT, float> ShInOutMatrix3x3f;
typedef ShMatrix<3, 3, SH_TEMP, float> ShMatrix3x3f;
typedef ShMatrix<3, 4, SH_INPUT, float> ShInputMatrix3x4f;
typedef ShMatrix<3, 4, SH_OUTPUT, float> ShOutputMatrix3x4f;
typedef ShMatrix<3, 4, SH_INOUT, float> ShInOutMatrix3x4f;
typedef ShMatrix<3, 4, SH_TEMP, float> ShMatrix3x4f;

typedef ShMatrix<4, 1, SH_INPUT, float> ShInputMatrix4x1f;
typedef ShMatrix<4, 1, SH_OUTPUT, float> ShOutputMatrix4x1f;
typedef ShMatrix<4, 1, SH_INOUT, float> ShInOutMatrix4x1f;
typedef ShMatrix<4, 1, SH_TEMP, float> ShMatrix4x1f;
typedef ShMatrix<4, 2, SH_INPUT, float> ShInputMatrix4x2f;
typedef ShMatrix<4, 2, SH_OUTPUT, float> ShOutputMatrix4x2f;
typedef ShMatrix<4, 2, SH_INOUT, float> ShInOutMatrix4x2f;
typedef ShMatrix<4, 2, SH_TEMP, float> ShMatrix4x2f;
typedef ShMatrix<4, 3, SH_INPUT, float> ShInputMatrix4x3f;
typedef ShMatrix<4, 3, SH_OUTPUT, float> ShOutputMatrix4x3f;
typedef ShMatrix<4, 3, SH_INOUT, float> ShInOutMatrix4x3f;
typedef ShMatrix<4, 3, SH_TEMP, float> ShMatrix4x3f;
typedef ShMatrix<4, 4, SH_INPUT, float> ShInputMatrix4x4f;
typedef ShMatrix<4, 4, SH_OUTPUT, float> ShOutputMatrix4x4f;
typedef ShMatrix<4, 4, SH_INOUT, float> ShInOutMatrix4x4f;
typedef ShMatrix<4, 4, SH_TEMP, float> ShMatrix4x4f;

}

#include "ShMatrixImpl.hpp"

#endif

---