/usr/src/RPM/BUILD/trilinos-11.12.1/packages/intrepid/src/Shared/MiniTensor/Intrepid_MiniTensor_Tensor4.h

// @HEADER
// ************************************************************************
//
//                           Intrepid Package
//                 Copyright (2007) Sandia Corporation
//
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions: Alejandro Mota (amota@sandia.gov)
//
// ************************************************************************
// @HEADER

#if !defined(Intrepid_MiniTensor_Tensor4_h)
#define Intrepid_MiniTensor_Tensor4_h

#include "Intrepid_MiniTensor_Tensor3.h"

namespace Intrepid {

template<typename T, Index N>
struct tensor4_store
{
  typedef Storage<T, dimension_power<N, 4>::value> type;
};

template<typename T, Index N = DYNAMIC>
class Tensor4 : public TensorBase<T, typename tensor4_store<T, N>::type>
{
public:

  static
  Index const
  ORDER = 4;

  static
  bool const
  IS_DYNAMIC = N == DYNAMIC;

  typedef typename tensor4_store<T, N>::type
  Store;

  static
  Index
  get_order() {return ORDER;}

  explicit
  Tensor4();

  explicit
  Tensor4(Index const dimension);

  explicit
  Tensor4(ComponentValue const value);

  explicit
  Tensor4(Index const dimension, ComponentValue const value);

  explicit
  Tensor4(T const * data_ptr);

  explicit
  Tensor4(Index const dimension, T const * data_ptr);

  Tensor4(Tensor4<T, N> const & A);

  Tensor4(Tensor<T, dimension_square<N>::value> const & A);
  ~Tensor4();

  T const &
  operator()(
      Index const i,
      Index const j,
      Index const k,
      Index const l) const;

  T &
  operator()(
      Index const i,
      Index const j,
      Index const k,
      Index const l);

  Index
  get_dimension() const;

  void
  set_dimension(Index const dimension);

};

template<typename S, typename T, Index N>
Tensor4<typename Promote<S, T>::type, N>
operator+(Tensor4<S, N> const & A, Tensor4<T, N> const & B);

template<typename S, typename T, Index N>
Tensor4<typename Promote<S, T>::type, N>
operator-(Tensor4<S, N> const & A, Tensor4<T, N> const & B);

template<typename T, Index N>
Tensor4<T, N>
operator-(Tensor4<T, N> const & A);

template<typename T, Index N>
bool
operator==(Tensor4<T, N> const & A, Tensor4<T, N> const & B);

template<typename T, Index N>
bool
operator!=(Tensor4<T, N> const & A, Tensor4<T, N> const & B);

template<typename S, typename T, Index N>
typename lazy_disable_if< order_1234<S>, apply_tensor4< Promote<S,T>, N> >::type
operator*(S const & s, Tensor4<T, N> const & A);

template<typename S, typename T, Index N>
typename lazy_disable_if< order_1234<S>, apply_tensor4< Promote<S,T>, N> >::type
operator*(Tensor4<T, N> const & A, S const & s);

template<typename S, typename T, Index N>
Tensor4<typename Promote<S, T>::type, N>
operator/(Tensor4<T, N> const & A, S const & s);

template<typename S, typename T, Index N>
Tensor4<typename Promote<S, T>::type, N>
operator/(S const & s, Tensor4<T, N> const & A);

template<typename T, Index N>
Tensor4<T, N>
transpose(Tensor4<T, N> const & A);

template<typename T, Index N>
const Tensor4<T, N>
identity_1();

template<typename T>
const Tensor4<T, DYNAMIC>
identity_1(Index const dimension);

template<typename T, Index N>
const Tensor4<T, N>
identity_1(Index const dimension);

template<typename T, Index N>
const Tensor4<T, N>
identity_2();

template<typename T>
const Tensor4<T, DYNAMIC>
identity_2(Index const dimension);

template<typename T, Index N>
const Tensor4<T, N>
identity_2(Index const dimension);

template<typename T, Index N>
const Tensor4<T, N>
identity_3();

template<typename T>
const Tensor4<T, DYNAMIC>
identity_3(Index const dimension);

template<typename T, Index N>
const Tensor4<T, N>
identity_3(Index const dimension);

template<typename T, Index N>
Tensor4<T, N>
inverse(Tensor4<T, N> const & A);

template<typename S, typename T, Index N>
Tensor3<typename Promote<S, T>::type, N>
dot(Tensor4<T, N> const & A, Vector<S, N> const & u);

template<typename S, typename T, Index N>
Tensor3<typename Promote<S, T>::type, N>
dot(Vector<S, N> const & u, Tensor4<T, N> const & A);

template<typename S, typename T, Index N>
Tensor3<typename Promote<S, T>::type, N>
dot2(Tensor4<T, N> const & A, Vector<S, N> const & u);

template<typename S, typename T, Index N>
Tensor3<typename Promote<S, T>::type, N>
dot2(Vector<S, N> const & u, Tensor4<T, N> const & A);

template<typename S, typename T, Index N>
Tensor<typename Promote<S, T>::type, N>
dotdot(Tensor4<T, N> const & A, Tensor<S, N> const & B);

template<typename S, typename T, Index N>
Tensor<typename Promote<S, T>::type, N>
dotdot(Tensor<S, N> const & B, Tensor4<T, N> const & A);

template<typename S, typename T, Index N>
Tensor4<typename Promote<S, T>::type, N>
dotdot(Tensor4<S, N> const & A, Tensor4<T, N> const & B);

template<typename S, typename T, Index N>
Tensor4<typename Promote<S, T>::type, N>
tensor(Tensor<S, N> const & A, Tensor<T, N> const & B);

template<typename S, typename T, Index N>
Tensor4<typename Promote<S, T>::type, N>
tensor2(Tensor<S, N> const & A, Tensor<T, N> const & B);

template<typename S, typename T, Index N>
Tensor4<typename Promote<S, T>::type, N>
tensor3(Tensor<S, N> const & A, Tensor<T, N> const & B);

template<typename S, typename T, Index N>
Tensor4<typename Promote<S, T>::type, N>
dot(Tensor4<T, N> const & A, Tensor<S, N> const & B);

template<typename S, typename T, Index N>
Tensor4<typename Promote<S, T>::type, N>
dot_t(Tensor4<T, N> const & A, Tensor<S, N> const & B);

template<typename S, typename T, Index N>
Tensor4<typename Promote<S, T>::type, N>
dot(Tensor<S> const & A, Tensor4<T, N> const & B);

template<typename S, typename T, Index N>
Tensor4<typename Promote<S, T>::type, N>
t_dot(Tensor<S, N> const & A, Tensor4<T, N> const & B);

template<typename S, typename T, Index N>
Tensor4<typename Promote<S, T>::type, N>
dot2(Tensor4<T, N> const & A, Tensor<S, N> const & B);

template<typename S, typename T, Index N>
Tensor4<typename Promote<S, T>::type, N>
dot2_t(Tensor4<T, N> const & A, Tensor<S, N> const & B);

template<typename S, typename T, Index N>
Tensor4<typename Promote<S, T>::type, N>
dot2(Tensor<S, N> const & A, Tensor4<T, N> const & B);

template<typename S, typename T, Index N>
Tensor4<typename Promote<S, T>::type, N>
t_dot2(Tensor<S, N> const & A, Tensor4<T, N> const & B);

template<typename S, typename T, Index N>
Tensor4<typename Promote<S, T>::type, N>
odot(Tensor<S, N> const & A, Tensor<T, N> const & B);

template<typename S, typename T, Index N>
Tensor4<typename Promote<S, T>::type, N>
kronecker(Tensor<S, N> const & A, Tensor4<T, N> const & B);

template<typename T, Index N>
std::istream &
operator>>(std::istream & is, Tensor4<T, N> & A);

template<typename T, Index N>
std::ostream &
operator<<(std::ostream & os, Tensor4<T, N> const & A);

} // namespace Intrepid

#include "Intrepid_MiniTensor_Tensor4.i.h"
#include "Intrepid_MiniTensor_Tensor4.t.h"

#endif //Intrepid_MiniTensor_Tensor4_h