DUNE-FEM (unstable)

vectorial.hh
1#ifndef DUNE_FEM_SHAPEFUNCTIONSET_VECTORIAL_HH
2#define DUNE_FEM_SHAPEFUNCTIONSET_VECTORIAL_HH
3
4// C++ includes
5#include <algorithm>
6#include <cstddef>
7
8// dune-fem includes
9#include <dune/fem/common/fmatrixcol.hh>
10#include <dune/fem/common/utility.hh>
11#include <dune/fem/space/basisfunctionset/functor.hh>
12#include <dune/fem/space/common/functionspace.hh>
13
14
15namespace Dune
16{
17
18 namespace Fem
19 {
20
21 // MakeVectorialTraits
22 // -------------------
23
24 template< class Scalar, class Vectorial >
25 struct MakeVectorialTraits;
26
27 template< class K, int dimR >
28 struct MakeVectorialTraits< FieldVector< K, 1 >, FieldVector< K, dimR > >
29 {
30 typedef FieldVector< K, 1 > ScalarType;
31 typedef FieldVector< K, dimR > VectorialType;
32
33 typedef typename FieldTraits< VectorialType >::field_type field_type;
34 typedef typename VectorialType::size_type ComponentType;
35 typedef typename VectorialType::size_type size_type;
36
37 static const size_type factor = dimR;
38
39 static ComponentType begin () { return ComponentType( 0 ); }
40 static ComponentType end () { return ComponentType( factor ); }
41
42 static VectorialType zeroVectorial () { return VectorialType( K( field_type( 0 ) ) ); }
43
44 static const K &access ( const ScalarType &x ) { return x[ 0 ]; }
45 static K &access ( ScalarType &x ) { return x[ 0 ]; }
46
47 static const K &access ( const VectorialType &x, const ComponentType &i ) { return x[ i ]; }
48 static K &access ( VectorialType &x, const ComponentType &i ) { return x[ i ]; }
49
50 static size_type index ( const ComponentType &i ) { return i; }
51 };
52
53 template< class K, int dimR >
54 struct MakeVectorialTraits< ExplicitFieldVector< K, 1 >, ExplicitFieldVector< K, dimR > >
55 {
56 typedef FieldVector< K, 1 > ScalarType;
57 typedef ExplicitFieldVector< K, dimR > VectorialType;
58
59 typedef typename FieldTraits< VectorialType >::field_type field_type;
60 typedef typename VectorialType::size_type ComponentType;
61 typedef typename VectorialType::size_type size_type;
62
63 static const size_type factor = dimR;
64
65 static ComponentType begin () { return ComponentType( 0 ); }
66 static ComponentType end () { return ComponentType( factor ); }
67
68 static VectorialType zeroVectorial () { return VectorialType( K( field_type( 0 ) ) ); }
69
70 static const K &access ( const ScalarType &x ) { return x[ 0 ]; }
71 static K &access ( ScalarType &x ) { return x[ 0 ]; }
72
73 static const K &access ( const VectorialType &x, const ComponentType &i ) { return x[ i ]; }
74 static K &access ( VectorialType &x, const ComponentType &i ) { return x[ i ]; }
75
76 static size_type index ( const ComponentType &i ) { return i; }
77 };
78
79 template< class K, int dimR, int dimD >
80 struct MakeVectorialTraits< FieldMatrix< K, 1, dimD >, FieldMatrix< K, dimR, dimD > >
81 {
82 typedef FieldMatrix< K, 1, dimD > ScalarType;
83 typedef FieldMatrix< K, dimR, dimD > VectorialType;
84
85 typedef typename FieldTraits< VectorialType >::field_type field_type;
86 typedef typename VectorialType::size_type ComponentType;
87 typedef typename VectorialType::size_type size_type;
88
89 static const size_type factor = dimR;
90
91 static ComponentType begin () { return ComponentType( 0 ); }
92 static ComponentType end () { return ComponentType( factor ); }
93
94 static VectorialType zeroVectorial () { return VectorialType( K( field_type( 0 ) ) ); }
95
96 static const FieldVector< K, dimD > &access ( const ScalarType &x ) { return x[ 0 ]; }
97 static FieldVector< K, dimD > &access ( ScalarType &x ) { return x[ 0 ]; }
98
99 static const FieldVector< K, dimD > &access ( const VectorialType &x, const ComponentType &i ) { return x[ i ]; }
100 static FieldVector< K, dimD > &access ( VectorialType &x, const ComponentType &i ) { return x[ i ]; }
101
102 static size_type index ( const ComponentType &i ) { return i; }
103 };
104
105
106 // MakeVectorialExpression
107 // -----------------------
108
109 template< class Scalar, class Vectorial >
110 class BasicMakeVectorialExpression
111 {
112 typedef BasicMakeVectorialExpression< Scalar, Vectorial > ThisType;
113
114 typedef MakeVectorialTraits< Scalar, Vectorial > Traits;
115
116 public:
117 typedef typename Traits::ScalarType ScalarType;
118 typedef typename Traits::VectorialType VectorialType;
119
120 typedef typename Traits::field_type field_type;
121 typedef typename Traits::ComponentType ComponentType;
122 typedef typename Traits::size_type size_type;
123
124 BasicMakeVectorialExpression ( const ComponentType &component, const ScalarType &scalar )
125 : component_( component ),
126 scalar_( scalar )
127 {}
128
129 operator VectorialType () const
130 {
131 VectorialType vectorial = Traits::zeroVectorial();
132 Traits::access( vectorial, component() ) = Traits::access( scalar() );
133 return vectorial;
134 }
135
136 const ThisType &operator*= ( const field_type &s )
137 {
138 scalar() *= s;
139 return *this;
140 }
141
142 const ThisType &operator/= ( const field_type &s )
143 {
144 scalar() /= s;
145 return *this;
146 }
147
148 const ComponentType &component () const { return component_; }
149
150 const ScalarType &scalar () const { return scalar_; }
151 ScalarType &scalar () { return scalar_; }
152
153 protected:
154 ComponentType component_;
155 ScalarType scalar_;
156 };
157
158
159
160 // MakeVectorialExpression
161 // -----------------------
162
163 template< class Scalar, class Vectorial >
164 class MakeVectorialExpression
165 : public BasicMakeVectorialExpression< Scalar, Vectorial >
166 {
167 typedef MakeVectorialExpression< Scalar, Vectorial > ThisType;
168 typedef BasicMakeVectorialExpression< Scalar, Vectorial > BaseType;
169
170 public:
171 typedef typename BaseType::ComponentType ComponentType;
172 typedef typename BaseType::ScalarType ScalarType;
173
174 MakeVectorialExpression ( const ComponentType &component, const ScalarType &scalar )
175 : BaseType( component, scalar )
176 {}
177 };
178
179 template< class K, int dimR >
180 class MakeVectorialExpression< FieldVector< K, 1 >, FieldVector< K, dimR > >
181 : public BasicMakeVectorialExpression< FieldVector< K, 1 >, FieldVector< K, dimR > >
182 {
183 typedef MakeVectorialExpression< FieldVector< K, 1 >, FieldVector< K, dimR > > ThisType;
184 typedef BasicMakeVectorialExpression< FieldVector< K, 1 >, FieldVector< K, dimR > > BaseType;
185
186 public:
187 typedef typename BaseType::ScalarType ScalarType;
188 typedef typename BaseType::VectorialType VectorialType;
189
190 typedef typename BaseType::field_type field_type;
191 typedef typename BaseType::ComponentType ComponentType;
192 typedef typename BaseType::size_type size_type;
193
194 using BaseType::component;
195 using BaseType::scalar;
196
197 MakeVectorialExpression ( const ComponentType &component, const ScalarType &scalar )
198 : BaseType( component, scalar )
199 {}
200
201 field_type operator* ( const ThisType &other ) const
202 {
203 return (component() == other.component() ? scalar() * other.scalar() : field_type( 0 ));
204 }
205
206 field_type operator* ( const VectorialType &other ) const
207 {
208 return (scalar()[ 0 ] * other[ component() ]);
209 }
210
211 field_type one_norm () const { return scalar().one_norm(); }
212 field_type two_norm () const { return scalar().two_norm(); }
213 field_type two_norm2 () const { return scalar().two_norm2(); }
214 field_type infinity_norm () const { return scalar().infinity_norm(); }
215
216 size_type size () const { return dimR; }
217
218 friend field_type operator* ( const VectorialType &a, ThisType &b ) { return b*a; }
219 };
220
221 template< class K, int dimR, int dimD >
222 class MakeVectorialExpression< FieldMatrix< K, 1, dimD >, FieldMatrix< K, dimR, dimD > >
223 : public BasicMakeVectorialExpression< FieldMatrix< K, 1, dimD >, FieldMatrix< K, dimR, dimD > >
224 {
225 typedef MakeVectorialExpression< FieldMatrix< K, 1, dimD >, FieldMatrix< K, dimR, dimD > > ThisType;
226 typedef BasicMakeVectorialExpression< FieldMatrix< K, 1, dimD >, FieldMatrix< K, dimR, dimD > > BaseType;
227
228 public:
229 typedef typename BaseType::ScalarType ScalarType;
230 typedef typename BaseType::VectorialType VectorialType;
231
232 typedef typename BaseType::field_type field_type;
233 typedef typename BaseType::ComponentType ComponentType;
234 typedef typename BaseType::size_type size_type;
235
236 using BaseType::component;
237 using BaseType::scalar;
238
239 MakeVectorialExpression ( const ComponentType &component, const ScalarType &scalar )
240 : BaseType( component, scalar )
241 {}
242
243 template< class X, class Y >
244 void mv ( const X &x, Y &y ) const
245 {
246 for( size_type i = 0; i < rows(); ++i )
247 y[ i ] = field_type( 0 );
248 for( size_type j= 0; j < cols(); ++j )
249 y[ component() ] += scalar()[ component() ][ j ] * x[ j ];
250 }
251
252 template< class X, class Y >
253 void mtv ( const X &x, Y &y ) const
254 {
255 for( size_type i = 0; i < rows(); ++i )
256 y[ i ] = scalar()[ i ][ component() ] * x[ component() ];
257 }
258
259 template< class X, class Y >
260 void umv ( const X &x, Y &y ) const
261 {
262 for( size_type j= 0; j < cols(); ++j )
263 y[ component() ] += scalar()[ component() ][ j ] * x[ j ];
264 }
265
266 template< class X, class Y >
267 void umtv ( const X &x, Y &y ) const
268 {
269 for( size_type i = 0; i < rows(); ++i )
270 y[ i ] += scalar()[ i ][ component() ] * x[ component() ];
271 }
272
273 template< class X, class Y >
274 void mmv ( const X &x, Y &y ) const
275 {
276 for( size_type j= 0; j < cols(); ++j )
277 y[ component() ] -= scalar()[ component() ][ j ] * x[ j ];
278 }
279
280 template< class X, class Y >
281 void mmtv ( const X &x, Y &y ) const
282 {
283 for( size_type i = 0; i < rows(); ++i )
284 y[ i ] -= scalar()[ i ][ component() ] * x[ component() ];
285 }
286
287 field_type frobenius_norm () const { return scalar().frobenius_norm(); }
288 field_type frobenius_norm2 () const { return scalar().frobenius_norm2(); }
289 field_type infinity_norm () const { return scalar().infinity_norm(); }
290
291 field_type determinant () const { return (dimR == 1 ? scalar().determinant() : field_type( 0 )); }
292
293 size_type N () const { return rows(); }
294 size_type M () const { return cols(); }
295
296 size_type rows () const { return dimR; }
297 size_type cols () const { return scalar().cols(); }
298 };
299
300
301
302 // Auxilliary Functions for MakeVectorialExpression
303 // ------------------------------------------------
304
305 template< class Scalar, class Vectorial >
306 inline bool
307 operator== ( const MakeVectorialExpression< Scalar, Vectorial > &a,
308 const MakeVectorialExpression< Scalar, Vectorial > &b )
309 {
310 return ((a.component() == b.component()) && (a.scalar() == b.scalar()));
311 }
312
313 template< class Scalar, class Vectorial >
314 inline bool
315 operator!= ( const MakeVectorialExpression< Scalar, Vectorial > &a,
316 const MakeVectorialExpression< Scalar, Vectorial > &b )
317 {
318 return ((a.component() != b.component()) || (a.scalar() != b.scalar()));
319 }
320
321 template< class Scalar, class Vectorial >
322 inline bool
323 operator== ( const Vectorial &a,
324 const MakeVectorialExpression< Scalar, Vectorial > &b )
325 {
326 return (a == static_cast< Vectorial >( b ));
327 }
328
329 template< class Scalar, class Vectorial >
330 inline bool
331 operator!= ( const Vectorial &a,
332 const MakeVectorialExpression< Scalar, Vectorial > &b )
333 {
334 return (a != static_cast< Vectorial >( b ));
335 }
336
337 template< class Scalar, class Vectorial >
338 inline bool
339 operator== ( const MakeVectorialExpression< Scalar, Vectorial > &a,
340 const Vectorial &b )
341 {
342 return (static_cast< Vectorial >( a ) == b);
343 }
344
345 template< class Scalar, class Vectorial >
346 inline bool
347 operator!= ( const MakeVectorialExpression< Scalar, Vectorial > &a,
348 const Vectorial &b )
349 {
350 return (static_cast< Vectorial >( a ) != b);
351 }
352
353 template< class Scalar, class Vectorial >
354 inline void
355 axpy ( const typename MakeVectorialTraits< Scalar, Vectorial >::field_type &a,
356 const MakeVectorialExpression< Scalar, Vectorial > &x,
357 typename MakeVectorialTraits< Scalar, Vectorial >::VectorialType &y )
358 {
359 typedef MakeVectorialTraits< Scalar, Vectorial > Traits;
360 axpy( a, Traits::access( x.scalar() ), Traits::access( y, x.component() ) );
361 }
362
363 template< class GeometryJacobianInverseTransposed, class K, int ROWS >
364 void jacobianTransformation ( const GeometryJacobianInverseTransposed &gjit,
365 const MakeVectorialExpression< FieldMatrix< K, 1, GeometryJacobianInverseTransposed::cols >, FieldMatrix< K, ROWS, GeometryJacobianInverseTransposed::cols > > &a,
366 FieldMatrix< K, ROWS, GeometryJacobianInverseTransposed::rows > &b )
367 {
368 typedef MakeVectorialTraits< FieldMatrix< K, 1, GeometryJacobianInverseTransposed::cols >, FieldMatrix< K, ROWS, GeometryJacobianInverseTransposed::cols > > Traits;
369 typedef MakeVectorialTraits< FieldMatrix< K, 1, GeometryJacobianInverseTransposed::rows >, FieldMatrix< K, ROWS, GeometryJacobianInverseTransposed::rows > > RgTraits;
370 b = RgTraits::zeroVectorial();
371 gjit.mv( Traits::access( a.scalar() ), b[ a.component() ] );
372 }
373
374 template< class GeometryJacobianInverseTransposed, class K, int SIZE >
375 void hessianTransformation ( const GeometryJacobianInverseTransposed &gjit,
376 const MakeVectorialExpression< ExplicitFieldVector< FieldMatrix< K, GeometryJacobianInverseTransposed::cols, GeometryJacobianInverseTransposed::cols >, 1 >, ExplicitFieldVector< FieldMatrix< K, GeometryJacobianInverseTransposed::cols, GeometryJacobianInverseTransposed::cols >, SIZE > > &a,
377 ExplicitFieldVector< FieldMatrix< K, GeometryJacobianInverseTransposed::rows, GeometryJacobianInverseTransposed::rows >, SIZE > &b )
378 {
379 const int dimLocal = GeometryJacobianInverseTransposed::cols;
380 const int dimGlobal = GeometryJacobianInverseTransposed::rows;
381 typedef MakeVectorialTraits< FieldVector< FieldMatrix< K, dimLocal, dimLocal >, 1 >, FieldVector< FieldMatrix< K, dimLocal, dimLocal >, SIZE > > Traits;
382 typedef MakeVectorialTraits< FieldVector< FieldMatrix< K, dimGlobal, dimGlobal >, 1 >, FieldVector< FieldMatrix< K, dimGlobal, dimGlobal >, SIZE > > RgTraits;
383
384 b = RgTraits::zeroVectorial();
385
386 // c = J^{-T} a_r^T
387 FieldMatrix< K, dimLocal, dimGlobal > c;
388 for( int i = 0; i < dimLocal; ++i )
389 gjit.mv( Traits::access( a.scalar() )[ i ], c[ i ] );
390
391 // b_r = J^{-T} c
392 for( int i = 0; i < dimGlobal; ++i )
393 {
394 FieldMatrixColumn< const FieldMatrix< K, dimLocal, dimGlobal > > ci( c, i );
395 FieldMatrixColumn< FieldMatrix< K, dimGlobal, dimGlobal > > bi( RgTraits::access( b, a.component() ), i );
396 gjit.umv( ci, bi );
397 }
398
399 }
400
401 template< class Scalar, class Vectorial >
402 inline typename MakeVectorialTraits< Scalar, Vectorial >::field_type
403 scalarProduct ( const MakeVectorialExpression< Scalar, Vectorial > &a,
404 const Vectorial &b )
405 {
406 return scalarProduct( a.scalar()[ 0 ], b[ a.component() ] );
407 }
408
409 template< class Scalar, class Vectorial >
410 inline typename MakeVectorialTraits< Scalar, Vectorial >::field_type
411 scalarProduct ( const Vectorial &a,
412 const MakeVectorialExpression< Scalar, Vectorial > &b )
413 {
414 return scalarProduct( a[ b.component() ], b.scalar()[ 0 ] );
415 }
416
417 template< class Scalar, class Vectorial >
418 inline typename MakeVectorialTraits< Scalar, Vectorial >::field_type
419 scalarProduct ( const MakeVectorialExpression< Scalar, Vectorial > &a,
420 const MakeVectorialExpression< Scalar, Vectorial > &b )
421 {
422 typedef typename MakeVectorialTraits< Scalar, Vectorial >::field_type field_type;
423 return (a.component() == b.component() ? scalarProduct( a.scalar(), b.scalar() ) : field_type( 0 ));
424 }
425
426
427
428 // ToNewRange
429 // ----------
430
431 template< class ScalarFunctionSpace, class RangeVector >
432 struct ToNewRange;
433
434 template< class DomainField, class RangeField, int dimD, int dimR >
435 struct ToNewRange< FunctionSpace< DomainField, RangeField, dimD, 1 >, FieldVector< RangeField, dimR > >
436 {
437 typedef FunctionSpace< DomainField, RangeField, dimD, dimR > Type;
438 };
439
440
441
442 // VectorialShapeFunctionSet
443 // -------------------------
444
445 template< class ScalarShapeFunctionSet, class RangeVector >
446 class VectorialShapeFunctionSet
447 {
448 typedef VectorialShapeFunctionSet< ScalarShapeFunctionSet, RangeVector > ThisType;
449
450 public:
451 typedef ScalarShapeFunctionSet ScalarShapeFunctionSetType;
452
453 // if ScalarShapeFunctionSetType has a member variable codegenShapeFunctionSet then this is forwarded here
454 // otherwise this value defaults to false
455 static constexpr bool codegenShapeFunctionSet = detail::IsCodegenShapeFunctionSet< ScalarShapeFunctionSetType >::value;
456 static const int pointSetId = detail::SelectPointSetId< ScalarShapeFunctionSetType >::value;
457
458 protected:
459 typedef typename ScalarShapeFunctionSetType::FunctionSpaceType ScalarFunctionSpaceType;
460
461 static const std::size_t dimRangeFactor = MakeVectorialTraits< typename ScalarFunctionSpaceType::RangeType, RangeVector >::factor;
462
463 template< class Functor, class Vectorial >
464 struct VectorialFunctor;
465
466 public:
467 typedef typename ToNewRange< ScalarFunctionSpaceType, RangeVector >::Type FunctionSpaceType;
468
469 typedef typename FunctionSpaceType::RangeType RangeType;
470 typedef typename FunctionSpaceType::JacobianRangeType JacobianRangeType;
471 typedef typename FunctionSpaceType::HessianRangeType HessianRangeType;
472
473 template< class ... Args >
474 VectorialShapeFunctionSet ( Args&& ... args )
475 : scalarShapeFunctionSet_( std::forward< Args > ( args ) ... )
476 {}
477
478 explicit VectorialShapeFunctionSet ( const ScalarShapeFunctionSetType &scalarShapeFunctionSet )
479 : scalarShapeFunctionSet_( scalarShapeFunctionSet )
480 {}
481
482 const ScalarShapeFunctionSetType &scalarShapeFunctionSet () const { return scalarShapeFunctionSet_; }
483
484 int order () const { return scalarShapeFunctionSet().order(); }
485
486 // Shape Function Set Interface Methods
487 std::size_t size () const { return dimRangeFactor * scalarShapeFunctionSet().size(); }
488
489 template< class Point, class Functor >
490 void evaluateEach ( const Point &x, Functor functor ) const;
491
492 template< class Point, class Functor >
493 void jacobianEach ( const Point &x, Functor functor ) const;
494
495 template< class Point, class Functor >
496 void hessianEach ( const Point &x, Functor functor ) const;
497
498 protected:
499 ScalarShapeFunctionSet scalarShapeFunctionSet_;
500 };
501
502
503
504 // VectorialShapeFunctionSet::VectorialFunctor
505 // -------------------------------------------
506
507 template< class ScalarShapeFunctionSet, class RangeVector >
508 template< class Functor, class Vectorial >
509 struct VectorialShapeFunctionSet< ScalarShapeFunctionSet, RangeVector >::VectorialFunctor
510 {
511 explicit VectorialFunctor ( const Functor &functor )
512 : functor_( functor )
513 {}
514
515 template< class Scalar >
516 void operator() ( const std::size_t i, const Scalar &value )
517 {
518 typedef MakeVectorialTraits< Scalar, Vectorial > Traits;
519 typedef MakeVectorialExpression< Scalar, Vectorial > Expression;
520 const typename Traits::ComponentType end = Traits::end();
521 for( typename Traits::ComponentType k = Traits::begin(); k != end; ++k )
522 functor_( i*Traits::factor + Traits::index( k ), Expression( k, value ) );
523 }
524
525 private:
526 Functor functor_;
527 };
528
529
530
531 // Implementation of VectorialShapeFunctionSet
532 // -------------------------------------------
533
534 template< class ScalarShapeFunctionSet, class RangeVector >
535 template< class Point, class Functor >
536 inline void VectorialShapeFunctionSet< ScalarShapeFunctionSet, RangeVector >
537 ::evaluateEach ( const Point &x, Functor functor ) const
538 {
539 typedef typename FunctionSpaceType::RangeType VectorialType;
540 scalarShapeFunctionSet().evaluateEach( x, VectorialFunctor< Functor, VectorialType >( functor ) );
541 }
542
543
544 template< class ScalarShapeFunctionSet, class RangeVector >
545 template< class Point, class Functor >
546 inline void VectorialShapeFunctionSet< ScalarShapeFunctionSet, RangeVector >
547 ::jacobianEach ( const Point &x, Functor functor ) const
548 {
549 typedef typename FunctionSpaceType::JacobianRangeType VectorialType;
550 scalarShapeFunctionSet().jacobianEach( x, VectorialFunctor< Functor, VectorialType >( functor ) );
551 }
552
553
554 template< class ScalarShapeFunctionSet, class RangeVector >
555 template< class Point, class Functor >
556 inline void VectorialShapeFunctionSet< ScalarShapeFunctionSet, RangeVector >
557 ::hessianEach ( const Point &x, Functor functor ) const
558 {
559 typedef typename FunctionSpaceType::HessianRangeType VectorialType;
560 scalarShapeFunctionSet().hessianEach( x, VectorialFunctor< Functor, VectorialType >( functor ) );
561 }
562
563 } // namespace Fem
564
565} // namespace Dune
566
567#endif // #ifndef DUNE_FEM_SHAPEFUNCTIONSET_VECTORIAL_HH
Dune::Fem::ExplicitFieldVector
Definition: explicitfieldvector.hh:75
Dune::Fem::FunctionSpaceInterface< VectorSpaceTraits< DomainField, RangeField, dimD, dimR > >::RangeType
FunctionSpaceTraits::RangeType RangeType
Type of range vector (using type of range field) has a Dune::FieldVector type interface.
Definition: functionspaceinterface.hh:71
Dune::Fem::FunctionSpaceInterface< VectorSpaceTraits< DomainField, RangeField, dimD, dimR > >::JacobianRangeType
FunctionSpaceTraits::LinearMappingType JacobianRangeType
Intrinsic type used for the jacobian values has a Dune::FieldMatrix type interface.
Definition: functionspaceinterface.hh:75
Dune::Fem::FunctionSpace
A vector valued function space.
Definition: functionspace.hh:60
Dune::operator==
EnableIfInterOperable< T1, T2, bool >::type operator==(const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
Checks for equality.
Definition: iteratorfacades.hh:238
Dune::operator!=
EnableIfInterOperable< T1, T2, bool >::type operator!=(const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
Checks for inequality.
Definition: iteratorfacades.hh:260
Dune::Simd::Scalar
typename Overloads::ScalarType< std::decay_t< V > >::type Scalar
Element type of some SIMD type.
Definition: interface.hh:235
Dune
Dune namespace.
Definition: alignedallocator.hh:13
Dune::size
constexpr std::integral_constant< std::size_t, sizeof...(II)> size(std::integer_sequence< T, II... >)
Return the size of the sequence.
Definition: integersequence.hh:75
std
STL namespace.
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden  |  generated with Hugo v0.111.3 (Jul 27, 22:29, 2024)