│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
175 template<
typename M,
typename G,
typename L>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
183 typedef typename std::set<IndexTripel>::const_iterator localindex_iterator;
│ │ │ │ -
184 typedef typename std::set<RemoteIndexTripel>::const_iterator remoteindex_iterator;
│ │ │ │ -
│ │ │ │ -
186 typedef Dune::ParallelLocalIndex<AttributeSet> LI;
│ │ │ │ -
│ │ │ │ -
188 typedef Dune::ParallelIndexSet<GlobalIdType,LI,512>
PIS;
│ │ │ │ -
189 typedef Dune::RemoteIndices<PIS>
RI;
│ │ │ │ -
190 typedef Dune::RemoteIndexListModifier<PIS,typename RI::Allocator,false>
RILM;
│ │ │ │ -
191 typedef typename RI::RemoteIndex
RX;
│ │ │ │ -
192 typedef Dune::BufferedCommunicator
BC;
│ │ │ │ -
193 typedef Dune::Interface
IF;
│ │ │ │ -
194 typedef EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::owner>
OwnerSet;
│ │ │ │ -
195 typedef EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::copy>
CopySet;
│ │ │ │ -
196 typedef Combine<EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::owner>,EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::overlap>,
AttributeSet>
OwnerOverlapSet;
│ │ │ │ -
197 typedef Dune::AllSet<AttributeSet>
AllSet;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
205 typedef typename CommPolicy<T>::IndexedType
V;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
220 typedef typename CommPolicy<T>::IndexedType
V;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
173 if (m.buildMode() != Matrix::implicit)
│ │ │ │ +
174 DUNE_THROW(
BCRSMatrixError,
"You can only create an ImplicitBuilder for a matrix in implicit build mode");
│ │ │ │ +
175 if (m.buildStage() != Matrix::building)
│ │ │ │ +
176 DUNE_THROW(
BCRSMatrixError,
"You can only create an ImplicitBuilder for a matrix with set size that has not been compressed() yet");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
197 if (m.buildStage() != Matrix::notAllocated)
│ │ │ │ +
198 DUNE_THROW(
BCRSMatrixError,
"You can only set up a matrix for this ImplicitBuilder if it has no memory allocated yet");
│ │ │ │ +
199 m.setBuildMode(Matrix::implicit);
│ │ │ │ +
200 m.setImplicitBuildModeParameters(avg_cols_per_row,overflow_fraction);
│ │ │ │ +
201 m.setSize(rows,cols);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
235 if (OwnerOverlapToAllInterfaceBuilt)
│ │ │ │ -
236 OwnerOverlapToAllInterface.free();
│ │ │ │ -
│ │ │ │ -
238 Combine<OwnerOverlapSet,EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::copy>,
AttributeSet>
│ │ │ │ -
│ │ │ │ -
240 OwnerOverlapToAllInterface.build(ri,sourceFlags,destFlags);
│ │ │ │ -
241 OwnerOverlapToAllInterfaceBuilt =
true;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
246 if (OwnerToAllInterfaceBuilt)
│ │ │ │ -
247 OwnerToAllInterface.free();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
250 OwnerToAllInterface.build(ri,sourceFlags,destFlags);
│ │ │ │ -
251 OwnerToAllInterfaceBuilt =
true;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
256 if (OwnerCopyToAllInterfaceBuilt)
│ │ │ │ -
257 OwnerCopyToAllInterface.free();
│ │ │ │ -
│ │ │ │ -
259 typedef Combine<EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::owner>,EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::copy>,
AttributeSet> OwnerCopySet;
│ │ │ │ -
260 OwnerCopySet sourceFlags;
│ │ │ │ -
261 Combine<OwnerCopySet,EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::overlap>,
AttributeSet> destFlags;
│ │ │ │ -
262 OwnerCopyToAllInterface.build(ri,sourceFlags,destFlags);
│ │ │ │ -
263 OwnerCopyToAllInterfaceBuilt =
true;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
268 if (OwnerCopyToOwnerCopyInterfaceBuilt)
│ │ │ │ -
269 OwnerCopyToOwnerCopyInterface.free();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
272 typedef Combine<EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::owner>,EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::copy>,
AttributeSet> OwnerCopySet;
│ │ │ │ -
273 OwnerCopySet sourceFlags;
│ │ │ │ -
274 OwnerCopySet destFlags;
│ │ │ │ -
275 OwnerCopyToOwnerCopyInterface.build(ri,sourceFlags,destFlags);
│ │ │ │ -
276 OwnerCopyToOwnerCopyInterfaceBuilt =
true;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
281 if (CopyToAllInterfaceBuilt)
│ │ │ │ -
282 CopyToAllInterface.free();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
285 CopyToAllInterface.build(ri,sourceFlags,destFlags);
│ │ │ │ -
286 CopyToAllInterfaceBuilt =
true;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
313 if (!OwnerToAllInterfaceBuilt)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
317 communicator.template forward<CopyGatherScatter<T> >(source,dest);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
330 if (!CopyToAllInterfaceBuilt)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
334 communicator.template forward<CopyGatherScatter<T> >(source,dest);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
347 if (!OwnerOverlapToAllInterfaceBuilt)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
350 communicator.template build<T>(OwnerOverlapToAllInterface);
│ │ │ │ -
351 communicator.template forward<AddGatherScatter<T> >(source,dest);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
364 if (!OwnerCopyToAllInterfaceBuilt)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
367 communicator.template build<T>(OwnerCopyToAllInterface);
│ │ │ │ -
368 communicator.template forward<AddGatherScatter<T> >(source,dest);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
381 if (!OwnerCopyToOwnerCopyInterfaceBuilt)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
384 communicator.template build<T>(OwnerCopyToOwnerCopyInterface);
│ │ │ │ -
385 communicator.template forward<AddGatherScatter<T> >(source,dest);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
397 template<
class T1,
class T2>
│ │ │ │ -
│ │ │ │ -
398 void dot (
const T1& x,
const T1& y, T2& result)
const
│ │ │ │ -
│ │ │ │ -
400 using real_type =
typename FieldTraits<typename T1::field_type>::real_type;
│ │ │ │ -
│ │ │ │ -
402 if (mask.size()!=
static_cast<typename std::vector<double>::size_type
>(x.size()))
│ │ │ │ -
│ │ │ │ -
404 mask.resize(x.size());
│ │ │ │ -
405 for (
typename std::vector<double>::size_type i=0; i<mask.size(); i++)
│ │ │ │ -
│ │ │ │ -
407 for (
typename PIS::const_iterator i=pis.begin(); i!=pis.end(); ++i)
│ │ │ │ -
│ │ │ │ -
409 mask[i->local().local()] = 0;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
413 for (
typename T1::size_type i=0; i<x.size(); i++)
│ │ │ │ -
414 result += (x[i]*(y[i]))*
static_cast<real_type
>(mask[i]);
│ │ │ │ -
415 result = cc.sum(result);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
425 typename FieldTraits<typename T1::field_type>::real_type
norm (
const T1& x)
const
│ │ │ │ -
│ │ │ │ -
427 using real_type =
typename FieldTraits<typename T1::field_type>::real_type;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
430 if (mask.size()!=
static_cast<typename std::vector<double>::size_type
>(x.size()))
│ │ │ │ -
│ │ │ │ -
432 mask.resize(x.size());
│ │ │ │ -
433 for (
typename std::vector<double>::size_type i=0; i<mask.size(); i++)
│ │ │ │ -
│ │ │ │ -
435 for (
typename PIS::const_iterator i=pis.begin(); i!=pis.end(); ++i)
│ │ │ │ -
│ │ │ │ -
437 mask[i->local().local()] = 0;
│ │ │ │ -
│ │ │ │ -
439 auto result = real_type(0.0);
│ │ │ │ -
440 for (
typename T1::size_type i=0; i<x.size(); i++)
│ │ │ │ -
441 result += Impl::asVector(x[i]).two_norm2()*mask[i];
│ │ │ │ -
│ │ │ │ -
443 return sqrt(cc.sum(result));
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
446 typedef Dune::EnumItem<AttributeSet,OwnerOverlapCopyAttributeSet::copy>
CopyFlags;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
464 template<
class B,
class A=std::allocator<B> >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
498 if(pis.seqNo()==oldseqNo)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
501 delete globalLookup_;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
505 oldseqNo = pis.seqNo();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
511 if(pis.seqNo()==oldseqNo)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
514 delete globalLookup_;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
517 oldseqNo = pis.seqNo();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
522 delete globalLookup_;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
528 assert(globalLookup_ != 0);
│ │ │ │ -
529 return *globalLookup_;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
540 for (
typename PIS::const_iterator i=pis.begin(); i!=pis.end(); ++i)
│ │ │ │ -
│ │ │ │ -
542 x[i->local().local()] = 0;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
556 bool freecomm_ =
false)
│ │ │ │ -
557 : comm(comm_), cc(comm_), pis(), ri(pis,pis,comm_),
│ │ │ │ -
558 OwnerToAllInterfaceBuilt(false), OwnerOverlapToAllInterfaceBuilt(false),
│ │ │ │ -
559 OwnerCopyToAllInterfaceBuilt(false), OwnerCopyToOwnerCopyInterfaceBuilt(false),
│ │ │ │ -
560 CopyToAllInterfaceBuilt(false), globalLookup_(0), category_(cat_),
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
573 : comm(MPI_COMM_WORLD), cc(MPI_COMM_WORLD), pis(), ri(pis,pis,MPI_COMM_WORLD),
│ │ │ │ -
574 OwnerToAllInterfaceBuilt(false), OwnerOverlapToAllInterfaceBuilt(false),
│ │ │ │ -
575 OwnerCopyToAllInterfaceBuilt(false), OwnerCopyToOwnerCopyInterfaceBuilt(false),
│ │ │ │ -
576 CopyToAllInterfaceBuilt(false), globalLookup_(0), category_(cat_), freecomm(false)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
589 bool freecomm_ =
false)
│ │ │ │ -
590 : comm(comm_), cc(comm_), OwnerToAllInterfaceBuilt(false),
│ │ │ │ -
591 OwnerOverlapToAllInterfaceBuilt(false), OwnerCopyToAllInterfaceBuilt(false),
│ │ │ │ -
592 OwnerCopyToOwnerCopyInterfaceBuilt(false), CopyToAllInterfaceBuilt(false),
│ │ │ │ -
593 globalLookup_(0), category_(cat_), freecomm(freecomm_)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
611 ri.setIndexSets(pis,pis,cc);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
615 int p = std::get<0>(*i);
│ │ │ │ -
616 RILM modifier = ri.template getModifier<false,true>(p);
│ │ │ │ -
617 typename PIS::const_iterator pi=pis.begin();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
621 if (p!=std::get<0>(*i))
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
624 modifier = ri.template getModifier<false,true>(p);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
629 while (pi->global()!=std::get<1>(*i) && pi!=pis.end())
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
632 DUNE_THROW(
ISTLError,
"OwnerOverlapCopyCommunication: global index not in index set");
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
645 ri.template getModifier<false,true>(0);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
653 if (OwnerToAllInterfaceBuilt) OwnerToAllInterface.free();
│ │ │ │ -
654 if (OwnerOverlapToAllInterfaceBuilt) OwnerOverlapToAllInterface.free();
│ │ │ │ -
655 if (OwnerCopyToAllInterfaceBuilt) OwnerCopyToAllInterface.free();
│ │ │ │ -
656 if (OwnerCopyToOwnerCopyInterfaceBuilt) OwnerCopyToOwnerCopyInterface.free();
│ │ │ │ -
657 if (CopyToAllInterfaceBuilt) CopyToAllInterface.free();
│ │ │ │ -
658 if (globalLookup_)
delete globalLookup_;
│ │ │ │ -
659 if (freecomm && (comm != MPI_COMM_NULL))
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
664 int wasFinalized = 0;
│ │ │ │ -
665 MPI_Finalized(&wasFinalized);
│ │ │ │ -
│ │ │ │ -
667 MPI_Comm_free(&comm);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
676 Communication<MPI_Comm> cc;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
679 mutable IF OwnerToAllInterface;
│ │ │ │ -
680 mutable bool OwnerToAllInterfaceBuilt;
│ │ │ │ -
681 mutable IF OwnerOverlapToAllInterface;
│ │ │ │ -
682 mutable bool OwnerOverlapToAllInterfaceBuilt;
│ │ │ │ -
683 mutable IF OwnerCopyToAllInterface;
│ │ │ │ -
684 mutable bool OwnerCopyToAllInterfaceBuilt;
│ │ │ │ -
685 mutable IF OwnerCopyToOwnerCopyInterface;
│ │ │ │ -
686 mutable bool OwnerCopyToOwnerCopyInterfaceBuilt;
│ │ │ │ -
687 mutable IF CopyToAllInterface;
│ │ │ │ -
688 mutable bool CopyToAllInterfaceBuilt;
│ │ │ │ -
689 mutable std::vector<double> mask;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
500 typedef Imp::CompressedBlockVectorWindow<B,size_type>
row_type;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
547#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
549 DUNE_THROW(
BCRSMatrixError,
"You cannot use operator[] in implicit build mode before calling compress()");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
559#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
561 DUNE_THROW(
BCRSMatrixError,
"You cannot use operator[] in implicit build mode before calling compress()");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
574 :
public RandomAccessIteratorFacade<RealRowIterator<T>, T>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
646 void advance(std::ptrdiff_t diff)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
651 T& elementAt(std::ptrdiff_t diff)
const
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
void testRedistributed(int s)
│ │ │ │ -
│ │ │ │ -
Provides classes for reading and writing MatrixMarket Files with an extension for parallel matrices.
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
787 DUNE_THROW(
BCRSMatrixError,
"Only call this constructor when using the implicit build mode");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
793 DUNE_THROW(
BCRSMatrixError,
"You cannot set a negative overflow fraction");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
808 DUNE_THROW(InvalidStateException,
"BCRSMatrix can only be copy-constructed when source matrix is completely empty (size not set) or fully built)");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
840 DUNE_THROW(InvalidStateException,
"Matrix structure cannot be changed at this stage anymore (ready == "<<
ready<<
").");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
866 DUNE_THROW(
Dune::BCRSMatrixError,
"number of non-zeroes may not be set in implicit mode, use setImplicitBuildModeParameters() instead");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
874 allocate(rows, columns, nnz,
true,
false);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
892 if (compressionBufferSize < 0.0)
│ │ │ │ +
893 DUNE_THROW(
BCRSMatrixError,
"You cannot set a negative compressionBufferSize value");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
897 DUNE_THROW(InvalidStateException,
"You cannot modify build mode parameters at this stage anymore");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
911 if (&Mat==
this)
return *
this;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
914 DUNE_THROW(InvalidStateException,
"BCRSMatrix can only be copied when both target and source are empty or fully built)");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
921 if (
n>0 &&
n!=Mat.
n) {
│ │ │ │ +
│ │ │ │ +
923 for(
row_type *riter=
r+(
n-1), *rend=
r-1; riter!=rend; --riter)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
944 DUNE_THROW(InvalidStateException,
"Scalar assignment only works on fully built BCRSMatrix)");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
958 : Mat(_Mat), i(_i), nnz(0), current_row(nullptr, Mat.
j_.
get(), 0)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
965 DUNE_THROW(
BCRSMatrixError,
"creation only allowed for uninitialized matrix");
│ │ │ │ +
│ │ │ │ +
967 DUNE_THROW(
BCRSMatrixError,
"creation only allowed if row wise allocation was requested in the constructor");
│ │ │ │ +
968 if(i==0 && _Mat.
N()==0)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1001 Mat.
r[i].set(s,
nullptr,current_row.getindexptr());
│ │ │ │ +
1002 current_row.setindexptr(current_row.getindexptr()+s);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1011 Mat.
r[i].set(s,b,j);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1015 Mat.
r[i].set(0,
nullptr,
nullptr);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1018 std::copy(pattern.cbegin(), pattern.cend(), Mat.
r[i].getindexptr());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1045 return (i!=it.i) || (&Mat!=&it.Mat);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1051 return (i==it.i) && (&Mat==&it.Mat);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1069 return pattern.find(j) != pattern.end();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1078 return pattern.size();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1085 typedef std::set<size_type,std::less<size_type> > PatternType;
│ │ │ │ +
1086 PatternType pattern;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1127#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1131 return r[i].getsize();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1142 r[i].setsize(
r[i].getsize()+s);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1157 total +=
r[i].getsize();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1163 else if(
nnz_ < total)
│ │ │ │ +
│ │ │ │ +
1165 <<
"sufficient for calculated nonzeros ("<<total<<
"! ");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1197 DUNE_THROW(
BCRSMatrixError,
"matrix size not set and no memory allocated yet");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1203 size_type*
const first =
r[row].getindexptr();
│ │ │ │ +
1204 size_type*
const last = first +
r[row].getsize();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1210 if (pos!=last && *pos ==
col)
return;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1218 std::copy_backward(pos,
end,
end+1);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1231 template<
typename It>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1238 if ((col_end = std::copy(
begin,
end,
r[row].getindexptr())) != col_begin + row_size)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1241 <<
") does not match number of passed entries (" << (col_end - col_begin) <<
")");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1254 template<
typename It>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1261 if ((col_end = std::copy(
begin,
end,
r[row].getindexptr())) != col_begin + row_size)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1264 <<
") does not match number of passed entries (" << (col_end - col_begin) <<
")");
│ │ │ │ +
1265 std::sort(col_begin,col_end);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1278 DUNE_THROW(
BCRSMatrixError,
"matrix size not set and no memory allocated yet");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1286 if (j.index() >=
m) {
│ │ │ │ +
1287 dwarn <<
"WARNING: size of row "<< i.index()<<
" is "<<j.offset()<<
". But was specified as being "<< (*i).end().offset()
│ │ │ │ +
1288 <<
". This means you are wasting valuable space and creating additional cache misses!"<<std::endl;
│ │ │ │ +
1289 nnz_ -= ((*i).end().offset() - j.offset());
│ │ │ │ +
1290 r[i.index()].setsize(j.offset());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1319#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1323 DUNE_THROW(
BCRSMatrixError,
"matrix already built up, use operator[] for entry access now");
│ │ │ │ +
│ │ │ │ +
1325 DUNE_THROW(
BCRSMatrixError,
"matrix size not set and no memory allocated yet");
│ │ │ │ +
│ │ │ │ +
1327 DUNE_THROW(InvalidStateException,
"You may only use entry() during the 'building' stage");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1344 std::ptrdiff_t offset = pos -
r[row].getindexptr();
│ │ │ │ +
1345 B* aptr =
r[row].getptr() + offset;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1351 if (
r[row].getsize() ==
avg)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1359 std::ptrdiff_t offset =
end -
r[row].getindexptr();
│ │ │ │ +
1360 B* apos =
r[row].getptr() + offset;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1363 r[row].setsize(
r[row].getsize()+1);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1386 DUNE_THROW(
BCRSMatrixError,
"matrix already built up, no more need for compression");
│ │ │ │ +
│ │ │ │ +
1388 DUNE_THROW(
BCRSMatrixError,
"matrix size not set and no memory allocated yet");
│ │ │ │ +
│ │ │ │ +
1390 DUNE_THROW(InvalidStateException,
"You may only call compress() at the end of the 'building' stage");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1402 typename OverflowType::iterator oit =
overflow.begin();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1405 std::vector<size_type*> perm;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1417 typename std::vector<size_type*>::iterator it = perm.begin();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1425 r[i].setindexptr(jiit);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1428 for (it = perm.begin(); it != perm.end(); ++it)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1431 while ((oit!=
overflow.end()) && (oit->first < std::make_pair(i,**it)))
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1436 "Allocated memory for BCRSMatrix exhausted during compress()!"
│ │ │ │ +
1437 "Please increase either the average number of entries per row or the compressionBufferSize value."
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1440 *jiit = oit->first.second;
│ │ │ │ +
│ │ │ │ +
1442 *aiit = oit->second;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1445 r[i].setsize(
r[i].getsize()+1);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1451 "Allocated memory for BCRSMatrix exhausted during compress()!"
│ │ │ │ +
1452 "Please increase either the average number of entries per row or the compressionBufferSize value."
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1458 B* apos = *it -
j_.get() +
a;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1464 while ((oit!=
overflow.end()) && (oit->first.first == i))
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1469 "Allocated memory for BCRSMatrix exhausted during compress()!"
│ │ │ │ +
1470 "Please increase either the average number of entries per row or the compressionBufferSize value."
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1474 *jiit = oit->first.second;
│ │ │ │ +
│ │ │ │ +
1476 *aiit = oit->second;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1479 r[i].setsize(
r[i].getsize()+1);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1498 std::ptrdiff_t diff = (
r[
n-1].getindexptr() +
r[
n-1].getsize() -
j_.get());
│ │ │ │ +
│ │ │ │ +
1500 stats.
avg = (double) (
nnz_) / (double)
n;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1515#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
1517 DUNE_THROW(
BCRSMatrixError,
"You can only call arithmetic operations on fully built BCRSMatrix instances");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1543#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
1545 DUNE_THROW(
BCRSMatrixError,
"You can only call arithmetic operations on fully built BCRSMatrix instances");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1576#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
1578 DUNE_THROW(
BCRSMatrixError,
"You can only call arithmetic operations on fully built BCRSMatrix instances");
│ │ │ │ +
1579 if(
N()!=b.
N() ||
M() != b.
M())
│ │ │ │ +
1580 DUNE_THROW(RangeError,
"Matrix sizes do not match!");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1598#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
1600 DUNE_THROW(
BCRSMatrixError,
"You can only call arithmetic operations on fully built BCRSMatrix instances");
│ │ │ │ +
1601 if(
N()!=b.
N() ||
M() != b.
M())
│ │ │ │ +
1602 DUNE_THROW(RangeError,
"Matrix sizes do not match!");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1623#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
1625 DUNE_THROW(
BCRSMatrixError,
"You can only call arithmetic operations on fully built BCRSMatrix instances");
│ │ │ │ +
1626 if(
N()!=b.
N() ||
M() != b.
M())
│ │ │ │ +
1627 DUNE_THROW(RangeError,
"Matrix sizes do not match!");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1640 template<
class X,
class Y>
│ │ │ │ +
│ │ │ │ +
1641 void mv (
const X& x, Y& y)
const
│ │ │ │ +
│ │ │ │ +
1643#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
1645 DUNE_THROW(
BCRSMatrixError,
"You can only call arithmetic operations on fully built BCRSMatrix instances");
│ │ │ │ +
│ │ │ │ +
1647 "Size mismatch: M: " <<
N() <<
"x" <<
M() <<
" x: " << x.N());
│ │ │ │ +
│ │ │ │ +
1649 "Size mismatch: M: " <<
N() <<
"x" <<
M() <<
" y: " << y.N());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1658 auto&& xj = Impl::asVector(x[j.index()]);
│ │ │ │ +
1659 auto&& yi = Impl::asVector(y[i.index()]);
│ │ │ │ +
1660 Impl::asMatrix(*j).umv(xj, yi);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1666 template<
class X,
class Y>
│ │ │ │ +
│ │ │ │ +
1667 void umv (
const X& x, Y& y)
const
│ │ │ │ +
│ │ │ │ +
1669#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
1671 DUNE_THROW(
BCRSMatrixError,
"You can only call arithmetic operations on fully built BCRSMatrix instances");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1681 auto&& xj = Impl::asVector(x[j.index()]);
│ │ │ │ +
1682 auto&& yi = Impl::asVector(y[i.index()]);
│ │ │ │ +
1683 Impl::asMatrix(*j).umv(xj,yi);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1689 template<
class X,
class Y>
│ │ │ │ +
│ │ │ │ +
1690 void mmv (
const X& x, Y& y)
const
│ │ │ │ +
│ │ │ │ +
1692#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
1694 DUNE_THROW(
BCRSMatrixError,
"You can only call arithmetic operations on fully built BCRSMatrix instances");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1704 auto&& xj = Impl::asVector(x[j.index()]);
│ │ │ │ +
1705 auto&& yi = Impl::asVector(y[i.index()]);
│ │ │ │ +
1706 Impl::asMatrix(*j).mmv(xj,yi);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1712 template<
class X,
class Y,
class F>
│ │ │ │ +
│ │ │ │ +
1713 void usmv (F&& alpha,
const X& x, Y& y)
const
│ │ │ │ +
│ │ │ │ +
1715#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
1717 DUNE_THROW(
BCRSMatrixError,
"You can only call arithmetic operations on fully built BCRSMatrix instances");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1727 auto&& xj = Impl::asVector(x[j.index()]);
│ │ │ │ +
1728 auto&& yi = Impl::asVector(y[i.index()]);
│ │ │ │ +
1729 Impl::asMatrix(*j).usmv(alpha,xj,yi);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1735 template<
class X,
class Y>
│ │ │ │ +
│ │ │ │ +
1736 void mtv (
const X& x, Y& y)
const
│ │ │ │ +
│ │ │ │ +
1738#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
1740 DUNE_THROW(
BCRSMatrixError,
"You can only call arithmetic operations on fully built BCRSMatrix instances");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1750 template<
class X,
class Y>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1753#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
1755 DUNE_THROW(
BCRSMatrixError,
"You can only call arithmetic operations on fully built BCRSMatrix instances");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1765 auto&& xi = Impl::asVector(x[i.index()]);
│ │ │ │ +
1766 auto&& yj = Impl::asVector(y[j.index()]);
│ │ │ │ +
1767 Impl::asMatrix(*j).umtv(xi,yj);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1773 template<
class X,
class Y>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1776#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1786 auto&& xi = Impl::asVector(x[i.index()]);
│ │ │ │ +
1787 auto&& yj = Impl::asVector(y[j.index()]);
│ │ │ │ +
1788 Impl::asMatrix(*j).mmtv(xi,yj);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1794 template<
class X,
class Y>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1797#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
1799 DUNE_THROW(
BCRSMatrixError,
"You can only call arithmetic operations on fully built BCRSMatrix instances");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1809 auto&& xi = Impl::asVector(x[i.index()]);
│ │ │ │ +
1810 auto&& yj = Impl::asVector(y[j.index()]);
│ │ │ │ +
1811 Impl::asMatrix(*j).usmtv(alpha,xi,yj);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1817 template<
class X,
class Y>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1820#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
1822 DUNE_THROW(
BCRSMatrixError,
"You can only call arithmetic operations on fully built BCRSMatrix instances");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1832 auto&& xi = Impl::asVector(x[i.index()]);
│ │ │ │ +
1833 auto&& yj = Impl::asVector(y[j.index()]);
│ │ │ │ +
1834 Impl::asMatrix(*j).umhv(xi,yj);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1840 template<
class X,
class Y>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1843#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
1845 DUNE_THROW(
BCRSMatrixError,
"You can only call arithmetic operations on fully built BCRSMatrix instances");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1855 auto&& xi = Impl::asVector(x[i.index()]);
│ │ │ │ +
1856 auto&& yj = Impl::asVector(y[j.index()]);
│ │ │ │ +
1857 Impl::asMatrix(*j).mmhv(xi,yj);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1863 template<
class X,
class Y>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1866#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
1868 DUNE_THROW(
BCRSMatrixError,
"You can only call arithmetic operations on fully built BCRSMatrix instances");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1878 auto&& xi = Impl::asVector(x[i.index()]);
│ │ │ │ +
1879 auto&& yj = Impl::asVector(y[j.index()]);
│ │ │ │ +
1880 Impl::asMatrix(*j).usmhv(alpha,xi,yj);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1891#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
1893 DUNE_THROW(
BCRSMatrixError,
"You can only call arithmetic operations on fully built BCRSMatrix instances");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1896 typename FieldTraits<field_type>::real_type sum=0;
│ │ │ │ +
│ │ │ │ +
1898 for (
auto&& row : (*this))
│ │ │ │ +
1899 for (
auto&&
entry : row)
│ │ │ │ +
1900 sum += Impl::asMatrix(
entry).frobenius_norm2();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1913 typename std::enable_if<!HasNaN<ft>::value,
int>::type = 0>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1916 DUNE_THROW(
BCRSMatrixError,
"You can only call arithmetic operations on fully built BCRSMatrix instances");
│ │ │ │ +
│ │ │ │ +
1918 using real_type =
typename FieldTraits<ft>::real_type;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1922 for (
auto const &x : *
this) {
│ │ │ │ +
│ │ │ │ +
1924 for (
auto const &y : x)
│ │ │ │ +
1925 sum += Impl::asMatrix(y).infinity_norm();
│ │ │ │ +
1926 norm = max(sum, norm);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1933 typename std::enable_if<!HasNaN<ft>::value,
int>::type = 0>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1936 DUNE_THROW(
BCRSMatrixError,
"You can only call arithmetic operations on fully built BCRSMatrix instances");
│ │ │ │ +
│ │ │ │ +
1938 using real_type =
typename FieldTraits<ft>::real_type;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1942 for (
auto const &x : *
this) {
│ │ │ │ +
│ │ │ │ +
1944 for (
auto const &y : x)
│ │ │ │ +
1945 sum += Impl::asMatrix(y).infinity_norm_real();
│ │ │ │ +
1946 norm = max(sum, norm);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1953 typename std::enable_if<HasNaN<ft>::value,
int>::type = 0>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1956 DUNE_THROW(
BCRSMatrixError,
"You can only call arithmetic operations on fully built BCRSMatrix instances");
│ │ │ │ +
│ │ │ │ +
1958 using real_type =
typename FieldTraits<ft>::real_type;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1962 real_type isNaN = 1;
│ │ │ │ +
1963 for (
auto const &x : *
this) {
│ │ │ │ +
│ │ │ │ +
1965 for (
auto const &y : x)
│ │ │ │ +
1966 sum += Impl::asMatrix(y).infinity_norm();
│ │ │ │ +
1967 norm = max(sum, norm);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1971 return norm * (isNaN / isNaN);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1976 typename std::enable_if<HasNaN<ft>::value,
int>::type = 0>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1979 DUNE_THROW(
BCRSMatrixError,
"You can only call arithmetic operations on fully built BCRSMatrix instances");
│ │ │ │ +
│ │ │ │ +
1981 using real_type =
typename FieldTraits<ft>::real_type;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1985 real_type isNaN = 1;
│ │ │ │ +
│ │ │ │ +
1987 for (
auto const &x : *
this) {
│ │ │ │ +
│ │ │ │ +
1989 for (
auto const &y : x)
│ │ │ │ +
1990 sum += Impl::asMatrix(y).infinity_norm_real();
│ │ │ │ +
1991 norm = max(sum, norm);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1995 return norm * (isNaN / isNaN);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2038#ifdef DUNE_ISTL_WITH_CHECKING
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2042 return (
r[i].size() &&
r[i].find(j) !=
r[i].
end());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2052 typename std::allocator_traits<A>::template rebind_alloc<B>
allocator_;
│ │ │ │ +
│ │ │ │ +
2054 typename std::allocator_traits<A>::template rebind_alloc<row_type>
rowAllocator_;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2072 std::shared_ptr<size_type>
j_;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2090 r[i].set(s,current_row.getptr(), current_row.getindexptr());
│ │ │ │ +
│ │ │ │ +
2092 current_row.setptr(current_row.getptr()+s);
│ │ │ │ +
2093 current_row.setindexptr(current_row.getindexptr()+s);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2096 r[i].set(0,
nullptr,
nullptr);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2116 r[i].setindexptr(jptr);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2119 r[i].set(0,
nullptr,
nullptr);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2137 if (
r[i].getsize() > 0) {
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2142 r[i].set(0,
nullptr,
nullptr);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2146 aptr +=
r[i].getsize();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2190 if (
r[i].getsize()>0)
│ │ │ │ +
│ │ │ │ +
2192 for (B *
col=
r[i].getptr()+(
r[i].getsize()-1),
│ │ │ │ +
2193 *colend =
r[i].getptr()-1;
col!=colend; --
col) {
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2200 r[i].set(0,
nullptr,
nullptr);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2205 if (
n>0 && deallocateRows &&
r) {
│ │ │ │ +
2206 for(
row_type *riter=
r+(
n-1), *rend=
r-1; riter!=rend; --riter)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2240 nnz_ = allocationSize;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2247 DUNE_THROW(InvalidStateException,
"Rows have already been allocated, cannot allocate a second time");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2266 alloc.deallocate(ptr, size);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2279 DUNE_THROW(InvalidStateException,
"Cannot allocate data array (already allocated)");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2298 DUNE_THROW(InvalidStateException,
"implicit_allocate() may only be called in implicit build mode");
│ │ │ │ +
│ │ │ │ +
2300 DUNE_THROW(InvalidStateException,
"memory has already been allocated");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2304 DUNE_THROW(InvalidStateException,
"You have to set the implicit build mode parameters before starting to build the matrix");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2313 B* aptr =
a + osize;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2316 r[i].set(0,aptr,jptr);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2326 template<
class B,
class A>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
2330 using real_type =
typename FieldTraits<field_type>::real_type;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
Helper functions for determining the vector/matrix block level.
│ │ │ │ +
│ │ │ │ +
This file implements a vector space as a tensor product of a given vector space. The number of compon...
│ │ │ │ +
Some handy generic functions for ISTL matrices.
│ │ │ │ +
Col col
Definition matrixmatrix.hh:351
│ │ │ │
Definition allocator.hh:11
│ │ │ │ -
derive error class from the base class in common
Definition istlexception.hh:19
│ │ │ │ -
Attribute set for overlapping Schwarz.
Definition owneroverlapcopy.hh:59
│ │ │ │ -
AttributeSet
Definition owneroverlapcopy.hh:60
│ │ │ │ -
@ owner
Definition owneroverlapcopy.hh:61
│ │ │ │ -
@ copy
Definition owneroverlapcopy.hh:61
│ │ │ │ -
@ overlap
Definition owneroverlapcopy.hh:61
│ │ │ │ -
Information about the index distribution.
Definition owneroverlapcopy.hh:78
│ │ │ │ -
std::tuple< GlobalIdType, LocalIdType, int > IndexTripel
A triple describing a local index.
Definition owneroverlapcopy.hh:92
│ │ │ │ -
void addRemoteIndex(const RemoteIndexTripel &x)
Add a new remote index triple to the set of remote indices.
Definition owneroverlapcopy.hh:120
│ │ │ │ -
G GlobalIdType
The type of the global index.
Definition owneroverlapcopy.hh:81
│ │ │ │ -
const std::set< IndexTripel > & localIndices() const
Get the set of indices local to the process.
Definition owneroverlapcopy.hh:133
│ │ │ │ -
const std::set< RemoteIndexTripel > & remoteIndices() const
Get the set of remote indices.
Definition owneroverlapcopy.hh:142
│ │ │ │ -
L LocalIdType
The type of the local index.
Definition owneroverlapcopy.hh:84
│ │ │ │ -
void clear()
Remove all indices from the sets.
Definition owneroverlapcopy.hh:150
│ │ │ │ -
void addLocalIndex(const IndexTripel &x)
Add a new index triple to the set of local indices.
Definition owneroverlapcopy.hh:106
│ │ │ │ -
std::tuple< int, GlobalIdType, int > RemoteIndexTripel
A triple describing a remote index.
Definition owneroverlapcopy.hh:99
│ │ │ │ -
A class setting up standard communication for a two-valued attribute set with owner/overlap/copy sema...
Definition owneroverlapcopy.hh:174
│ │ │ │ -
EnumItem< AttributeSet, OwnerOverlapCopyAttributeSet::copy > CopySet
Definition owneroverlapcopy.hh:195
│ │ │ │ -
const GlobalLookupIndexSet & globalLookup() const
Definition owneroverlapcopy.hh:526
│ │ │ │ -
FieldTraits< typenameT1::field_type >::real_type norm(const T1 &x) const
Compute the global Euclidean norm of a vector.
Definition owneroverlapcopy.hh:425
│ │ │ │ -
void buildOwnerOverlapToAllInterface() const
Definition owneroverlapcopy.hh:233
│ │ │ │ -
Dune::ParallelIndexSet< GlobalIdType, LI, 512 > PIS
Definition owneroverlapcopy.hh:188
│ │ │ │ -
void buildOwnerCopyToAllInterface() const
Definition owneroverlapcopy.hh:254
│ │ │ │ -
void buildOwnerCopyToOwnerCopyInterface() const
Definition owneroverlapcopy.hh:266
│ │ │ │ -
OwnerOverlapCopyCommunication(const IndexInfoFromGrid< GlobalIdType, LocalIdType > &indexinfo, MPI_Comm comm_, SolverCategory::Category cat_=SolverCategory::overlapping, bool freecomm_=false)
Constructor.
Definition owneroverlapcopy.hh:586
│ │ │ │ -
SolverCategory::Category category() const
Get Solver Category.
Definition owneroverlapcopy.hh:295
│ │ │ │ -
void addOwnerCopyToOwnerCopy(const T &source, T &dest) const
Communicate values from owner and copy data points to owner and copy data points and add them to thos...
Definition owneroverlapcopy.hh:379
│ │ │ │ -
void buildCopyToAllInterface() const
Definition owneroverlapcopy.hh:279
│ │ │ │ -
Dune::EnumItem< AttributeSet, OwnerOverlapCopyAttributeSet::copy > CopyFlags
Definition owneroverlapcopy.hh:446
│ │ │ │ -
RemoteIndices & remoteIndices()
Get the underlying remote indices.
Definition owneroverlapcopy.hh:490
│ │ │ │ -
const ParallelIndexSet & indexSet() const
Get the underlying parallel index set.
Definition owneroverlapcopy.hh:462
│ │ │ │ -
Dune::RemoteIndices< PIS > RI
Definition owneroverlapcopy.hh:189
│ │ │ │ -
void buildGlobalLookup(std::size_t size)
Definition owneroverlapcopy.hh:508
│ │ │ │ -
void addOwnerOverlapToAll(const T &source, T &dest) const
Communicate values from owner data points to all other data points and add them to those values.
Definition owneroverlapcopy.hh:345
│ │ │ │ -
Dune::RemoteIndices< PIS > RemoteIndices
The type of the remote indices.
Definition owneroverlapcopy.hh:452
│ │ │ │ -
void project(T1 &x) const
Set vector to zero at copy dofs.
Definition owneroverlapcopy.hh:538
│ │ │ │ -
Dune::AllSet< AttributeSet > AllSet
Definition owneroverlapcopy.hh:197
│ │ │ │ -
Combine< EnumItem< AttributeSet, OwnerOverlapCopyAttributeSet::owner >, EnumItem< AttributeSet, OwnerOverlapCopyAttributeSet::overlap >, AttributeSet > OwnerOverlapSet
Definition owneroverlapcopy.hh:196
│ │ │ │ -
void copyCopyToAll(const T &source, T &dest) const
Communicate values from copy data points to all other data points.
Definition owneroverlapcopy.hh:328
│ │ │ │ -
Dune::GlobalLookupIndexSet< ParallelIndexSet > GlobalLookupIndexSet
The type of the reverse lookup of indices.
Definition owneroverlapcopy.hh:456
│ │ │ │ -
Dune::Interface IF
Definition owneroverlapcopy.hh:193
│ │ │ │ -
~OwnerOverlapCopyCommunication()
Definition owneroverlapcopy.hh:650
│ │ │ │ -
void buildGlobalLookup()
Definition owneroverlapcopy.hh:495
│ │ │ │ -
Dune::BufferedCommunicator BC
Definition owneroverlapcopy.hh:192
│ │ │ │ -
OwnerOverlapCopyCommunication(MPI_Comm comm_, SolverCategory::Category cat_=SolverCategory::overlapping, bool freecomm_=false)
Construct the communication without any indices.
Definition owneroverlapcopy.hh:554
│ │ │ │ -
ParallelIndexSet & indexSet()
Get the underlying parallel index set.
Definition owneroverlapcopy.hh:480
│ │ │ │ -
void dot(const T1 &x, const T1 &y, T2 &result) const
Compute a global dot product of two vectors.
Definition owneroverlapcopy.hh:398
│ │ │ │ -
const Communication< MPI_Comm > & communicator() const
Definition owneroverlapcopy.hh:299
│ │ │ │ -
OwnerOverlapCopyCommunication(SolverCategory::Category cat_=SolverCategory::overlapping)
Construct the communication without any indices using MPI_COMM_WORLD.
Definition owneroverlapcopy.hh:572
│ │ │ │ -
EnumItem< AttributeSet, OwnerOverlapCopyAttributeSet::owner > OwnerSet
Definition owneroverlapcopy.hh:194
│ │ │ │ -
void copyOwnerToAll(const T &source, T &dest) const
Communicate values from owner data points to all other data points.
Definition owneroverlapcopy.hh:311
│ │ │ │ -
const RemoteIndices & remoteIndices() const
Get the underlying remote indices.
Definition owneroverlapcopy.hh:471
│ │ │ │ -
friend void loadMatrixMarket(M &, const std::string &, OwnerOverlapCopyCommunication< G, L > &, bool)
Load a parallel matrix/vector stored in matrix market format.
Definition matrixmarket.hh:1269
│ │ │ │ -
RI::RemoteIndex RX
Definition owneroverlapcopy.hh:191
│ │ │ │ -
void addOwnerCopyToAll(const T &source, T &dest) const
Communicate values from owner and copy data points to all other data points and add them to those val...
Definition owneroverlapcopy.hh:362
│ │ │ │ -
void freeGlobalLookup()
Definition owneroverlapcopy.hh:520
│ │ │ │ -
Dune::RemoteIndexListModifier< PIS, typename RI::Allocator, false > RILM
Definition owneroverlapcopy.hh:190
│ │ │ │ -
Dune::ParallelIndexSet< GlobalIdType, LI, 512 > ParallelIndexSet
The type of the parallel index set.
Definition owneroverlapcopy.hh:449
│ │ │ │ -
void buildOwnerToAllInterface() const
Definition owneroverlapcopy.hh:244
│ │ │ │ -
gather/scatter callback for communication
Definition owneroverlapcopy.hh:204
│ │ │ │ -
static V gather(const T &a, std::size_t i)
Definition owneroverlapcopy.hh:207
│ │ │ │ -
static void scatter(T &a, V v, std::size_t i)
Definition owneroverlapcopy.hh:212
│ │ │ │ -
CommPolicy< T >::IndexedType V
Definition owneroverlapcopy.hh:205
│ │ │ │ -
Definition owneroverlapcopy.hh:219
│ │ │ │ -
CommPolicy< T >::IndexedType V
Definition owneroverlapcopy.hh:220
│ │ │ │ -
static V gather(const T &a, std::size_t i)
Definition owneroverlapcopy.hh:222
│ │ │ │ -
static void scatter(T &a, V v, std::size_t i)
Definition owneroverlapcopy.hh:227
│ │ │ │ -
Category
Definition solvercategory.hh:23
│ │ │ │ -
@ overlapping
Category for overlapping solvers.
Definition solvercategory.hh:29
│ │ │ │ +
PropertyMapTypeSelector< Amg::VertexVisitedTag, Amg::PropertiesGraph< G, Amg::VertexProperties, EP, VM, EM > >::Type get(const Amg::VertexVisitedTag &tag, Amg::PropertiesGraph< G, Amg::VertexProperties, EP, VM, EM > &graph)
Definition dependency.hh:293
│ │ │ │ +
Definition matrixutils.hh:211
│ │ │ │ +
Statistics about compression achieved in implicit mode.
Definition bcrsmatrix.hh:88
│ │ │ │ +
size_type overflow_total
total number of elements written to the overflow area during construction.
Definition bcrsmatrix.hh:94
│ │ │ │ +
size_type maximum
maximum number of non-zeroes per row.
Definition bcrsmatrix.hh:92
│ │ │ │ +
double avg
average number of non-zeroes per row.
Definition bcrsmatrix.hh:90
│ │ │ │ +
double mem_ratio
fraction of wasted memory resulting from non-used overflow area.
Definition bcrsmatrix.hh:99
│ │ │ │ +
A wrapper for uniform access to the BCRSMatrix during and after the build stage in implicit build mod...
Definition bcrsmatrix.hh:117
│ │ │ │ +
Matrix::block_type block_type
The block_type of the underlying matrix.
Definition bcrsmatrix.hh:125
│ │ │ │ +
ImplicitMatrixBuilder(Matrix &m)
Creates an ImplicitMatrixBuilder for matrix m.
Definition bcrsmatrix.hh:170
│ │ │ │ +
M_ Matrix
The underlying matrix.
Definition bcrsmatrix.hh:122
│ │ │ │ +
ImplicitMatrixBuilder(Matrix &m, size_type rows, size_type cols, size_type avg_cols_per_row, double overflow_fraction)
Sets up matrix m for implicit construction using the given parameters and creates an ImplicitBmatrixu...
Definition bcrsmatrix.hh:194
│ │ │ │ +
size_type M() const
The number of columns in the matrix.
Definition bcrsmatrix.hh:217
│ │ │ │ +
Matrix::size_type size_type
The size_type of the underlying matrix.
Definition bcrsmatrix.hh:128
│ │ │ │ +
row_object operator[](size_type i) const
Returns a proxy for entries in row i.
Definition bcrsmatrix.hh:205
│ │ │ │ +
size_type N() const
The number of rows in the matrix.
Definition bcrsmatrix.hh:211
│ │ │ │ +
Proxy row object for entry access.
Definition bcrsmatrix.hh:137
│ │ │ │ +
block_type & operator[](size_type j) const
Returns entry in column j.
Definition bcrsmatrix.hh:142
│ │ │ │ +
A sparse block matrix with compressed row storage.
Definition bcrsmatrix.hh:466
│ │ │ │ +
typename Imp::BlockTraits< B >::field_type field_type
export the type representing the field
Definition bcrsmatrix.hh:488
│ │ │ │ +
std::allocator_traits< A >::template rebind_alloc< row_type > rowAllocator_
Definition bcrsmatrix.hh:2054
│ │ │ │ +
bool exists(size_type i, size_type j) const
return true if (i,j) is in pattern
Definition bcrsmatrix.hh:2036
│ │ │ │ +
BuildStage buildStage() const
The current build stage of the matrix.
Definition bcrsmatrix.hh:2022
│ │ │ │ +
Iterator begin()
Get iterator to first row.
Definition bcrsmatrix.hh:671
│ │ │ │ +
void copyWindowStructure(const BCRSMatrix &Mat)
Copy the window structure from another matrix.
Definition bcrsmatrix.hh:2151
│ │ │ │ +
B & entry(size_type row, size_type col)
Returns reference to entry (row,col) of the matrix.
Definition bcrsmatrix.hh:1317
│ │ │ │ +
void mmhv(const X &x, Y &y) const
y -= A^H x
Definition bcrsmatrix.hh:1841
│ │ │ │ +
void usmhv(const field_type &alpha, const X &x, Y &y) const
y += alpha A^H x
Definition bcrsmatrix.hh:1864
│ │ │ │ +
void umtv(const X &x, Y &y) const
y += A^T x
Definition bcrsmatrix.hh:1751
│ │ │ │ +
double compressionBufferSize_
Definition bcrsmatrix.hh:2076
│ │ │ │ +
size_type m
Definition bcrsmatrix.hh:2060
│ │ │ │ +
RealRowIterator< const row_type > const_iterator
The const iterator over the matrix rows.
Definition bcrsmatrix.hh:703
│ │ │ │ +
void allocate(size_type rows, size_type columns, size_type allocationSize, bool allocateRows, bool allocate_data)
Allocate memory for the matrix structure.
Definition bcrsmatrix.hh:2235
│ │ │ │ +
BCRSMatrix & axpy(field_type alpha, const BCRSMatrix &b)
Add the scaled entries of another matrix to this one.
Definition bcrsmatrix.hh:1621
│ │ │ │ +
FieldTraits< ft >::real_type infinity_norm_real() const
simplified infinity norm (uses Manhattan norm for complex values)
Definition bcrsmatrix.hh:1934
│ │ │ │ +
~BCRSMatrix()
destructor
Definition bcrsmatrix.hh:821
│ │ │ │ +
void allocateData()
Definition bcrsmatrix.hh:2276
│ │ │ │ +
void deallocate(bool deallocateRows=true)
deallocate memory of the matrix.
Definition bcrsmatrix.hh:2168
│ │ │ │ +
Iterator RowIterator
rename the iterators for easier access
Definition bcrsmatrix.hh:697
│ │ │ │ +
row_type & operator[](size_type i)
random access to the rows
Definition bcrsmatrix.hh:545
│ │ │ │ +
BCRSMatrix()
an empty matrix
Definition bcrsmatrix.hh:745
│ │ │ │ +
void endrowsizes()
indicate that size of all rows is defined
Definition bcrsmatrix.hh:1146
│ │ │ │ +
void incrementrowsize(size_type i, size_type s=1)
increment size of row i by s (1 by default)
Definition bcrsmatrix.hh:1135
│ │ │ │ +
void mtv(const X &x, Y &y) const
y = A^T x
Definition bcrsmatrix.hh:1736
│ │ │ │ +
void umhv(const X &x, Y &y) const
y += A^H x
Definition bcrsmatrix.hh:1818
│ │ │ │ +
size_type nonzeroes() const
number of blocks that are stored (the number of blocks that possibly are nonzero)
Definition bcrsmatrix.hh:2013
│ │ │ │ +
size_type allocationSize_
Definition bcrsmatrix.hh:2062
│ │ │ │ +
ConstIterator ConstRowIterator
rename the const row iterator for easier access
Definition bcrsmatrix.hh:734
│ │ │ │ +
BuildStage ready
Definition bcrsmatrix.hh:2049
│ │ │ │ +
void setIndicesNoSort(size_type row, It begin, It end)
Set all column indices for row from the given iterator range.
Definition bcrsmatrix.hh:1232
│ │ │ │ +
BuildMode build_mode
Definition bcrsmatrix.hh:2048
│ │ │ │ +
void setrowsize(size_type i, size_type s)
Set number of indices in row i to s.
Definition bcrsmatrix.hh:1114
│ │ │ │ +
RealRowIterator< row_type > Iterator
Definition bcrsmatrix.hh:668
│ │ │ │ +
size_type nnz_
Definition bcrsmatrix.hh:2061
│ │ │ │ +
BCRSMatrix & operator*=(const field_type &k)
vector space multiplication with scalar
Definition bcrsmatrix.hh:1513
│ │ │ │ +
std::allocator_traits< A >::template rebind_alloc< size_type > sizeAllocator_
Definition bcrsmatrix.hh:2056
│ │ │ │ +
RealRowIterator< row_type > iterator
The iterator over the (mutable matrix rows.
Definition bcrsmatrix.hh:667
│ │ │ │ +
void usmtv(const field_type &alpha, const X &x, Y &y) const
y += alpha A^T x
Definition bcrsmatrix.hh:1795
│ │ │ │ +
ConstIterator beforeBegin() const
Definition bcrsmatrix.hh:728
│ │ │ │ +
RealRowIterator< const row_type > ConstIterator
Definition bcrsmatrix.hh:704
│ │ │ │ +
Iterator beforeBegin()
Definition bcrsmatrix.hh:691
│ │ │ │ +
B * a
Definition bcrsmatrix.hh:2069
│ │ │ │ +
BuildMode
we support two modes
Definition bcrsmatrix.hh:506
│ │ │ │ +
@ implicit
Build entries randomly with an educated guess for the number of entries per row.
Definition bcrsmatrix.hh:535
│ │ │ │ +
@ unknown
Build mode not set!
Definition bcrsmatrix.hh:539
│ │ │ │ +
@ random
Build entries randomly.
Definition bcrsmatrix.hh:526
│ │ │ │ +
@ row_wise
Build in a row-wise manner.
Definition bcrsmatrix.hh:517
│ │ │ │ +
BCRSMatrix(size_type _n, size_type _m, size_type _nnz, BuildMode bm)
matrix with known number of nonzeroes
Definition bcrsmatrix.hh:752
│ │ │ │ +
Imp::CompressedBlockVectorWindow< B, size_type > row_type
implement row_type with compressed vector
Definition bcrsmatrix.hh:500
│ │ │ │ +
::Dune::CompressionStatistics< size_type > CompressionStatistics
The type for the statistics object returned by compress()
Definition bcrsmatrix.hh:503
│ │ │ │ +
BCRSMatrix & operator-=(const BCRSMatrix &b)
Subtract the entries of another matrix from this one.
Definition bcrsmatrix.hh:1596
│ │ │ │ +
BCRSMatrix(const BCRSMatrix &Mat)
copy constructor
Definition bcrsmatrix.hh:802
│ │ │ │ +
Iterator end()
Get iterator to one beyond last row.
Definition bcrsmatrix.hh:677
│ │ │ │ +
row_type * r
Definition bcrsmatrix.hh:2066
│ │ │ │ +
void setIndices(size_type row, It begin, It end)
Set all column indices for row from the given iterator range.
Definition bcrsmatrix.hh:1255
│ │ │ │ +
void addindex(size_type row, size_type col)
add index (row,col) to the matrix
Definition bcrsmatrix.hh:1188
│ │ │ │ +
std::map< std::pair< size_type, size_type >, B > OverflowType
Definition bcrsmatrix.hh:2078
│ │ │ │ +
row_type::Iterator ColIterator
Iterator for the entries of each row.
Definition bcrsmatrix.hh:700
│ │ │ │ +
FieldTraits< field_type >::real_type frobenius_norm() const
frobenius norm: sqrt(sum over squared values of entries)
Definition bcrsmatrix.hh:1906
│ │ │ │ +
A::size_type size_type
The type for the index access and the size.
Definition bcrsmatrix.hh:497
│ │ │ │ +
BCRSMatrix & operator/=(const field_type &k)
vector space division by scalar
Definition bcrsmatrix.hh:1541
│ │ │ │ +
OverflowType overflow
Definition bcrsmatrix.hh:2079
│ │ │ │ +
BCRSMatrix & operator+=(const BCRSMatrix &b)
Add the entries of another matrix to this one.
Definition bcrsmatrix.hh:1574
│ │ │ │ +
BCRSMatrix(size_type _n, size_type _m, size_type _avg, double compressionBufferSize, BuildMode bm)
construct matrix with a known average number of entries per row
Definition bcrsmatrix.hh:781
│ │ │ │ +
CreateIterator createend()
get create iterator pointing to one after the last block
Definition bcrsmatrix.hh:1100
│ │ │ │ +
FieldTraits< field_type >::real_type frobenius_norm2() const
square of frobenius norm, need for block recursion
Definition bcrsmatrix.hh:1889
│ │ │ │ +
Iterator beforeEnd()
Definition bcrsmatrix.hh:684
│ │ │ │ +
row_type::ConstIterator ConstColIterator
Const iterator to the entries of a row.
Definition bcrsmatrix.hh:737
│ │ │ │ +
void usmv(F &&alpha, const X &x, Y &y) const
y += alpha A x
Definition bcrsmatrix.hh:1713
│ │ │ │ +
size_type getrowsize(size_type i) const
get current number of indices in row i
Definition bcrsmatrix.hh:1125
│ │ │ │ +
size_type M() const
number of columns (counted in blocks)
Definition bcrsmatrix.hh:2007
│ │ │ │ +
size_type n
Definition bcrsmatrix.hh:2059
│ │ │ │ +
CreateIterator createbegin()
get initial create iterator
Definition bcrsmatrix.hh:1094
│ │ │ │ +
BuildStage
Definition bcrsmatrix.hh:469
│ │ │ │ +
@ rowSizesBuilt
The row sizes of the matrix are known.
Definition bcrsmatrix.hh:480
│ │ │ │ +
@ built
The matrix structure is fully built.
Definition bcrsmatrix.hh:482
│ │ │ │ +
@ notbuilt
Matrix is not built at all, no memory has been allocated, build mode and size can still be set.
Definition bcrsmatrix.hh:471
│ │ │ │ +
@ notAllocated
Matrix is not built at all, no memory has been allocated, build mode and size can still be set.
Definition bcrsmatrix.hh:473
│ │ │ │ +
@ building
Matrix is currently being built, some memory has been allocated, build mode and size are fixed.
Definition bcrsmatrix.hh:475
│ │ │ │ +
BuildMode buildMode() const
The currently selected build mode of the matrix.
Definition bcrsmatrix.hh:2028
│ │ │ │ +
void mmv(const X &x, Y &y) const
y -= A x
Definition bcrsmatrix.hh:1690
│ │ │ │ +
FieldTraits< ft >::real_type infinity_norm() const
infinity norm (row sum norm, how to generalize for blocks?)
Definition bcrsmatrix.hh:1914
│ │ │ │ +
void mv(const X &x, Y &y) const
y = A x
Definition bcrsmatrix.hh:1641
│ │ │ │ +
B block_type
export the type representing the components
Definition bcrsmatrix.hh:491
│ │ │ │ +
void mmtv(const X &x, Y &y) const
y -= A^T x
Definition bcrsmatrix.hh:1774
│ │ │ │ +
size_type avg
Definition bcrsmatrix.hh:2075
│ │ │ │ +
void umv(const X &x, Y &y) const
y += A x
Definition bcrsmatrix.hh:1667
│ │ │ │ +
void implicit_allocate(size_type _n, size_type _m)
organizes allocation implicit mode calculates correct array size to be allocated and sets the the win...
Definition bcrsmatrix.hh:2295
│ │ │ │ +
void setImplicitBuildModeParameters(size_type _avg, double compressionBufferSize)
Set parameters needed for creation in implicit build mode.
Definition bcrsmatrix.hh:886
│ │ │ │ +
BCRSMatrix(size_type _n, size_type _m, BuildMode bm)
matrix with unknown number of nonzeroes
Definition bcrsmatrix.hh:761
│ │ │ │ +
void endindices()
indicate that all indices are defined, check consistency
Definition bcrsmatrix.hh:1269
│ │ │ │ +
CompressionStatistics compress()
Finishes the buildstage in implicit mode.
Definition bcrsmatrix.hh:1381
│ │ │ │ +
void setDataPointers()
Set data pointers for all rows.
Definition bcrsmatrix.hh:2132
│ │ │ │ +
std::allocator_traits< A >::template rebind_alloc< B > allocator_
Definition bcrsmatrix.hh:2052
│ │ │ │ +
size_type N() const
number of rows (counted in blocks)
Definition bcrsmatrix.hh:2001
│ │ │ │ +
void setBuildMode(BuildMode bm)
Sets the build mode of the matrix.
Definition bcrsmatrix.hh:830
│ │ │ │ +
void setSize(size_type rows, size_type columns, size_type nnz=0)
Set the size of the matrix.
Definition bcrsmatrix.hh:858
│ │ │ │ +
std::shared_ptr< size_type > j_
Definition bcrsmatrix.hh:2072
│ │ │ │ +
void setWindowPointers(ConstRowIterator row)
Definition bcrsmatrix.hh:2081
│ │ │ │ +
BCRSMatrix & operator=(const BCRSMatrix &Mat)
assignment
Definition bcrsmatrix.hh:908
│ │ │ │ +
void setColumnPointers(ConstRowIterator row)
Copy row sizes from iterator range starting at row and set column index pointers for all rows.
Definition bcrsmatrix.hh:2106
│ │ │ │ +
ConstIterator end() const
Get const iterator to one beyond last row.
Definition bcrsmatrix.hh:714
│ │ │ │ +
ConstIterator begin() const
Get const iterator to first row.
Definition bcrsmatrix.hh:708
│ │ │ │ +
A allocator_type
export the allocator type
Definition bcrsmatrix.hh:494
│ │ │ │ +
ConstIterator beforeEnd() const
Definition bcrsmatrix.hh:721
│ │ │ │ +
Iterator access to matrix rows
Definition bcrsmatrix.hh:575
│ │ │ │ +
RealRowIterator()
empty constructor, use with care!
Definition bcrsmatrix.hh:592
│ │ │ │ +
bool equals(const RealRowIterator< ValueType > &other) const
equality
Definition bcrsmatrix.hh:620
│ │ │ │ +
std::remove_const< T >::type ValueType
The unqualified value type.
Definition bcrsmatrix.hh:579
│ │ │ │ +
RealRowIterator(const RealRowIterator< ValueType > &it)
Definition bcrsmatrix.hh:596
│ │ │ │ +
bool equals(const RealRowIterator< const ValueType > &other) const
equality
Definition bcrsmatrix.hh:627
│ │ │ │ +
RealRowIterator(row_type *_p, size_type _i)
constructor
Definition bcrsmatrix.hh:587
│ │ │ │ +
std::ptrdiff_t distanceTo(const RealRowIterator< const ValueType > &other) const
Definition bcrsmatrix.hh:613
│ │ │ │ +
size_type index() const
return index
Definition bcrsmatrix.hh:602
│ │ │ │ +
std::ptrdiff_t distanceTo(const RealRowIterator< ValueType > &other) const
Definition bcrsmatrix.hh:607
│ │ │ │ +
Iterator class for sequential creation of blocks
Definition bcrsmatrix.hh:954
│ │ │ │ +
bool operator==(const CreateIterator &it) const
equality
Definition bcrsmatrix.hh:1049
│ │ │ │ +
CreateIterator & operator++()
prefix increment
Definition bcrsmatrix.hh:974
│ │ │ │ +
size_type index() const
The number of the row that the iterator currently points to.
Definition bcrsmatrix.hh:1055
│ │ │ │ +
bool operator!=(const CreateIterator &it) const
inequality
Definition bcrsmatrix.hh:1043
│ │ │ │ +
CreateIterator(BCRSMatrix &_Mat, size_type _i)
constructor
Definition bcrsmatrix.hh:957
│ │ │ │ +
void insert(size_type j)
put column index in row
Definition bcrsmatrix.hh:1061
│ │ │ │ +
bool contains(size_type j)
return true if column index is in row
Definition bcrsmatrix.hh:1067
│ │ │ │ +
size_type size() const
Get the current row size.
Definition bcrsmatrix.hh:1076
│ │ │ │ +
typename BCRSMatrix< B, A >::field_type field_type
Definition bcrsmatrix.hh:2329
│ │ │ │ +
typename FieldTraits< field_type >::real_type real_type
Definition bcrsmatrix.hh:2330
│ │ │ │ +
Error specific to BCRSMatrix.
Definition istlexception.hh:24
│ │ │ │ +
Thrown when the compression buffer used by the implicit BCRSMatrix construction is exhausted.
Definition istlexception.hh:37
│ │ │ │ +
A generic dynamic dense matrix.
Definition matrix.hh:561
│ │ │ │ +
A::size_type size_type
Type for indices and sizes.
Definition matrix.hh:577
│ │ │ │ +
T block_type
Export the type representing the components.
Definition matrix.hh:568
│ │ │ │ +
Definition matrixutils.hh:538
│ │ │ │
