RTOp Package Browser (Single Doxygen Collection)  Version of the Day
RTOpPack_RTOpTHelpers_decl.hpp
Go to the documentation of this file.
1 // @HEADER
2 // ***********************************************************************
3 //
4 // RTOp: Interfaces and Support Software for Vector Reduction Transformation
5 // Operations
6 // Copyright (2006) Sandia Corporation
7 //
8 // Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
9 // license for use of this work by or on behalf of the U.S. Government.
10 //
11 // Redistribution and use in source and binary forms, with or without
12 // modification, are permitted provided that the following conditions are
13 // met:
14 //
15 // 1. Redistributions of source code must retain the above copyright
16 // notice, this list of conditions and the following disclaimer.
17 //
18 // 2. Redistributions in binary form must reproduce the above copyright
19 // notice, this list of conditions and the following disclaimer in the
20 // documentation and/or other materials provided with the distribution.
21 //
22 // 3. Neither the name of the Corporation nor the names of the
23 // contributors may be used to endorse or promote products derived from
24 // this software without specific prior written permission.
25 //
26 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
27 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
30 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
34 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
35 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
36 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 //
38 // Questions? Contact Roscoe A. Bartlett (rabartl@sandia.gov)
39 //
40 // ***********************************************************************
41 // @HEADER
42 
43 #ifndef RTOPPACK_RTOP_T_HELPERS_DECL_HPP
44 #define RTOPPACK_RTOP_T_HELPERS_DECL_HPP
45 
46 
47 //#define RTOPPACK_RTOPT_HELPER_DUMP_OUTPUT
48 
49 
50 #include <typeinfo>
51 
52 
53 #include "RTOpPack_RTOpT.hpp"
54 #include "Teuchos_StandardMemberCompositionMacros.hpp"
55 #include "Teuchos_ScalarTraits.hpp"
56 #include "Teuchos_dyn_cast.hpp"
57 #include "Teuchos_TypeNameTraits.hpp"
58 
59 
60 #ifdef RTOPPACK_RTOPT_HELPER_DUMP_OUTPUT
61 # include "Teuchos_VerboseObject.hpp"
62 namespace RTOpPack { extern bool rtop_helpers_dump_all; }
63 #endif // RTOPPACK_RTOPT_HELPER_DUMP_OUTPUT
64 
65 
66 namespace RTOpPack {
67 
68 
73 template<class Scalar>
74 struct ScalarIndex {
76  Scalar scalar;
80  ScalarIndex( const Scalar &_scalar, const Ordinal &_index )
81  : scalar(_scalar), index(_index)
82  {}
85  : scalar(ScalarTraits<Scalar>::zero()), index(-1)
86  {}
87 };
88 
89 
94 template<class Scalar>
95 std::ostream& operator<<(std::ostream &out, const ScalarIndex<Scalar> &scalarIndex)
96 {
97  out << "{"<<scalarIndex.scalar<<","<<scalarIndex.index<<"}";
98  return out;
99 }
100 
101 
105 template <class Scalar>
106 class PrimitiveTypeTraits<Scalar, ScalarIndex<Scalar> > {
107 public:
113  static int numPrimitiveObjs() { return ScalarPrimitiveTypeTraits::numPrimitiveObjs(); }
115  static int numIndexObjs() { return 1; }
117  static int numCharObjs() { return 0; }
119  static void extractPrimitiveObjs(
120  const ScalarIndex<Scalar> &obj,
121  const ArrayView<primitiveType> &primitiveObjs,
122  const ArrayView<index_type> &indexObjs,
123  const ArrayView<char> &charObjs
124  )
125  {
126  assertInput(primitiveObjs, indexObjs, charObjs);
127  ScalarPrimitiveTypeTraits::extractPrimitiveObjs(
128  obj.scalar, primitiveObjs, Teuchos::null, Teuchos::null );
129  indexObjs[0] = obj.index;
130  }
132  static void loadPrimitiveObjs(
133  const ArrayView<const primitiveType> &primitiveObjs,
134  const ArrayView<const index_type> &indexObjs,
135  const ArrayView<const char> &charObjs,
136  const Ptr<ScalarIndex<Scalar> > &obj
137  )
138  {
139  assertInput(primitiveObjs, indexObjs, charObjs);
140  ScalarPrimitiveTypeTraits::loadPrimitiveObjs(
141  primitiveObjs, Teuchos::null, Teuchos::null,
142  Teuchos::outArg(obj->scalar) );
143  obj->index = indexObjs[0];
144  }
145 private:
146  static void assertInput(
147  const ArrayView<const primitiveType> &primitiveObjs,
148  const ArrayView<const index_type> &indexObjs,
149  const ArrayView<const char> &charObjs
150  )
151  {
152 #ifdef TEUCHOS_DEBUG
153  TEUCHOS_TEST_FOR_EXCEPT(
154  primitiveObjs.size()!=ScalarPrimitiveTypeTraits::numPrimitiveObjs()
155  || indexObjs.size()!=1
156  || charObjs.size()!=0 );
157 #endif
158  }
159 };
160 
161 
166 template<class ConcreteReductObj>
168 public:
170  DefaultReductTarget( const ConcreteReductObj &concreteReductObj )
171  : concreteReductObj_(concreteReductObj)
172  {}
174  void set( const ConcreteReductObj &concreteReductObj )
175  { concreteReductObj_ = concreteReductObj; }
177  const ConcreteReductObj& get() const
178  { return concreteReductObj_; }
180  std::string description() const;
181 private:
182  ConcreteReductObj concreteReductObj_;
183 };
184 
185 
190 template<class ConcreteReductObj>
191 const RCP<DefaultReductTarget<ConcreteReductObj> >
192 defaultReductTarget( const ConcreteReductObj &concreteReductObj )
193 {
194  return Teuchos::rcp(
195  new DefaultReductTarget<ConcreteReductObj>(concreteReductObj));
196 }
197 
198 
221 template<class Scalar>
222 void validate_apply_op(
223  const RTOpT<Scalar> &op,
224  const int allowed_num_sub_vecs,
225  const int allowed_num_targ_sub_vecs,
226  const bool expect_reduct_obj,
227  const ArrayView<const ConstSubVectorView<Scalar> > &sub_vecs,
228  const ArrayView<const SubVectorView<Scalar> > &targ_sub_vecs,
229  const Ptr<const ReductTarget> &reduct_obj
230  );
231 
232 
233 //
234 // Reduction object operator support
235 //
236 
237 
240 
241 
243 template<class ConcreteReductObj, int ReductionType>
245 public:
247  inline void operator()(const ConcreteReductObj& in_reduct, ConcreteReductObj& inout_reduct) const
248  {
249  return in_reduct.this_reduction_type_needs_a_specialization();
250  }
251 };
252 
253 
255 template<class ConcreteReductObj>
256 class BasicReductObjReductionOp<ConcreteReductObj, REDUCT_TYPE_SUM> {
257 public:
259  inline void operator()(const ConcreteReductObj& in_reduct, ConcreteReductObj& inout_reduct) const
260  {
261  inout_reduct += in_reduct;
262  }
263 };
264 
265 
267 template<class ConcreteReductObj>
268 class BasicReductObjReductionOp<ConcreteReductObj, REDUCT_TYPE_MAX> {
269 public:
271  inline void operator()(const ConcreteReductObj& in_reduct, ConcreteReductObj& inout_reduct) const
272  {
273  inout_reduct = std::max(inout_reduct, in_reduct);
274  }
275 };
276 
277 
279 template<class ConcreteReductObj>
280 class BasicReductObjReductionOp<ConcreteReductObj, REDUCT_TYPE_MIN> {
281 public:
283  inline void operator()(const ConcreteReductObj& in_reduct, ConcreteReductObj& inout_reduct) const
284  {
285  inout_reduct = std::min(inout_reduct, in_reduct);
286  }
287 };
288 
289 
291 template<class Scalar>
293 public:
295  inline void operator()(const Scalar& in_reduct, Scalar& inout_reduct) const
296  {
297  inout_reduct += in_reduct;
298  }
299 };
300 // 2008/07/03: rabart: Above: I have broken from the Thyra guideline of
301 // passing in-out arguments as const Ptr<Type>& and used raw non-const
302 // reference Type& instead to allow the user function to be more readable.
303 
304 
306 template<class Scalar, class ConcreteReductObj, class ReductObjReduction>
307 class ROpScalarReductionWithOpBase : public RTOpT<Scalar>
308 {
309 public:
310 
313 
316 
319  const ConcreteReductObj &initReductObjValue_in = ScalarTraits<Scalar>::zero(),
320  ReductObjReduction reductObjReduction_in = ReductObjReduction()
321  )
322  : initReductObjValue_(initReductObjValue_in),
323  reductObjReduction_(reductObjReduction_in)
324  {}
325 
327  const ConcreteReductObj& getRawVal( const ReductTarget &reduct_obj ) const
328  {
329  using Teuchos::dyn_cast;
330  return dyn_cast<const DefaultReductTarget<ConcreteReductObj> >(reduct_obj).get();
331  }
332 
334  void setRawVal( const ConcreteReductObj &rawVal,
335  const Ptr<ReductTarget> &reduct_obj
336  ) const
337  {
338  using Teuchos::dyn_cast;
339  dyn_cast<DefaultReductTarget<ConcreteReductObj> >(*reduct_obj).set(rawVal);
340  }
341 
343  ConcreteReductObj operator()(const ReductTarget& reduct_obj ) const
344  {
345  return this->getRawVal(reduct_obj);
346  }
347 
350 
353  const Ptr<int> &num_values,
354  const Ptr<int> &num_indexes,
355  const Ptr<int> &num_chars
356  ) const
357  {
359  *num_values = PTT::numPrimitiveObjs();
360  *num_indexes = PTT::numIndexObjs();
361  *num_chars = PTT::numCharObjs();
362  }
363 
365  Teuchos::RCP<ReductTarget> reduct_obj_create_impl() const
366  {
367  return Teuchos::rcp(
368  new DefaultReductTarget<ConcreteReductObj>(initReductObjValue()));
369  }
370 
373  const ReductTarget& in_reduct_obj, const Ptr<ReductTarget>& inout_reduct_obj
374  ) const
375  {
376  const ConcreteReductObj scalar_in_reduct_obj = this->getRawVal(in_reduct_obj);
377  ConcreteReductObj scalar_inout_reduct_obj = this->getRawVal(*inout_reduct_obj);
378  reductObjReduction_(scalar_in_reduct_obj, scalar_inout_reduct_obj);
379  this->setRawVal( scalar_inout_reduct_obj, inout_reduct_obj );
380  }
381 
383  void reduct_obj_reinit_impl( const Ptr<ReductTarget> &reduct_obj ) const
384  {
385  setRawVal( initReductObjValue(), reduct_obj );
386  }
387 
390  const ReductTarget &reduct_obj,
391  const ArrayView<primitive_value_type> &value_data,
392  const ArrayView<index_type> &index_data,
393  const ArrayView<char_type> &char_data
394  ) const
395  {
397  PTT::extractPrimitiveObjs( getRawVal(reduct_obj),
398  value_data, index_data, char_data );
399  }
400 
403  const ArrayView<const primitive_value_type> &value_data,
404  const ArrayView<const index_type> &index_data,
405  const ArrayView<const char_type> &char_data,
406  const Ptr<ReductTarget> &reduct_obj
407  ) const
408  {
410  ConcreteReductObj concrete_reduct_obj;
411  PTT::loadPrimitiveObjs( value_data, index_data, char_data,
412  Teuchos::outArg(concrete_reduct_obj) );
413  this->setRawVal( concrete_reduct_obj, reduct_obj );
414  }
415 
417 
418 protected:
419 
421  STANDARD_MEMBER_COMPOSITION_MEMBERS( ConcreteReductObj, initReductObjValue );
422 
423 private:
424 
425  ReductObjReduction reductObjReduction_;
426 
427 };
428 
429 
430 //
431 // ROp 1 vector scalar reduction
432 //
433 
434 
436 template<class Scalar, class ConcreteReductObj, class EleWiseReduction,
437  class ReductObjReduction = SumScalarReductObjReduction<ConcreteReductObj> >
439  : public ROpScalarReductionWithOpBase<Scalar, ConcreteReductObj, ReductObjReduction>
440 {
441 public:
442 
445 
448  const ConcreteReductObj &initReductObjValue_in = ConcreteReductObj(),
449  EleWiseReduction eleWiseReduction_in = EleWiseReduction(),
450  ReductObjReduction reductObjReduction_in = ReductObjReduction()
451  )
452  : base_t(initReductObjValue_in, reductObjReduction_in),
453  eleWiseReduction_(eleWiseReduction_in)
454  {}
455 
458 
461  const ArrayView<const ConstSubVectorView<Scalar> > &sub_vecs,
462  const ArrayView<const SubVectorView<Scalar> > &targ_sub_vecs,
463  const Ptr<ReductTarget> &reduct_obj_inout
464  ) const
465  {
466  typedef typename Teuchos::ArrayRCP<const Scalar>::iterator const_iter_t;
467  using Teuchos::dyn_cast;
468 
469 #ifdef TEUCHOS_DEBUG
470  validate_apply_op<Scalar>(*this, 1, 0, true,
471  sub_vecs, targ_sub_vecs, reduct_obj_inout.getConst());
472 #endif
473 
475  dyn_cast<DefaultReductTarget<ConcreteReductObj> >(*reduct_obj_inout);
476  ConcreteReductObj reduct = reduct_obj.get();
477 
478  const RTOpPack::index_type subDim = sub_vecs[0].subDim();
479 
480  const_iter_t v0_val = sub_vecs[0].values().begin();
481  const ptrdiff_t v0_s = sub_vecs[0].stride();
482 
483  if ( v0_s == 1 ) {
484  for( Teuchos_Ordinal i = 0; i < subDim; ++i )
485  eleWiseReduction_( *v0_val++, reduct);
486  }
487  else {
488  for( Teuchos_Ordinal i = 0; i < subDim; ++i, v0_val += v0_s )
489  eleWiseReduction_( *v0_val, reduct);
490  }
491 
492  reduct_obj.set(reduct);
493 
494  }
495 
497 
498 private:
499 
500  EleWiseReduction eleWiseReduction_;
501 
502 };
503 
504 
506 #define RTOP_ROP_1_REDUCT_SCALAR_CUSTOM_DEFAULT( ROP_CLASS_NAME, REDUCT_SCALAR, \
507  BASIC_REDUCT_TYPE_ENUM, CUSTOM_DEFAULT \
508  ) \
509  \
510  template<class Scalar, class ReductScalar> \
511  class ROP_CLASS_NAME ## EleWiseReduction \
512  { \
513  public: \
514  inline void operator()( \
515  const Scalar &v0, \
516  ReductScalar &reduct \
517  ) const; \
518  }; \
519  \
520  \
521  template<class Scalar> \
522  class ROP_CLASS_NAME \
523  : public RTOpPack::ROp_1_ScalarReduction< \
524  Scalar, \
525  REDUCT_SCALAR, \
526  ROP_CLASS_NAME ## EleWiseReduction<Scalar, REDUCT_SCALAR >, \
527  RTOpPack::BasicReductObjReductionOp<REDUCT_SCALAR, BASIC_REDUCT_TYPE_ENUM> > \
528  { \
529  typedef RTOpPack::ROp_1_ScalarReduction< \
530  Scalar, \
531  REDUCT_SCALAR, \
532  ROP_CLASS_NAME ## EleWiseReduction<Scalar, REDUCT_SCALAR >, \
533  RTOpPack::BasicReductObjReductionOp<REDUCT_SCALAR, BASIC_REDUCT_TYPE_ENUM> > \
534  base_t; \
535  public: \
536  ROP_CLASS_NAME() \
537  : base_t(CUSTOM_DEFAULT) \
538  { \
539  this->setOpNameBase( #ROP_CLASS_NAME ); \
540  } \
541  }; \
542  \
543  \
544  template<class Scalar, class ReductScalar> \
545  void ROP_CLASS_NAME ## EleWiseReduction<Scalar, ReductScalar>::operator()( \
546  const Scalar &v0, ReductScalar &reduct \
547  ) const
548 
549 
551 #define RTOP_ROP_1_REDUCT_SCALAR( ROP_CLASS_NAME, REDUCT_SCALAR, \
552  BASIC_REDUCT_TYPE_ENUM \
553  ) \
554  RTOP_ROP_1_REDUCT_SCALAR_CUSTOM_DEFAULT(ROP_CLASS_NAME, REDUCT_SCALAR, \
555  BASIC_REDUCT_TYPE_ENUM, Teuchos::ScalarTraits<REDUCT_SCALAR >::zero() )
556 
557 
558 //
559 // ROp 1 coordinate-variant vector scalar reduction
560 //
561 
562 
565 template<
566  class Scalar,
567  class ReductScalar,
568  class EleWiseReduction,
569  class ReductObjReduction = SumScalarReductObjReduction<ReductScalar>
570  >
572  : public ROpScalarReductionWithOpBase<Scalar, ReductScalar, ReductObjReduction>
573 {
574 public:
575 
578 
581 
584  const ReductScalar &initReductObjValue_in = ReductScalar(),
585  EleWiseReduction eleWiseReduction_in = EleWiseReduction(),
586  ReductObjReduction reductObjReduction_in = ReductObjReduction()
587  )
588  : base_t(initReductObjValue_in, reductObjReduction_in),
589  eleWiseReduction_(eleWiseReduction_in)
590  {}
591 
593  void setEleWiseReduction(EleWiseReduction eleWiseReduction_in)
594  { eleWiseReduction_ = eleWiseReduction_in; }
595 
597  const EleWiseReduction& getEleWiseReduction() const
598  { return eleWiseReduction_; }
599 
601 
604 
606  bool coord_invariant_impl() const { return false; }
607 
610  const ArrayView<const ConstSubVectorView<Scalar> > &sub_vecs,
611  const ArrayView<const SubVectorView<Scalar> > &targ_sub_vecs,
612  const Ptr<ReductTarget> &reduct_obj_inout
613  ) const
614  {
615  typedef typename Teuchos::ArrayRCP<const Scalar>::iterator const_iter_t;
616  using Teuchos::dyn_cast;
617 
618 #ifdef TEUCHOS_DEBUG
619  validate_apply_op<Scalar>(*this, 1, 0, true,
620  sub_vecs, targ_sub_vecs, reduct_obj_inout);
621 #endif
622 
624  dyn_cast<DefaultReductTarget<ReductScalar> >(*reduct_obj_inout);
625  ReductScalar reduct = reduct_obj.get();
626 
627  const RTOpPack::index_type subDim = sub_vecs[0].subDim();
628 
629  const_iter_t v0_val = sub_vecs[0].values().begin();
630  const ptrdiff_t v0_s = sub_vecs[0].stride();
631 
632  RTOpPack::index_type global_i = sub_vecs[0].globalOffset();
633 
634  if ( v0_s == 1 ) {
635  for( Teuchos_Ordinal i = 0; i < subDim; ++i, ++global_i )
636  eleWiseReduction_( global_i, *v0_val++, reduct);
637  }
638  else {
639  for( Teuchos_Ordinal i = 0; i < subDim; ++i, v0_val += v0_s, ++global_i )
640  eleWiseReduction_( global_i, *v0_val, reduct);
641  }
642 
643  reduct_obj.set(reduct);
644 
645  }
646 
648 
649 private:
650 
651  EleWiseReduction eleWiseReduction_;
652 
653 };
654 
655 
656 //
657 // ROp 2 vector scalar reduction
658 //
659 
660 
662 template<
663  class Scalar,
664  class ReductScalar,
665  class EleWiseReduction,
666  class ReductObjReduction = SumScalarReductObjReduction<ReductScalar>
667  >
669  : public ROpScalarReductionWithOpBase<Scalar, ReductScalar, ReductObjReduction>
670 {
671 public:
672 
676 
679  const ReductScalar &initReductObjValue_in = ReductScalar(),
680  EleWiseReduction eleWiseReduction_in = EleWiseReduction(),
681  ReductObjReduction reductObjReduction_in = ReductObjReduction()
682  )
683  : base_t(initReductObjValue_in, reductObjReduction_in),
684  eleWiseReduction_(eleWiseReduction_in)
685  {}
686 
689 
692  const ArrayView<const ConstSubVectorView<Scalar> > &sub_vecs,
693  const ArrayView<const SubVectorView<Scalar> > &targ_sub_vecs,
694  const Ptr<ReductTarget> &reduct_obj_inout
695  ) const
696  {
697  typedef typename Teuchos::ArrayRCP<const Scalar>::iterator const_iter_t;
698  using Teuchos::dyn_cast;
699 
700 #ifdef TEUCHOS_DEBUG
701  validate_apply_op<Scalar>(*this, 2, 0, true,
702  sub_vecs, targ_sub_vecs, reduct_obj_inout.getConst());
703 #endif
704 
705  DefaultReductTarget<Scalar> &reduct_obj =
706  dyn_cast<DefaultReductTarget<Scalar> >(*reduct_obj_inout);
707  Scalar reduct = reduct_obj.get();
708 
709  const RTOpPack::index_type subDim = sub_vecs[0].subDim();
710 
711  const_iter_t v0_val = sub_vecs[0].values().begin();
712  const ptrdiff_t v0_s = sub_vecs[0].stride();
713  const_iter_t v1_val = sub_vecs[1].values().begin();
714  const ptrdiff_t v1_s = sub_vecs[1].stride();
715 
716  if( v0_s == 1 && v1_s == 1 ) {
717  for( Teuchos_Ordinal i = 0; i < subDim; ++i )
718  eleWiseReduction_( *v0_val++, *v1_val++, reduct);
719  }
720  else {
721  for( Teuchos_Ordinal i = 0; i < subDim; ++i, v0_val += v0_s, v1_val += v1_s )
722  eleWiseReduction_( *v0_val, *v1_val, reduct);
723  }
724 
725  reduct_obj.set(reduct);
726 
727  }
728 
730 
731 private:
732 
733  EleWiseReduction eleWiseReduction_;
734 
735 };
736 
737 
741 #define RTOP_ROP_2_REDUCT_SCALAR( ROP_CLASS_NAME, REDUCT_SCALAR, \
742  BASIC_REDUCT_TYPE_ENUM \
743  ) \
744  \
745  template<class Scalar, class ReductScalar> \
746  class ROP_CLASS_NAME ## EleWiseReduction \
747  { \
748  public: \
749  inline void operator()(const Scalar &v0, \
750  const Scalar &v1, \
751  ReductScalar &reduct \
752  ) const; \
753  }; \
754  \
755  \
756  template<class Scalar> \
757  class ROP_CLASS_NAME \
758  : public RTOpPack::ROp_2_ScalarReduction< \
759  Scalar, \
760  REDUCT_SCALAR, \
761  ROP_CLASS_NAME ## EleWiseReduction<Scalar, REDUCT_SCALAR >, \
762  RTOpPack::BasicReductObjReductionOp<REDUCT_SCALAR, BASIC_REDUCT_TYPE_ENUM> > \
763  { \
764  public: \
765  ROP_CLASS_NAME() \
766  { \
767  this->setOpNameBase( #ROP_CLASS_NAME ); \
768  this->initReductObjValue(ScalarTraits<REDUCT_SCALAR >::zero()); \
769  } \
770  }; \
771  \
772  template<class Scalar, class ReductScalar> \
773  void ROP_CLASS_NAME ## EleWiseReduction<Scalar, ReductScalar>::operator()( \
774  const Scalar &v0, const Scalar &v1, ReductScalar &reduct) const
775 
776 
777 //
778 // TOp 0 to 1 vector transformation
779 //
780 
781 
783 template<class Scalar, class EleWiseTransformation>
784 class TOp_0_1_Base : public RTOpT<Scalar>
785 {
786 public:
787 
790  EleWiseTransformation eleWiseTransformation = EleWiseTransformation()
791  )
792  : eleWiseTransformation_(eleWiseTransformation)
793  {}
794 
797 
800  const ArrayView<const ConstSubVectorView<Scalar> > &sub_vecs,
801  const ArrayView<const SubVectorView<Scalar> > &targ_sub_vecs,
802  const Ptr<ReductTarget> &reduct_obj_inout
803  ) const
804  {
805  typedef typename Teuchos::ArrayRCP<Scalar>::iterator iter_t;
806 
807 #ifdef TEUCHOS_DEBUG
808  validate_apply_op<Scalar>(*this, 0, 1, false,
809  sub_vecs, targ_sub_vecs, reduct_obj_inout.getConst());
810 #endif
811 
812  const RTOpPack::index_type subDim = targ_sub_vecs[0].subDim();
813 
814  iter_t z0_val = targ_sub_vecs[0].values().begin();
815  const ptrdiff_t z0_s = targ_sub_vecs[0].stride();
816 
817  if ( z0_s == 1 ) {
818  for( Teuchos_Ordinal i = 0; i < subDim; ++i )
819  eleWiseTransformation_( *z0_val++);
820  }
821  else {
822  for( Teuchos_Ordinal i = 0; i < subDim; ++i, z0_val += z0_s )
823  eleWiseTransformation_( *z0_val);
824  }
825 
826  }
827 
829 
830 private:
831 
832  EleWiseTransformation eleWiseTransformation_;
833 
834 };
835 
836 
839 template<class Scalar, class EleWiseTransformation>
840 class TOp_0_1_CoordVariantBase : public RTOpT<Scalar>
841 {
842 public:
843 
846  EleWiseTransformation eleWiseTransformation = EleWiseTransformation()
847  )
848  : eleWiseTransformation_(eleWiseTransformation)
849  {}
850 
852  void setEleWiseTransformation(EleWiseTransformation eleWiseTransformation)
853  {
854  eleWiseTransformation_ = eleWiseTransformation;
855  }
856 
858  const EleWiseTransformation& getEleWiseTransformation() const
859  {
860  return eleWiseTransformation_;
861  }
862 
865 
867  bool coord_invariant_impl() const { return false; }
868 
871  const ArrayView<const ConstSubVectorView<Scalar> > &sub_vecs,
872  const ArrayView<const SubVectorView<Scalar> > &targ_sub_vecs,
873  const Ptr<ReductTarget> &reduct_obj_inout
874  ) const
875  {
876  typedef typename Teuchos::ArrayRCP<Scalar>::iterator iter_t;
877 
878 #ifdef TEUCHOS_DEBUG
879  validate_apply_op<Scalar>(*this, 0, 1, false,
880  sub_vecs, targ_sub_vecs, reduct_obj_inout.getConst());
881 #endif
882 
883  const RTOpPack::index_type subDim = targ_sub_vecs[0].subDim();
884 
885  iter_t z0_val = targ_sub_vecs[0].values().begin();
886  const ptrdiff_t z0_s = targ_sub_vecs[0].stride();
887 
888  RTOpPack::index_type global_i = targ_sub_vecs[0].globalOffset();
889 
890  if ( z0_s == 1 ) {
891  for( Teuchos_Ordinal i = 0; i < subDim; ++i, ++global_i )
892  eleWiseTransformation_(global_i, *z0_val++);
893  }
894  else {
895  for( Teuchos_Ordinal i = 0; i < subDim; ++i, z0_val += z0_s, ++global_i )
896  eleWiseTransformation_(global_i, *z0_val);
897  }
898 
899  }
900 
902 
903 private:
904 
905  EleWiseTransformation eleWiseTransformation_;
906 
907 };
908 
909 
910 //
911 // TOp 1 to 1 vector transformation
912 //
913 
914 
916 template<class Scalar, class EleWiseTransformation>
917 class TOp_1_1_Base : public RTOpT<Scalar>
918 {
919 public:
920 
923  EleWiseTransformation eleWiseTransformation = EleWiseTransformation()
924  )
925  : eleWiseTransformation_(eleWiseTransformation)
926  {}
927 
930 
933  const ArrayView<const ConstSubVectorView<Scalar> > &sub_vecs,
934  const ArrayView<const SubVectorView<Scalar> > &targ_sub_vecs,
935  const Ptr<ReductTarget> &reduct_obj_inout
936  ) const
937  {
938  typedef typename Teuchos::ArrayRCP<const Scalar>::iterator const_iter_t;
939  typedef typename Teuchos::ArrayRCP<Scalar>::iterator iter_t;
940 
941 #ifdef TEUCHOS_DEBUG
942  validate_apply_op<Scalar>(*this, 1, 1, false,
943  sub_vecs, targ_sub_vecs, reduct_obj_inout.getConst());
944 #endif
945 
946  const RTOpPack::index_type subDim = sub_vecs[0].subDim();
947 
948  const_iter_t v0_val = sub_vecs[0].values().begin();
949  const ptrdiff_t v0_s = sub_vecs[0].stride();
950 
951  iter_t z0_val = targ_sub_vecs[0].values().begin();
952  const ptrdiff_t z0_s = targ_sub_vecs[0].stride();
953 
954  if ( v0_s == 1 && z0_s == 1 ) {
955  for( Teuchos_Ordinal i = 0; i < subDim; ++i )
956  eleWiseTransformation_( *v0_val++, *z0_val++);
957  }
958  else {
959  for( Teuchos_Ordinal i = 0; i < subDim; ++i, v0_val += v0_s, z0_val += z0_s )
960  eleWiseTransformation_( *v0_val, *z0_val);
961  }
962 
963  }
964 
966 
967 private:
968 
969  EleWiseTransformation eleWiseTransformation_;
970 
971 };
972 
973 
975 #define RTOP_TOP_1_1( TOP_CLASS_NAME ) \
976  \
977  template<class Scalar> \
978  class TOP_CLASS_NAME ## EleWiseTransformation \
979  { \
980  public: \
981  inline void operator()( const Scalar &v0, Scalar &z0 ) const; \
982  }; \
983  \
984  \
985  template<class Scalar> \
986  class TOP_CLASS_NAME \
987  : public RTOpPack::TOp_1_1_Base< Scalar, \
988  TOP_CLASS_NAME ## EleWiseTransformation<Scalar> > \
989  { \
990  public: \
991  TOP_CLASS_NAME() \
992  { \
993  this->setOpNameBase( #TOP_CLASS_NAME ); \
994  } \
995  }; \
996  \
997  \
998  template<class Scalar> \
999  void TOP_CLASS_NAME ## EleWiseTransformation<Scalar>::operator()( \
1000  const Scalar &v0, Scalar &z0 \
1001  ) const
1002 
1003 
1004 //
1005 // TOp 2 to 1 vector transformation
1006 //
1007 
1008 
1010 template<class Scalar, class EleWiseTransformation>
1011 class TOp_2_1_Base : public RTOpT<Scalar>
1012 {
1013 public:
1014 
1017  EleWiseTransformation eleWiseTransformation = EleWiseTransformation()
1018  )
1019  : eleWiseTransformation_(eleWiseTransformation)
1020  {}
1021 
1024 
1027  const ArrayView<const ConstSubVectorView<Scalar> > &sub_vecs,
1028  const ArrayView<const SubVectorView<Scalar> > &targ_sub_vecs,
1029  const Ptr<ReductTarget> &reduct_obj_inout
1030  ) const
1031  {
1032  typedef typename Teuchos::ArrayRCP<const Scalar>::iterator const_iter_t;
1033  typedef typename Teuchos::ArrayRCP<Scalar>::iterator iter_t;
1034 
1035 #ifdef TEUCHOS_DEBUG
1036  validate_apply_op<Scalar>(*this, 2, 1, false,
1037  sub_vecs, targ_sub_vecs, reduct_obj_inout);
1038 #endif
1039 
1040  const RTOpPack::index_type subDim = sub_vecs[0].subDim();
1041 
1042  const_iter_t v0_val = sub_vecs[0].values().begin();
1043  const ptrdiff_t v0_s = sub_vecs[0].stride();
1044 
1045  const_iter_t v1_val = sub_vecs[1].values().begin();
1046  const ptrdiff_t v1_s = sub_vecs[1].stride();
1047 
1048  iter_t z0_val = targ_sub_vecs[0].values().begin();
1049  const ptrdiff_t z0_s = targ_sub_vecs[0].stride();
1050 
1051  if ( v0_s == 1 && v1_s == 1 && z0_s == 1 ) {
1052  for( Teuchos_Ordinal i = 0; i < subDim; ++i )
1053  eleWiseTransformation_( *v0_val++, *v1_val++, *z0_val++ );
1054  }
1055  else {
1056  for(
1057  Teuchos_Ordinal i = 0;
1058  i < subDim;
1059  ++i, v0_val += v0_s, v1_val += v1_s, z0_val += z0_s
1060  )
1061  {
1062  eleWiseTransformation_( *v0_val, *v1_val, *z0_val );
1063  }
1064  }
1065 
1066  }
1067 
1068 
1070 
1071 private:
1072 
1073  EleWiseTransformation eleWiseTransformation_;
1074 
1075 };
1076 
1078 template<class Scalar, class EleWiseTransformation>
1079 class TOp_3_1_Base : public RTOpT<Scalar>
1080 {
1081 public:
1082 
1085  EleWiseTransformation eleWiseTransformation = EleWiseTransformation()
1086  )
1087  : eleWiseTransformation_(eleWiseTransformation)
1088  {}
1089 
1092 
1095  const ArrayView<const ConstSubVectorView<Scalar> > &sub_vecs,
1096  const ArrayView<const SubVectorView<Scalar> > &targ_sub_vecs,
1097  const Ptr<ReductTarget> &reduct_obj_inout
1098  ) const
1099  {
1100  typedef typename Teuchos::ArrayRCP<const Scalar>::iterator const_iter_t;
1101  typedef typename Teuchos::ArrayRCP<Scalar>::iterator iter_t;
1102 
1103 #ifdef TEUCHOS_DEBUG
1104  validate_apply_op<Scalar>(*this, 3, 1, false,
1105  sub_vecs, targ_sub_vecs, reduct_obj_inout);
1106 #endif
1107 
1108  const RTOpPack::index_type subDim = sub_vecs[0].subDim();
1109 
1110  const_iter_t v0_val = sub_vecs[0].values().begin();
1111  const ptrdiff_t v0_s = sub_vecs[0].stride();
1112 
1113  const_iter_t v1_val = sub_vecs[1].values().begin();
1114  const ptrdiff_t v1_s = sub_vecs[1].stride();
1115 
1116  const_iter_t v2_val = sub_vecs[2].values().begin();
1117  const ptrdiff_t v2_s = sub_vecs[2].stride();
1118 
1119  iter_t z0_val = targ_sub_vecs[0].values().begin();
1120  const ptrdiff_t z0_s = targ_sub_vecs[0].stride();
1121 
1122  if ( v0_s == 1 && v1_s == 1 && v2_s == 1 && z0_s == 1 ) {
1123  for( Teuchos_Ordinal i = 0; i < subDim; ++i )
1124  eleWiseTransformation_( *v0_val++, *v1_val++, *v2_val++, *z0_val++ );
1125  }
1126  else {
1127  for(
1128  Teuchos_Ordinal i = 0;
1129  i < subDim;
1130  ++i, v0_val += v0_s, v1_val += v1_s, v2_val += v2_s, z0_val += z0_s
1131  )
1132  {
1133  eleWiseTransformation_( *v0_val, *v1_val, *v2_val, *z0_val );
1134  }
1135  }
1136 
1137  }
1138 
1140 
1141 private:
1142 
1143  EleWiseTransformation eleWiseTransformation_;
1144 
1145 };
1146 
1147 
1148 } // namespace RTOpPack
1149 
1150 
1151 #endif // RTOPPACK_RTOP_T_HELPERS_DECL_HPP
void apply_op_impl(const ArrayView< const ConstSubVectorView< Scalar > > &sub_vecs, const ArrayView< const SubVectorView< Scalar > > &targ_sub_vecs, const Ptr< ReductTarget > &reduct_obj_inout) const
Teuchos::RCP< ReductTarget > reduct_obj_create_impl() const
const ConcreteReductObj & get() const
Base class for scalar reduction RTOps with one input vector.
Base class for coordinate-variant scalar reduction RTOps with one input vector.
Simple ReductTarget subclass for simple scalar objects.
ROp_2_ScalarReduction(const ReductScalar &initReductObjValue_in=ReductScalar(), EleWiseReduction eleWiseReduction_in=EleWiseReduction(), ReductObjReduction reductObjReduction_in=ReductObjReduction())
Null reduction object reduction operator.
TOp_0_1_CoordVariantBase(EleWiseTransformation eleWiseTransformation=EleWiseTransformation())
static void assertInput(const ArrayView< const primitiveType > &primitiveObjs, const ArrayView< const index_type > &indexObjs, const ArrayView< const char > &charObjs)
const RCP< DefaultReductTarget< ConcreteReductObj > > defaultReductTarget(const ConcreteReductObj &concreteReductObj)
Nonmember constructor.
STANDARD_MEMBER_COMPOSITION_MEMBERS(ConcreteReductObj, initReductObjValue)
void operator()(const ConcreteReductObj &in_reduct, ConcreteReductObj &inout_reduct) const
Base class for coordinate variant transformations for 0 input and 1 output vector.
const EleWiseTransformation & getEleWiseTransformation() const
Class for a changeable sub-vector.
void apply_op_impl(const ArrayView< const ConstSubVectorView< Scalar > > &sub_vecs, const ArrayView< const SubVectorView< Scalar > > &targ_sub_vecs, const Ptr< ReductTarget > &reduct_obj_inout) const
Base class for transformations for 2 input and 1 output vector.
DefaultReductTarget(const ConcreteReductObj &concreteReductObj)
void setEleWiseReduction(EleWiseReduction eleWiseReduction_in)
ROp_1_ScalarReduction(const ConcreteReductObj &initReductObjValue_in=ConcreteReductObj(), EleWiseReduction eleWiseReduction_in=EleWiseReduction(), ReductObjReduction reductObjReduction_in=ReductObjReduction())
Base class for transformations for 0 input and 1 output vector.
TOp_0_1_Base(EleWiseTransformation eleWiseTransformation=EleWiseTransformation())
void set(const ConcreteReductObj &concreteReductObj)
Teuchos_Ordinal index_type
void reduct_obj_reinit_impl(const Ptr< ReductTarget > &reduct_obj) const
void apply_op_impl(const ArrayView< const ConstSubVectorView< Scalar > > &sub_vecs, const ArrayView< const SubVectorView< Scalar > > &targ_sub_vecs, const Ptr< ReductTarget > &reduct_obj_inout) const
virtual void reduce_reduct_objs_impl(const ReductTarget &in_reduct_obj, const Ptr< ReductTarget > &inout_reduct_obj) const
void get_reduct_type_num_entries_impl(const Ptr< int > &num_values, const Ptr< int > &num_indexes, const Ptr< int > &num_chars) const
Base class for transformations for 1 input and 1 output vector.
EleWiseTransformation eleWiseTransformation_
TOp_1_1_Base(EleWiseTransformation eleWiseTransformation=EleWiseTransformation())
Class for a non-changeable sub-vector.
ROpScalarReductionWithOpBase< Scalar, ConcreteReductObj, ReductObjReduction > base_t
Templated interface to vector reduction/transformation operators {abstract}.
Simple struct for a Scalar and an Ordinal object.
void operator()(const Scalar &in_reduct, Scalar &inout_reduct) const
Specialization where the scalar type is the same as the concrete object type.
void apply_op_impl(const ArrayView< const ConstSubVectorView< Scalar > > &sub_vecs, const ArrayView< const SubVectorView< Scalar > > &targ_sub_vecs, const Ptr< ReductTarget > &reduct_obj_inout) const
void setEleWiseTransformation(EleWiseTransformation eleWiseTransformation)
A templated traits class for decomposing object into an array of primitive objects.
ROpScalarReductionWithOpBase(const ConcreteReductObj &initReductObjValue_in=ScalarTraits< Scalar >::zero(), ReductObjReduction reductObjReduction_in=ReductObjReduction())
void operator()(const ConcreteReductObj &in_reduct, ConcreteReductObj &inout_reduct) const
void apply_op_impl(const ArrayView< const ConstSubVectorView< Scalar > > &sub_vecs, const ArrayView< const SubVectorView< Scalar > > &targ_sub_vecs, const Ptr< ReductTarget > &reduct_obj_inout) const
void operator()(const ConcreteReductObj &in_reduct, ConcreteReductObj &inout_reduct) const
TOp_2_1_Base(EleWiseTransformation eleWiseTransformation=EleWiseTransformation())
PrimitiveTypeTraits< Scalar, Scalar >::primitiveType primitive_value_type
Base class for scalar reduction RTOps with two input vectors.
bool coord_invariant_impl() const
This RTOp is NOT coordinate invariant! .
Abstract base class for all reduction objects.
ROpScalarReductionWithOpBase< Scalar, ReductScalar, ReductObjReduction > base_t
void setRawVal(const ConcreteReductObj &rawVal, const Ptr< ReductTarget > &reduct_obj) const
ConcreteReductObj operator()(const ReductTarget &reduct_obj) const
EleWiseTransformation eleWiseTransformation_
bool coord_invariant_impl() const
This RTOp is NOT coordinate invariant! .
static void loadPrimitiveObjs(const ArrayView< const primitiveType > &primitiveObjs, const ArrayView< const index_type > &indexObjs, const ArrayView< const char > &charObjs, const Ptr< ScalarIndex< Scalar > > &obj)
void apply_op_impl(const ArrayView< const ConstSubVectorView< Scalar > > &sub_vecs, const ArrayView< const SubVectorView< Scalar > > &targ_sub_vecs, const Ptr< ReductTarget > &reduct_obj_inout) const
TOp_3_1_Base(EleWiseTransformation eleWiseTransformation=EleWiseTransformation())
void extract_reduct_obj_state_impl(const ReductTarget &reduct_obj, const ArrayView< primitive_value_type > &value_data, const ArrayView< index_type > &index_data, const ArrayView< char_type > &char_data) const
static void extractPrimitiveObjs(const ScalarIndex< Scalar > &obj, const ArrayView< primitiveType > &primitiveObjs, const ArrayView< index_type > &indexObjs, const ArrayView< char > &charObjs)
ROpScalarReductionWithOpBase< Scalar, ReductScalar, ReductObjReduction > base_t
RTOpT< Scalar >::primitive_value_type primitive_value_type
void validate_apply_op(const RTOpT< Scalar > &op, const int allowed_num_sub_vecs, const int allowed_num_targ_sub_vecs, const bool expect_reduct_obj, const ArrayView< const ConstSubVectorView< Scalar > > &sub_vecs, const ArrayView< const SubVectorView< Scalar > > &targ_sub_vecs, const Ptr< const ReductTarget > &reduct_obj)
Validate the input to an apply_op(...) function.
void apply_op_impl(const ArrayView< const ConstSubVectorView< Scalar > > &sub_vecs, const ArrayView< const SubVectorView< Scalar > > &targ_sub_vecs, const Ptr< ReductTarget > &reduct_obj_inout) const
Base class for transformations for 3 input and 1 output vector.
EleWiseTransformation eleWiseTransformation_
void load_reduct_obj_state_impl(const ArrayView< const primitive_value_type > &value_data, const ArrayView< const index_type > &index_data, const ArrayView< const char_type > &char_data, const Ptr< ReductTarget > &reduct_obj) const
ScalarIndex(const Scalar &_scalar, const Ordinal &_index)
void operator()(const ConcreteReductObj &in_reduct, ConcreteReductObj &inout_reduct) const
const ConcreteReductObj & getRawVal(const ReductTarget &reduct_obj) const
Teuchos_Ordinal Ordinal
ROp_1_CoordVariantScalarReduction(const ReductScalar &initReductObjValue_in=ReductScalar(), EleWiseReduction eleWiseReduction_in=EleWiseReduction(), ReductObjReduction reductObjReduction_in=ReductObjReduction())
EleWiseTransformation eleWiseTransformation_
void apply_op_impl(const ArrayView< const ConstSubVectorView< Scalar > > &sub_vecs, const ArrayView< const SubVectorView< Scalar > > &targ_sub_vecs, const Ptr< ReductTarget > &reduct_obj_inout) const