template<class ArchiveImplementation>
class polymorphic_iarchive_route :
public polymorphic_iarchive,
- // note: gcc dynamic cross cast fails if the the derivation below is
+ // note: gcc dynamic cross cast fails if the derivation below is
// not public. I think this is a mistake.
public /*protected*/ ArchiveImplementation
{
}
// register type function
template<class T>
- const basic_pointer_iserializer *
+ const basic_pointer_iserializer *
register_type(T * t = NULL){
return ArchiveImplementation::register_type(t);
}
template<class ArchiveImplementation>
class polymorphic_oarchive_route :
public polymorphic_oarchive,
- // note: gcc dynamic cross cast fails if the the derivation below is
+ // note: gcc dynamic cross cast fails if the derivation below is
// not public. I think this is a mistake.
public /*protected*/ ArchiveImplementation
{
}
// register type function
template<class T>
- const basic_pointer_oserializer *
+ const basic_pointer_oserializer *
register_type(T * t = NULL){
return ArchiveImplementation::register_type(t);
}
// Cray employee), the release patch level is reported as "x". This gives
// versions that look like e.g. "8.6.x".
//
-// To accomplish this, the the Cray compiler preprocessor inserts:
+// To accomplish this, the Cray compiler preprocessor inserts:
//
// #define _RELEASE_PATCHLEVEL x
//
#define BOOST_MATH_DISABLE_STD_FPCLASSIFY
//#define BOOST_HAS_FPCLASSIFY
-#define BOOST_SP_USE_PTHREADS
-#define BOOST_AC_USE_PTHREADS
+#define BOOST_SP_USE_PTHREADS
+#define BOOST_AC_USE_PTHREADS
//
// Everything that follows is working around what are thought to be
#undef BOOST_NO_SFINAE_EXPR
#undef BOOST_NO_TWO_PHASE_NAME_LOOKUP
#undef BOOST_MATH_DISABLE_STD_FPCLASSIFY
-#undef BOOST_SP_USE_PTHREADS
-#undef BOOST_AC_USE_PTHREADS
+#undef BOOST_SP_USE_PTHREADS
+#undef BOOST_AC_USE_PTHREADS
#define BOOST_HAS_VARIADIC_TMPL
#define BOOST_HAS_UNISTD_H
this->assign(c_it(val, n), c_it());
}
- //! <b>Effects</b>: Assigns the the range [first, last) to *this.
+ //! <b>Effects</b>: Assigns the range [first, last) to *this.
//!
//! <b>Throws</b>: If memory allocation throws or
//! T's constructor from dereferencing InIt throws.
#endif
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
- //! <b>Effects</b>: Assigns the the range [il.begin(), il.end()) to *this.
+ //! <b>Effects</b>: Assigns the range [il.begin(), il.end()) to *this.
//!
//! <b>Throws</b>: If memory allocation throws or
//! T's constructor from dereferencing std::initializer_list iterator throws.
this->assign(cvalue_iterator(t, n), cvalue_iterator());
}
- //! <b>Effects</b>: Assigns the the range [first, last) to *this.
+ //! <b>Effects</b>: Assigns the range [first, last) to *this.
//!
//! <b>Throws</b>: If memory allocation throws or
//! T's constructor from dereferencing InpIt throws.
}
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
- //! <b>Effects</b>: Assigns the the range [il.begin(), il.end()) to *this.
+ //! <b>Effects</b>: Assigns the range [il.begin(), il.end()) to *this.
//!
//! <b>Throws</b>: If memory allocation throws or
//! T's constructor from dereferencing initializer_list iterator throws.
#endif
- //! <b>Effects</b>: Assigns the the range [first, last) to *this.
+ //! <b>Effects</b>: Assigns the range [first, last) to *this.
//!
//! <b>Throws</b>: If memory allocation throws or T's copy/move constructor/assignment or
//! T's constructor/assignment from dereferencing InpIt throws.
}
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
- //! <b>Effects</b>: Assigns the the range [il.begin(), il.end()) to *this.
+ //! <b>Effects</b>: Assigns the range [il.begin(), il.end()) to *this.
//!
//! <b>Throws</b>: If memory allocation throws or
//! T's constructor from dereferencing iniializer_list iterator throws.
}
#endif
- //! <b>Effects</b>: Assigns the the range [first, last) to *this.
+ //! <b>Effects</b>: Assigns the range [first, last) to *this.
//!
//! <b>Throws</b>: If memory allocation throws or T's copy/move constructor/assignment or
//! T's constructor/assignment from dereferencing InpIt throws.
operations (add, subtract) and storage (minimize space to represent)
in a concrete class. Thus, the date uses a count internally to
represent a particular date. The calendar parameter defines
- the policies for converting the the year-month-day and internal
+ the policies for converting the year-month-day and internal
counted form here. Applications that need to perform heavy
formatting of the same date repeatedly will perform better
by using the year-month-day representation.
// }
/*! Operator allows for adding dissimilar int_adapter types.
- * The return type will match that of the the calling object's type */
+ * The return type will match that of the calling object's type */
template<class rhs_type>
inline
int_adapter operator+(const int_adapter<rhs_type>& rhs) const
}
/*! Operator allows for subtracting dissimilar int_adapter types.
- * The return type will match that of the the calling object's type */
+ * The return type will match that of the calling object's type */
template<class rhs_type>
inline
int_adapter operator-(const int_adapter<rhs_type>& rhs)const
/**
* @name Generate Label Map
* These type generators are responsible for instantiating an associative
- * container for the the labeled graph. Note that the Selector must be
+ * container for the labeled graph. Note that the Selector must be
* select a pair associative container or a vecS, which is only valid if
* Label is an integral type.
*/
// clean_up_embedding does some clean-up and fills in values that have
// to be computed lazily during the actual execution of the algorithm
// (for instance, whether or not a bicomp is flipped in the final
- // embedding). It's dispatched on the the StoreEmbeddingPolicy, since
+ // embedding). It's dispatched on the StoreEmbeddingPolicy, since
// it's not needed if an embedding isn't desired.
typename vertex_vector_t::reverse_iterator vi, vi_end;
new_start = false; //Setting the loop repetition status to false
//step 2
- //initialize the the disance std-vector with 0
+ //initialize the disance std-vector with 0
for(typename std::vector<typename graph_traits<Graph>::vertices_size_type>::iterator iter = dist.begin(); iter != dist.end(); ++iter) *iter = 0;
//generating the RLS (rooted level structure)
// There are, in fact 5 diagonals, but they only differ from zero on the first and last row,
// so we can patch up the tridiagonal row reduction algorithm to deal with two special rows.
// See Kress, equations 8.41
- // The the "tridiagonal" matrix is:
+ // the "tridiagonal" matrix is:
// 1 0 -1
// 1 4 1
// 1 4 1
#include <boost/config.hpp>
-// These are the the "Sinus Cardinal" functions.
+// These are the "Sinus Cardinal" functions.
namespace boost
{
#include <boost/config.hpp>
-// These are the the "Hyperbolic Sinus Cardinal" functions.
+// These are the "Hyperbolic Sinus Cardinal" functions.
namespace boost
{
}
// last observation, if we are still in observation interval
- // might happen due to finite precision problems when computing the the time
+ // might happen due to finite precision problems when computing the time
if( less_eq_with_sign( time , end_time , dt ) )
{
st.calc_state( time , start_state );
namespace boost { namespace numeric { namespace ublas {
- /** \brief Base class for uBLAS statically derived expressions using the the Barton Nackman trick
+ /** \brief Base class for uBLAS statically derived expressions using the Barton Nackman trick
*
* This is a NonAssignable class
* Directly implement nonassignable - simplifes debugging call trace!
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
-// note: this version incorporates the related code into the the
+// note: this version incorporates the related code into the
// the same library as BOOST_ARCHIVE. This could change some day in the
// future
// the sequence of object initialization.
// Unfortunately, this triggers detectors of undefine behavior
// and reports an error. But I've been unable to find a different
- // of guarenteeing that the the singleton is created at pre-main time.
+ // of guarenteeing that the singleton is created at pre-main time.
use(* m_instance);
return static_cast<T &>(t);
// (2) a Base* cannot be converted to Derived* (so the base class is either ambiguous or virtual)
// With both conditions true, Base must be a virtual base of Derived.
// The "is_base_of" is only needed so the compiler can (but is not required to) error out if the types are incomplete.
- // This is in league with the the expected behaviour.
+ // This is in league with the expected behaviour.
template<class T, class U>
constexpr bool is_virtual_base_impl(...) { return true; }
\param [in] a_eAssociativity The associativity of the operator.
\param [in] a_bAllowOpt If this is true the operator may be optimized away.
- Adds a new Binary operator the the parser instance.
+ Adds a new Binary operator the parser instance.
*/
void ParserBase::DefineOprt(const string_type& a_sName, fun_type2 a_pFun, unsigned a_iPrec, EOprtAssociativity a_eAssociativity, bool a_bAllowOpt)
{
(-Control [UMFPACK_ALLOC_INIT]).
Regardless of the value of this parameter, a space equal to or
- greater than the the bare minimum amount of memory needed to start
+ greater than the bare minimum amount of memory needed to start
the factorization is always initially allocated. The bare initial
memory required is returned by umfpack_*_*symbolic in
Info [UMFPACK_VARIABLE_INIT_ESTIMATE] (an exact value, not an
Ax is optional; if Tx and/or Ax are not present (a (double *) NULL
pointer), then Ax is not computed. If present, Ax holds the
- numerical values of the the real part of the sparse matrix A and Az
+ numerical values of the real part of the sparse matrix A and Az
holds the imaginary parts. The nonzero pattern (row indices) for
column j is stored in Ai [(Ap [j]) ... (Ap [j+1]-1)], and the
corresponding numerical values are stored in
*
* - Classes designed to operate at the quadrature point level (or any general continuum point):
* - Differentiation::AD::ScalarFunction: %Differentiation of a scalar-valued function.
- * One typical use would be the the development of constitutive laws directly from a strain
+ * One typical use would be the development of constitutive laws directly from a strain
* energy function. An example of this exact use case is given in step-71.
* - Differentiation::AD::VectorFunction: %Differentiation of a vector-valued function.
* This could be used to linearize the kinematic variables of a constitutive law, or assist
* may not even store all of the elements a non-ghosted vector would
* store on the current processor. Consequently, for Trilinos vectors,
* there is no notion of an 'owner' of vector elements in the way we
- * have it in the the non-ghost case view (or in the PETSc case) and
+ * have it in the non-ghost case view (or in the PETSc case) and
* the name "ghost element" may be misleading since in this view,
* every element we have available locally may or may not be stored
* somewhere else as well, but even if it is, the local element is not
* number of them. It also gives them a global numbering.
*
* A different viewpoint is this: While the mesh and finite element describe
- * abstract properties of the the finite dimensional space $V_h$ in which we
+ * abstract properties of the finite dimensional space $V_h$ in which we
* seek the discrete solution, the %DoFHandler classes enumerate a concrete
* basis of this space so that we can represent the discrete solution as
* $u_h(\mathbf x)= \sum_j U_j \varphi_i(\mathbf x)$ by an ordered set of
<li>New: Memory consumption during compilation has been reduced by splitting
instantiation files. For this make_instantiations now supports additional
- logic to split the the instantiations in .inst files into groups. This is
+ logic to split the instantiations in .inst files into groups. This is
used in fe_values.cc, error_estimator.cc, and others.
<br>
(Timo Heister, 2015/09/05)
</li>
<li>
- Improved: TimerOutput now dynamically adjust to the the width of Section column.
+ Improved: TimerOutput now dynamically adjust to the width of Section column.
<br>
(Denis Davydov, 2018/05/29)
</li>
New: The class MGTransferMatrixFree::build() now also
accepts an optional function for initializing the internal level vectors.
-This is useful if one uses the the transfer operators in the context of
+This is useful if one uses the transfer operators in the context of
smoothers that are built around MatrixFree objects.
<br>
(Peter Munch, 2021/03/09)
PROJECT(myproject)
</pre>
The macro will set an uninitialized <code>CMAKE_BUILD_TYPE</code> variable
-to the the build type of deal.II, i.e. <code>DEAL_II_BUILD_TYPE</code>. If
+to the build type of deal.II, i.e. <code>DEAL_II_BUILD_TYPE</code>. If
<code>CMAKE_BUILD_TYPE</code> is specified it will automatically be reset
if the given value is unsupported by the deal.II installation (i.e., if it
is not equal to <code>Debug</code>, <code>Release</code>, or
// Let us now turn to the functions that deal with particles. The first one
// is about the creation of particles. As mentioned in the introduction,
- // we want to create a particle at points of the cathode if the the electric
+ // we want to create a particle at points of the cathode if the electric
// field $\mathbf E=\nabla V$ exceeds a certain threshold, i.e., if
// $|\mathbf E| \ge E_\text{threshold}$, and if furthermore the electric field
// points into the domain (i.e., if $\mathbf E \cdot \mathbf n < 0$). As is
\mathcal L_h(t, \mathbf{w}_h),
@f]
where we have taken the liberty to also denote the global solution
-vector by $\mathbf{w}_h$ (in addition to the the corresponding finite
+vector by $\mathbf{w}_h$ (in addition to the corresponding finite
element function). Equivalently, the system above has the form
@f[
\frac{\partial \mathbf{w}_h}{\partial t} =
// The next two functions initialize the
// Particles::ParticleHandler objects used in this class. We have two such
// objects: One represents passive tracers, used to plot the trajectories
- // of fluid particles, while the the other represents material particles
+ // of fluid particles, while the other represents material particles
// of the solid, which are placed at quadrature points of the solid grid.
void setup_tracer_particles();
void setup_solid_particles();
// exception of the handling of input parameter files. We allow the user to
// specify an optional parameter file as an argument to the program. If
// nothing is specified, we use the default file "parameters.prm", which is
-// created if non existent. The file name is scanned for the the string "23"
+// created if non existent. The file name is scanned for the string "23"
// first, and "3" afterwards. If the filename contains the string "23", the
// problem classes are instantiated with template arguments 2 and 3
// respectively. If only the string "3" is found, then both template arguments
and follows the logic laid out by Holzapfel @cite Holzapfel2007a.
Starting from the first law of thermodynamics, and following a few technical
-assumptions, it can be shown the the balance between the kinetic plus internal
+assumptions, it can be shown the balance between the kinetic plus internal
energy rates and the power supplied to the system from external
sources is given by the following relationship that equates the rate
of change of the energy in an (arbitrary) volume $V$ on the left, and
// \right]
// @f}
//
- // Well, that escalated quickly -- although the the definition of $\psi_{0}$
+ // Well, that escalated quickly -- although the definition of $\psi_{0}$
// and $f_{\mu_e}$ might have given some hints that the calculating
// the kinetic fields and their linearization would take some effort, it is
// likely that there's a little more complexity to the final definitions
What is more interesting is the output of the convergence tables. They are
outputted into the console, as well into a LaTeX file. The convergence tables
-are shown above. Here, you can see that the the solution has a convergence rate
+are shown above. Here, you can see that the solution has a convergence rate
of $\mathcal{O}(h)$ with respect to the $H^1$-norm, and the solution has a convergence rate
of $\mathcal{O}(h^2)$ with respect to the $L^2$-norm.
Petrov-Galerkin"</em> (SUPG) method, sometimes also called the
streamline diffusion method. A good explanation of the method can be
found in @cite elman2005 . Formally, this method replaces the step
-in which we derive the the weak form of the differential equation from
+in which we derive the weak form of the differential equation from
the strong form: Instead of multiplying the equation by a test
function $v$ and integrating over the domain, we instead multiply
by $v + \delta \beta\cdot\nabla v$, where $\delta$ is a
internal::MatrixFreeFunctions::GeometryType::affine)
{
// affine case: quadrature points are not available but
- // have to be computed from the the corner point and the
+ // have to be computed from the corner point and the
// Jacobian
Point<dim, VectorizedArrayType> point =
this->mapping_data->quadrature_points
const AdditionalData & additional_data)
{
MeshGenerator mesh_generator(additional_data);
- // Cast the the triangulation to the right type so that the right
+ // Cast the triangulation to the right type so that the right
// specialization of the function create_triangulation is picked up.
if (auto parallel_tria =
dynamic_cast<dealii::parallel::distributed::Triangulation<2, 2> *>(
mpi_communicator);
AssertThrowMPI(ierr);
- // Now computing the the displacement, relative to recvbuf,
+ // Now computing the displacement, relative to recvbuf,
// at which to store the incoming data
std::vector<int> rdispls(n_procs);
rdispls[0] = 0;
else
// If not, it asks for the parent of the cell, until it finds the
// parent cell with the refinement level equal to the min_level and
- // inserts that parent cell into the the set of uniform_cells, as the
+ // inserts that parent cell into the set of uniform_cells, as the
// set of cells with the coarsest common refinement level.
{
typename Container::cell_iterator parent = *patch_cell;
/**
* Return the active FE index of the DoFCellAccessor associated with the
- * DoFHandler and the the incoming cell in the triangulation.
+ * DoFHandler and the incoming cell in the triangulation.
*/
unsigned int
active_fe_index(const typename Triangulation<dim>::active_cell_iterator
// Check FE_Collection::hp_line_dof_identities with multiway
// identities for the FE_Q element. For this particular test, we use
-// equidistant support points for the the FE_Q element since that adds
+// equidistant support points for the FE_Q element since that adds
// additional identities between FE_Q(4) and FE_Q(8).
// Check FE_Collection::hp_quad_dof_identities with multiway
// identities for the FE_Q element. For this particular test, we use
-// equidistant support points for the the FE_Q element since that adds
+// equidistant support points for the FE_Q element since that adds
// additional identities between FE_Q(4) and FE_Q(8).
void
test_real_to_unit_cell(const Mapping<dim, spacedim> &mapping)
{
- // define a boundary that fits the the vertices of the hyper cube we're
+ // define a boundary that fits the vertices of the hyper cube we're
// going to create below
SphericalManifold<dim, spacedim> boundary;
// (0, 0 ,0), (0, 0, l), (0, l, 0), (l, 0, 0), in 3D.
// where l is the edge length.
// This is a good test because we know that the inside weights should sum to the
-// area/volume: $V = l^{dim}/dim!$, and that the the surface weights should sum
+// area/volume: $V = l^{dim}/dim!$, and that the surface weights should sum
// to $S = \sqrt(2) l$ in 2D and $S = \sqrt(3)/2 l^2$ in 3D.
template <int dim>
void
// Let us now turn to the functions that deal with particles. The first one
// is about the creation of particles. As mentioned in the introduction,
- // we want to create a particle at points of the cathode if the the electric
+ // we want to create a particle at points of the cathode if the electric
// field $\mathbf E=\nabla V$ exceeds a certain threshold, i.e., if
// $|\mathbf E| \ge E_\text{threshold}$, and if furthermore the electric field
// points into the domain (i.e., if $\mathbf E \cdot \mathbf n < 0$). As is
projects / dealii.git / commitdiff