DataLazy.h

Go to the documentation of this file.

/*******************************************************
*
* Copyright (c) 2003-2010 by University of Queensland
* Earth Systems Science Computational Center (ESSCC)
* http://www.uq.edu.au/esscc
*
* Primary Business: Queensland, Australia
* Licensed under the Open Software License version 3.0
* http://www.opensource.org/licenses/osl-3.0.php
*
*******************************************************/


#if !defined escript_DataLazy_20081008_H
#define escript_DataLazy_20081008_H
#include "system_dep.h"

#include "DataAbstract.h"

#include <string>
#include <functional>

#include "LocalOps.h"       // for tensor_binary_op
#include "DataVector.h"     // for ElementType


//#define LAZY_NODE_STORAGE

namespace escript {

// For the purposes of unit testing and maintaining sanity, it is important that this enum be contiguous
enum ES_optype
{
    UNKNOWNOP=0,
    IDENTITY=1,
    ADD=2,
    SUB=3,
    MUL=4,
    DIV=5,
    POW=6,
    SIN=POW+1,
    COS=SIN+1,
    TAN=SIN+2,
    ASIN=SIN+3,
    ACOS=SIN+4,
    ATAN=SIN+5,
    SINH=SIN+6,
    COSH=SIN+7,
    TANH=SIN+8,
    ERF=SIN+9,
    ASINH=SIN+10,
    ACOSH=SIN+11,
    ATANH=SIN+12,
    LOG10=ATANH+1,
    LOG=LOG10+1,
    SIGN=LOG10+2,
    ABS=LOG10+3,
    NEG=LOG10+4,
    POS=LOG10+5,
    EXP=LOG10+6,
    SQRT=LOG10+7,
    RECIP=LOG10+8,
    GZ=RECIP+1,
    LZ=GZ+1,
    GEZ=GZ+2,
    LEZ=GZ+3,
    NEZ=GZ+4,
    EZ=GZ+5,
    SYM=EZ+1,
    NSYM=SYM+1,
    PROD=NSYM+1,
    TRANS=PROD+1,
    TRACE=TRANS+1,
    SWAP=TRACE+1,
    MINVAL=SWAP+1,
    MAXVAL=MINVAL+1,
    CONDEVAL=MAXVAL+1
};

ESCRIPT_DLL_API
const std::string&
opToString(ES_optype op);

class DataLazy;

typedef POINTER_WRAPPER_CLASS(DataLazy) DataLazy_ptr;
typedef POINTER_WRAPPER_CLASS(const DataLazy) const_DataLazy_ptr;

class DataLazy : public DataAbstract
{

typedef DataAbstract parent;
typedef DataTypes::ValueType ValueType;
typedef DataTypes::ShapeType ShapeType;

public:
  ESCRIPT_DLL_API
  DataLazy(DataAbstract_ptr p);


  ESCRIPT_DLL_API
  DataLazy(DataAbstract_ptr left, ES_optype op);

  ESCRIPT_DLL_API
  DataLazy(DataAbstract_ptr left, ES_optype op, double tol);

  ESCRIPT_DLL_API  
  DataLazy(DataAbstract_ptr left, ES_optype op, int axis_offset);


  ESCRIPT_DLL_API
  DataLazy(DataAbstract_ptr left, DataAbstract_ptr right, ES_optype op);

  ESCRIPT_DLL_API
  DataLazy(DataAbstract_ptr left, DataAbstract_ptr right, ES_optype op, int axis_offset, int transpose);

  ESCRIPT_DLL_API
  DataLazy(DataAbstract_ptr left, ES_optype op, const int axis0, const int axis1);

  ESCRIPT_DLL_API
  DataLazy(DataAbstract_ptr mask, DataAbstract_ptr left, DataAbstract_ptr right/*, double tol*/);

  ESCRIPT_DLL_API
  ~DataLazy();

  ESCRIPT_DLL_API
  DataReady_ptr 
  resolve();

  ESCRIPT_DLL_API
  std::string
  toString() const;

  ESCRIPT_DLL_API
  DataAbstract* 
  deepCopy();


  ESCRIPT_DLL_API
  ValueType::size_type
  getLength() const;


  ESCRIPT_DLL_API
  DataAbstract*
  getSlice(const DataTypes::RegionType& region) const;


  DataTypes::ValueType::size_type 
  getPointOffset(int sampleNo,
                 int dataPointNo) const;

  DataTypes::ValueType::size_type 
  getPointOffset(int sampleNo,
                 int dataPointNo);

  ESCRIPT_DLL_API
  size_t
  getMaxSampleSize() const;

  ESCRIPT_DLL_API
  const ValueType*
  resolveSample(int sampleNo, size_t& roffset); 

  ESCRIPT_DLL_API
  bool
  actsExpanded() const;

  ESCRIPT_DLL_API
  virtual void
  setToZero();

  
  ESCRIPT_DLL_API
  void
  resolveGroupWorker(std::vector<DataLazy*>& dats);


private:
  DataReady_ptr m_id;   //  For IDENTITY nodes, stores a wrapped value.
  DataLazy_ptr m_left, m_right, m_mask; // operands for operation.
  ES_optype m_op;   // operation to perform.

  size_t m_samplesize;  // number of values required to store a sample

  char m_readytype; // E for expanded, T for tagged, C for constant

  int m_axis_offset;    // required extra info for general tensor product
  int m_transpose;  // offset and transpose are used for swapaxes as well
  int m_SL, m_SM, m_SR; // computed properties used in general tensor product


  double m_tol;     // required extra info for <>0 and ==0

  size_t m_children;
  size_t m_height;

  int* m_sampleids;     // may be NULL
  DataVector m_samples;  

  void LazyNodeSetup();


  const DataTypes::ValueType*
  resolveNodeUnary(int tid, int sampleNo, size_t& roffset);


  const DataTypes::ValueType*
  resolveNodeReduction(int tid, int sampleNo, size_t& roffset);  

  const DataTypes::ValueType*
  resolveNodeSample(int tid, int sampleNo, size_t& roffset);

  const DataTypes::ValueType*
  resolveNodeBinary(int tid, int sampleNo, size_t& roffset);

  const DataTypes::ValueType*
  resolveNodeNP1OUT(int tid, int sampleNo, size_t& roffset);

  const DataTypes::ValueType*
  resolveNodeNP1OUT_P(int tid, int sampleNo, size_t& roffset);

  const DataTypes::ValueType*
  resolveNodeTProd(int tid, int sampleNo, size_t& roffset);

  const DataTypes::ValueType*
  resolveNodeNP1OUT_2P(int tid, int sampleNo, size_t& roffset);

  const DataTypes::ValueType*
  resolveNodeCondEval(int tid, int sampleNo, size_t& roffset);

  void
  intoString(std::ostringstream& oss) const;

  void
  intoTreeString(std::ostringstream& oss,std::string indent) const;

  void
  collapse();       // converts the node into an IDENTITY node


  DataReady_ptr
  collapseToReady();

  void
  resolveToIdentity();

  void 
  makeIdentity(const DataReady_ptr& p);


  DataReady_ptr
  resolveNodeWorker();

};

}
#endif