Sacado_LFad_LogicalSparse.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//                           Sacado Package
//
// Copyright 2006 NTESS and the Sacado contributors.
// SPDX-License-Identifier: LGPL-2.1-or-later
// *****************************************************************************
// @HEADER

#ifndef SACADO_LFAD_LOGICALSPARSE_HPP
#define SACADO_LFAD_LOGICALSPARSE_HPP

#include "Sacado_LFad_LogicalSparseTraits.hpp"
#include "Sacado_LFad_ExpressionTraits.hpp"
#include "Sacado_Fad_DynamicStorage.hpp"

namespace Sacado {

  namespace LFad {


    template <typename ExprT> class Expr {};


    template <typename T>
    struct ExprLevel {
      static const unsigned value = 0;
    };

    template <typename T>
    struct ExprLevel< Expr<T> > {
      static const unsigned value =
        ExprLevel< typename Expr<T>::value_type >::value + 1;
    };

    template <typename T>
    struct IsFadExpr {
      static const bool value = false;
    };

    template <typename T>
    struct IsFadExpr< Expr<T> > {
      static const bool value = true;
    };

    // Forward declaration
    template <typename ValT, typename LogT> class LogicalSparse;

    template <typename ValT, typename LogT>
    class LogicalSparseImp :
      public Fad::DynamicStorage<ValT,LogT> {

      typedef Fad::DynamicStorage<ValT,LogT> Storage;

    public:

      typedef ValT value_type;

      typedef typename ScalarType<value_type>::type scalar_type;

      typedef LogT logical_type;


      LogicalSparseImp() : Storage(value_type(0)) {}


      template <typename S>
      LogicalSparseImp(const S& x, SACADO_ENABLE_VALUE_CTOR_DECL) :
        Storage(x) {}


      LogicalSparseImp(const int sz, const value_type & x) :
        Storage(sz, x, InitDerivArray) {}


      LogicalSparseImp(const int sz, const int i, const value_type & x) :
        Storage(sz, x, InitDerivArray) {
        this->fastAccessDx(i)=logical_type(1);
      }

      LogicalSparseImp(const LogicalSparseImp& x) :
        Storage(x) {}

      template <typename S>
      LogicalSparseImp(const Expr<S>& x, SACADO_ENABLE_EXPR_CTOR_DECL)  :
        Storage(value_type(0)) {
        int sz = x.size();

        if (sz != this->size())
          this->resize(sz);

        if (sz) {
          if (x.hasFastAccess())
            for(int i=0; i<sz; ++i)
              this->fastAccessDx(i) = x.fastAccessDx(i);
          else
            for(int i=0; i<sz; ++i)
              this->fastAccessDx(i) = x.dx(i);
        }

        this->val() = x.val();
      }

      ~LogicalSparseImp() {}


      void diff(const int ith, const int n) {
        if (this->size() != n)
          this->resize(n);

        this->zero();
        this->fastAccessDx(ith) = logical_type(1);
      }

      template <typename S>
      SACADO_ENABLE_EXPR_FUNC(bool) isEqualTo(const Expr<S>& x) const {
        typedef IsEqual<value_type> IE;
        if (x.size() != this->size()) return false;
        bool eq = IE::eval(x.val(), this->val());
        for (int i=0; i<this->size(); i++)
          eq = eq && IE::eval(x.dx(i), this->dx(i));
        return eq;
      }



      bool hasFastAccess() const { return this->size()!=0;}

      bool isPassive() const { return this->size()!=0;}

      void setIsConstant(bool is_const) {
        if (is_const && this->size()!=0)
          this->resize(0);
      }



      template <typename S>
      SACADO_ENABLE_VALUE_FUNC(LogicalSparseImp&) operator=(const S& v)  {
        this->val() = v;
        if (this->size()) {
          this->zero();
          this->resize(0);
        }
        return *this;
      }

      LogicalSparseImp& operator=(const LogicalSparseImp& x) {
        // Copy value & dx_
        Storage::operator=(x);

        return *this;
      }

      template <typename S>
      SACADO_ENABLE_EXPR_FUNC(LogicalSparseImp&) operator=(const Expr<S>& x) {
        int sz = x.size();

        if (sz != this->size())
          this->resize(sz);

        if (sz) {
          if (x.hasFastAccess())
            for(int i=0; i<sz; ++i)
              this->fastAccessDx(i) = x.fastAccessDx(i);
          else
            for(int i=0; i<sz; ++i)
              this->fastAccessDx(i) = x.dx(i);
        }

        this->val() = x.val();

        return *this;
      }



      template <typename S>
      SACADO_ENABLE_VALUE_FUNC(LogicalSparseImp&) operator += (const S& v) {
        this->val() += v;
        return *this;
      }

      template <typename S>
      SACADO_ENABLE_VALUE_FUNC(LogicalSparseImp&) operator -= (const S& v) {
        this->val() -= v;
        return *this;
      }

      template <typename S>
      SACADO_ENABLE_VALUE_FUNC(LogicalSparseImp&) operator *= (const S& v) {
        this->val() *= v;
        return *this;
      }

      template <typename S>
      SACADO_ENABLE_VALUE_FUNC(LogicalSparseImp&) operator /= (const S& v) {
        this->val() /= v;
        return *this;
      }

      LogicalSparseImp& operator += (const LogicalSparseImp& x) {
        int xsz = x.size(), sz = this->size();

#ifdef SACADO_DEBUG
        if ((xsz != sz) && (xsz != 0) && (sz != 0))
          throw "LFad Error:  Attempt to assign with incompatible sizes";
#endif

        if (xsz) {
          if (sz) {
            for (int i=0; i<xsz; ++i)
              this->fastAccessDx(i) = this->fastAccessDx(i) || x.fastAccessDx(i);
          }
          else {
            this->resize(xsz);
            for (int i=0; i<xsz; ++i)
              this->fastAccessDx(i) = x.fastAccessDx(i);
          }
        }

        this->val() += x.val();

        return *this;
      }

      LogicalSparseImp& operator -= (const LogicalSparseImp& x) {
        int xsz = x.size(), sz = this->size();

#ifdef SACADO_DEBUG
        if ((xsz != sz) && (xsz != 0) && (sz != 0))
          throw "LFad Error:  Attempt to assign with incompatible sizes";
#endif

        if (xsz) {
          if (sz) {
            for (int i=0; i<xsz; ++i)
              this->fastAccessDx(i) = this->fastAccessDx(i) || x.fastAccessDx(i);
          }
          else {
            this->resize(xsz);
            for (int i=0; i<xsz; ++i)
              this->fastAccessDx(i) = x.fastAccessDx(i);
          }
        }

        this->val() -= x.val();


        return *this;
      }

      LogicalSparseImp& operator *= (const LogicalSparseImp& x) {
        int xsz = x.size(), sz = this->size();

#ifdef SACADO_DEBUG
        if ((xsz != sz) && (xsz != 0) && (sz != 0))
          throw "LFad Error:  Attempt to assign with incompatible sizes";
#endif

        if (xsz) {
          if (sz) {
            for (int i=0; i<xsz; ++i)
              this->fastAccessDx(i) = this->fastAccessDx(i) || x.fastAccessDx(i);
          }
          else {
            this->resize(xsz);
            for (int i=0; i<xsz; ++i)
              this->fastAccessDx(i) = x.fastAccessDx(i);
          }
        }

        this->val() *= x.val();

        return *this;
      }

      LogicalSparseImp& operator /= (const LogicalSparseImp& x) {
        int xsz = x.size(), sz = this->size();

#ifdef SACADO_DEBUG
        if ((xsz != sz) && (xsz != 0) && (sz != 0))
          throw "LFad Error:  Attempt to assign with incompatible sizes";
#endif

        if (xsz) {
          if (sz) {
            for (int i=0; i<xsz; ++i)
              this->fastAccessDx(i) = this->fastAccessDx(i) || x.fastAccessDx(i);
          }
          else {
            this->resize(xsz);
            for (int i=0; i<xsz; ++i)
              this->fastAccessDx(i) = x.fastAccessDx(i);
          }
        }

        this->val() /= x.val();

        return *this;
      }

      template <typename S>
      SACADO_ENABLE_EXPR_FUNC(LogicalSparseImp&) operator += (const Expr<S>& x){
        int xsz = x.size(), sz = this->size();

#ifdef SACADO_DEBUG
        if ((xsz != sz) && (xsz != 0) && (sz != 0))
          throw "LFad Error:  Attempt to assign with incompatible sizes";
#endif

        if (xsz) {
          if (sz) {
            if (x.hasFastAccess())
              for (int i=0; i<xsz; ++i)
                this->fastAccessDx(i) = this->fastAccessDx(i) || x.fastAccessDx(i);
            else
              for (int i=0; i<xsz; ++i)
                this->fastAccessDx(i) = this->fastAccessDx(i) || x.dx(i);
          }
          else {
            this->resize(xsz);
            if (x.hasFastAccess())
              for (int i=0; i<xsz; ++i)
                this->fastAccessDx(i) = x.fastAccessDx(i);
            else
              for (int i=0; i<xsz; ++i)
                this->fastAccessDx(i) = x.dx(i);
          }
        }

        this->val() += x.val();

        return *this;
      }

      template <typename S>
      SACADO_ENABLE_EXPR_FUNC(LogicalSparseImp&) operator -= (const Expr<S>& x){
        int xsz = x.size(), sz = this->size();

#ifdef SACADO_DEBUG
        if ((xsz != sz) && (xsz != 0) && (sz != 0))
          throw "LFad Error:  Attempt to assign with incompatible sizes";
#endif

        if (xsz) {
          if (sz) {
            if (x.hasFastAccess())
              for (int i=0; i<xsz; ++i)
                this->fastAccessDx(i) = this->fastAccessDx(i) || x.fastAccessDx(i);
            else
              for (int i=0; i<xsz; ++i)
                this->fastAccessDx(i) = this->fastAccessDx(i) || x.dx(i);
          }
          else {
            this->resize(xsz);
            if (x.hasFastAccess())
              for (int i=0; i<xsz; ++i)
                this->fastAccessDx(i) = x.fastAccessDx(i);
            else
              for (int i=0; i<xsz; ++i)
                this->fastAccessDx(i) = x.dx(i);
          }
        }

        this->val() -= x.val();


        return *this;
      }

      template <typename S>
      SACADO_ENABLE_EXPR_FUNC(LogicalSparseImp&) operator *= (const Expr<S>& x){
        int xsz = x.size(), sz = this->size();

#ifdef SACADO_DEBUG
        if ((xsz != sz) && (xsz != 0) && (sz != 0))
          throw "LFad Error:  Attempt to assign with incompatible sizes";
#endif

        if (xsz) {
          if (sz) {
            if (x.hasFastAccess())
              for (int i=0; i<xsz; ++i)
                this->fastAccessDx(i) = this->fastAccessDx(i) || x.fastAccessDx(i);
            else
              for (int i=0; i<xsz; ++i)
                this->fastAccessDx(i) = this->fastAccessDx(i) || x.dx(i);
          }
          else {
            this->resize(xsz);
            if (x.hasFastAccess())
              for (int i=0; i<xsz; ++i)
                this->fastAccessDx(i) = x.fastAccessDx(i);
            else
              for (int i=0; i<xsz; ++i)
                this->fastAccessDx(i) = x.dx(i);
          }
        }

        this->val() *= x.val();

        return *this;
      }

      template <typename S>
      SACADO_ENABLE_EXPR_FUNC(LogicalSparseImp&) operator /= (const Expr<S>& x){
        int xsz = x.size(), sz = this->size();

#ifdef SACADO_DEBUG
        if ((xsz != sz) && (xsz != 0) && (sz != 0))
          throw "LFad Error:  Attempt to assign with incompatible sizes";
#endif

        if (xsz) {
          if (sz) {
            if (x.hasFastAccess())
              for (int i=0; i<xsz; ++i)
                this->fastAccessDx(i) = this->fastAccessDx(i) || x.fastAccessDx(i);
            else
              for (int i=0; i<xsz; ++i)
                this->fastAccessDx(i) = this->fastAccessDx(i) || x.dx(i);
          }
          else {
            this->resize(xsz);
            if (x.hasFastAccess())
              for (int i=0; i<xsz; ++i)
                this->fastAccessDx(i) = x.fastAccessDx(i);
            else
              for (int i=0; i<xsz; ++i)
                this->fastAccessDx(i) = x.dx(i);
          }
        }

        this->val() /= x.val();

        return *this;
      }


    }; // class LogicalSparseImp

    template <typename ValT, typename LogT>
    class Expr< LogicalSparseImp<ValT,LogT> > :
      public LogicalSparseImp<ValT,LogT> {

    public:

      typedef typename LogicalSparseImp<ValT,LogT>::value_type value_type;

      typedef typename LogicalSparseImp<ValT,LogT>::scalar_type scalar_type;

      typedef LogicalSparse<ValT,LogT> base_expr_type;

      Expr() :
        LogicalSparseImp<ValT,LogT>() {}


      template <typename S>
      Expr(const S & x, SACADO_ENABLE_VALUE_CTOR_DECL) :
        LogicalSparseImp<ValT,LogT>(x) {}


      Expr(const int sz, const ValT & x) :
        LogicalSparseImp<ValT,LogT>(sz,x) {}


      Expr(const int sz, const int i, const ValT & x) :
        LogicalSparseImp<ValT,LogT>(sz,i,x) {}

      Expr(const Expr& x) :
        LogicalSparseImp<ValT,LogT>(x) {}

      template <typename S>
      Expr(const Expr<S>& x, SACADO_ENABLE_EXPR_CTOR_DECL) :
        LogicalSparseImp<ValT,LogT>(x) {}

      ~Expr() {}

    }; // class Expr<LogicalSparseImp>

    template <typename ValT, typename LogT >
    class LogicalSparse : public Expr< LogicalSparseImp<ValT,LogT > > {

    public:

      typedef LogicalSparseImp< ValT,LogT > ImplType;
      typedef Expr<ImplType> ExprType;

      typedef typename ExprType::value_type value_type;

      typedef typename ExprType::scalar_type scalar_type;

      template <typename T, typename U = LogT>
      struct apply {
        typedef LogicalSparse<T,U> type;
      };



      LogicalSparse() :
        ExprType() {}


      template <typename S>
      LogicalSparse(const S& x, SACADO_ENABLE_VALUE_CTOR_DECL) :
        ExprType(x) {}


      LogicalSparse(const int sz, const ValT& x) :
        ExprType(sz,x) {}


      LogicalSparse(const int sz, const int i, const ValT & x) :
        ExprType(sz,i,x) {}

      LogicalSparse(const LogicalSparse& x) :
        ExprType(x) {}

      template <typename S>
      LogicalSparse(const Expr<S>& x, SACADO_ENABLE_EXPR_CTOR_DECL) :
        ExprType(x) {}


      ~LogicalSparse() {}

      template <typename S>
      SACADO_ENABLE_VALUE_FUNC(LogicalSparse&) operator=(const S& v) {
        ImplType::operator=(v);
        return *this;
      }

      LogicalSparse& operator=(const LogicalSparse& x) {
        ImplType::operator=(static_cast<const ImplType&>(x));
        return *this;
      }

      template <typename S>
      SACADO_ENABLE_EXPR_FUNC(LogicalSparse&) operator=(const Expr<S>& x)
        {
          ImplType::operator=(x);
          return *this;
        }

      template <typename S>
      SACADO_ENABLE_VALUE_FUNC(LogicalSparse&) operator += (const S& x) {
        ImplType::operator+=(x);
        return *this;
      }

      template <typename S>
      SACADO_ENABLE_VALUE_FUNC(LogicalSparse&) operator -= (const S& x) {
        ImplType::operator-=(x);
        return *this;
      }

      template <typename S>
      SACADO_ENABLE_VALUE_FUNC(LogicalSparse&) operator *= (const S& x) {
        ImplType::operator*=(x);
        return *this;
      }

      template <typename S>
      SACADO_ENABLE_VALUE_FUNC(LogicalSparse&) operator /= (const S& x) {
        ImplType::operator/=(x);
        return *this;
      }

      LogicalSparse& operator += (const LogicalSparse& x) {
        ImplType::operator+=(static_cast<const ImplType&>(x));
        return *this;
      }

      LogicalSparse& operator -= (const LogicalSparse& x) {
        ImplType::operator-=(static_cast<const ImplType&>(x));
        return *this;
      }

      LogicalSparse& operator *= (const LogicalSparse& x) {
        ImplType::operator*=(static_cast<const ImplType&>(x));
        return *this;
      }

      LogicalSparse& operator /= (const LogicalSparse& x) {
        ImplType::operator/=(static_cast<const ImplType&>(x));
        return *this;
      }

      template <typename S>
      SACADO_ENABLE_EXPR_FUNC(LogicalSparse&) operator += (const Expr<S>& x) {
        ImplType::operator+=(x);
        return *this;
      }

      template <typename S>
      SACADO_ENABLE_EXPR_FUNC(LogicalSparse&) operator -= (const Expr<S>& x) {
        ImplType::operator-=(x);
        return *this;
      }

      template <typename S>
      SACADO_ENABLE_EXPR_FUNC(LogicalSparse&) operator *= (const Expr<S>& x) {
        ImplType::operator*=(x);
        return *this;
      }

      template <typename S>
      SACADO_ENABLE_EXPR_FUNC(LogicalSparse&) operator /= (const Expr<S>& x) {
        ImplType::operator/=(x);
        return *this;
      }

    }; // class LogicalSparse<ValT,LogT>

    template <typename T, typename L>
    struct ExprLevel< LogicalSparse<T,L> > {
      static const unsigned value =
        ExprLevel< typename LogicalSparse<T,L>::value_type >::value + 1;
    };

  } // namespace LFad

  template <typename T>
  struct IsExpr< LFad::Expr<T> > {
    static const bool value = true;
  };

  template <typename T>
  struct BaseExprType< LFad::Expr<T> > {
    typedef typename LFad::Expr<T>::base_expr_type type;
  };

  template <typename T, typename L>
  struct IsExpr< LFad::LogicalSparse<T,L> > {
    static const bool value = true;
  };

  template <typename T, typename L>
  struct BaseExprType< LFad::LogicalSparse<T,L> > {
    typedef typename LFad::LogicalSparse<T,L>::base_expr_type type;
  };

} // namespace Sacado

#include "Sacado_LFad_LogicalSparseOps.hpp"

#endif // SACADO_LFAD_LOGICALSPARSE_HPP