From b862c636bf10d0c0842226abcdaee3e28af71cda Mon Sep 17 00:00:00 2001 From: Wolfgang Bangerth Date: Tue, 14 Jan 2025 21:02:53 -0700 Subject: [PATCH] Do not make a difference between debug/release mode when to include a file. --- include/deal.II/grid/tria_iterator.h | 527 ++++++++++++++++- .../deal.II/grid/tria_iterator.templates.h | 529 +----------------- 2 files changed, 518 insertions(+), 538 deletions(-) diff --git a/include/deal.II/grid/tria_iterator.h b/include/deal.II/grid/tria_iterator.h index 839dd1bece..4436e90475 100644 --- a/include/deal.II/grid/tria_iterator.h +++ b/include/deal.II/grid/tria_iterator.h @@ -44,13 +44,6 @@ class TriaActiveIterator; -// note: in non-debug mode, i.e. with optimizations, the file -// tria_iterator.templates.h is included at the end of this file. -// this includes a lot of templates and thus makes compilation -// slower, but at the same time allows for more aggressive -// inlining and thus faster code. - - /** * This class implements an iterator, analogous to those used in the standard * library. It fulfills the requirements of a bidirectional iterator. See the @@ -1245,12 +1238,524 @@ operator<<(std::ostream &out, const TriaActiveIterator &i) } -DEAL_II_NAMESPACE_CLOSE +#ifndef DOXYGEN + +/*------------------------ Functions: TriaRawIterator ------------------*/ + + +template +inline TriaRawIterator::TriaRawIterator() + : accessor(nullptr, -2, -2, nullptr) +{} + + +template +inline TriaRawIterator::TriaRawIterator( + const TriaRawIterator &i) + : accessor(i.accessor) +{} + + + +template +inline TriaRawIterator::TriaRawIterator( + const Triangulation *parent, + const int level, + const int index, + const typename Accessor::AccessorData *local_data) + : accessor(parent, level, index, local_data) +{} + + +template +inline TriaRawIterator::TriaRawIterator( + const TriaAccessorBase &tria_accessor, + const typename Accessor::AccessorData *local_data) + : accessor(nullptr, -2, -2, local_data) +{ + accessor.copy_from(tria_accessor); +} + + +template +inline TriaRawIterator & +TriaRawIterator::operator=(const TriaRawIterator &i) +{ + accessor.copy_from(i.accessor); + + return *this; +} + + + +template +template +inline std::enable_if_t, bool> +TriaRawIterator::operator==( + const TriaRawIterator &other) const +{ + return accessor == other.accessor; +} + + +template +inline bool +TriaRawIterator::operator!=( + const TriaRawIterator &other) const +{ + return !(*this == other); +} + + +template +inline TriaRawIterator +TriaRawIterator::operator++(int) +{ + TriaRawIterator tmp(*this); + operator++(); + + return tmp; +} + + +template +inline TriaRawIterator +TriaRawIterator::operator--(int) +{ + TriaRawIterator tmp(*this); + operator--(); + + return tmp; +} + + +/*----------------------- functions: TriaIterator ---------------*/ + + +template +inline TriaIterator::TriaIterator() + : TriaRawIterator() +{} + + +template +inline TriaIterator::TriaIterator(const TriaIterator &i) + : TriaRawIterator(i.accessor) +{} + + +template +inline TriaIterator::TriaIterator(const TriaRawIterator &i) + : TriaRawIterator(i.accessor) +{ +# ifdef DEBUG + // do this like this, because: + // if we write + // "Assert (IteratorState::past_the_end || used)" + // used() is called anyway, even if + // state==IteratorState::past_the_end, and will then + // throw the exception! + if (this->state() != IteratorState::past_the_end) + Assert(this->accessor.used(), ExcAssignmentOfUnusedObject()); +# endif +} + +template +inline TriaIterator::TriaIterator( + const Triangulation *parent, + const int level, + const int index, + const typename Accessor::AccessorData *local_data) + : TriaRawIterator(parent, level, index, local_data) +{ +# ifdef DEBUG + // do this like this, because: + // if we write + // "Assert (IteratorState::past_the_end || used)" + // used() is called anyway, even if + // state==IteratorState::past_the_end, and will then + // throw the exception! + if (this->state() != IteratorState::past_the_end) + Assert(this->accessor.used(), ExcAssignmentOfUnusedObject()); +# endif +} + + +template +inline TriaIterator::TriaIterator( + const TriaAccessorBase &tria_accessor, + const typename Accessor::AccessorData *local_data) + : TriaRawIterator(tria_accessor, local_data) +{ +# ifdef DEBUG + // do this like this, because: + // if we write + // "Assert (IteratorState::past_the_end || used)" + // used() is called anyway, even if + // state==IteratorState::past_the_end, and will then + // throw the exception! + if (this->state() != IteratorState::past_the_end) + Assert(this->accessor.used(), ExcAssignmentOfUnusedObject()); +# endif +} + + +template +inline TriaIterator & +TriaIterator::operator=(const TriaIterator &i) +{ + this->accessor.copy_from(i.accessor); + return *this; +} + + +template +template +inline TriaIterator & +TriaIterator::operator=(const TriaIterator &i) +{ + this->accessor.copy_from(i.accessor); + return *this; +} + + +template +inline TriaIterator & +TriaIterator::operator=(const TriaRawIterator &i) +{ + this->accessor.copy_from(i.accessor); +# ifdef DEBUG + // do this like this, because: + // if we write + // "Assert (IteratorState::past_the_end || used)" + // used() is called anyway, even if + // state==IteratorState::past_the_end, and will then + // throw the exception! + if (this->state() != IteratorState::past_the_end) + Assert(this->accessor.used(), ExcAssignmentOfUnusedObject()); +# endif + return *this; +} + + +template +template +inline TriaIterator & +TriaIterator::operator=(const TriaRawIterator &i) +{ + this->accessor.copy_from(i.accessor); +# ifdef DEBUG + // do this like this, because: + // if we write + // "Assert (IteratorState::past_the_end || used)" + // used() is called anyway, even if + // state==IteratorState::past_the_end, and will then + // throw the exception! + if (this->state() != IteratorState::past_the_end) + Assert(this->accessor.used(), ExcAssignmentOfUnusedObject()); +# endif + return *this; +} + + +template +inline TriaIterator & +TriaIterator::operator++() +{ + while (TriaRawIterator::operator++(), + (this->state() == IteratorState::valid)) + if (this->accessor.used() == true) + return *this; + return *this; +} + + +template +inline TriaIterator +TriaIterator::operator++(int) +{ + TriaIterator tmp(*this); + operator++(); + + return tmp; +} + + +template +inline TriaIterator & +TriaIterator::operator--() +{ + while (TriaRawIterator::operator--(), + (this->state() == IteratorState::valid)) + if (this->accessor.used() == true) + return *this; + return *this; +} + + +template +inline TriaIterator +TriaIterator::operator--(int) +{ + TriaIterator tmp(*this); + operator--(); + + return tmp; +} + + +/*----------------------- functions: TriaActiveIterator ---------------*/ + + +template +inline TriaActiveIterator::TriaActiveIterator() + : TriaIterator() +{} + + +template +inline TriaActiveIterator::TriaActiveIterator( + const TriaActiveIterator &i) + : TriaIterator(static_cast>(i)) +{} + + +template +inline TriaActiveIterator::TriaActiveIterator( + const TriaRawIterator &i) + : TriaIterator(i) +{ +# ifdef DEBUG + // do this like this, because: + // if we write + // "Assert (IteratorState::past_the_end || !has_children())" + // has_children() is called anyway, even if + // state==IteratorState::past_the_end, and will then + // throw the exception! + if (this->state() != IteratorState::past_the_end) + Assert(this->accessor.has_children() == false, + ExcAssignmentOfInactiveObject()); +# endif +} + + +template +inline TriaActiveIterator::TriaActiveIterator( + const TriaIterator &i) + : TriaIterator(i) +{ +# ifdef DEBUG + // do this like this, because: + // if we write + // "Assert (IteratorState::past_the_end || !has_children())" + // has_children() is called anyway, even if + // state==IteratorState::past_the_end, and will then + // throw the exception! + if (this->state() != IteratorState::past_the_end) + Assert(this->accessor.has_children() == false, + ExcAssignmentOfInactiveObject()); +# endif +} + + +template +inline TriaActiveIterator::TriaActiveIterator( + const Triangulation *parent, + const int level, + const int index, + const typename Accessor::AccessorData *local_data) + : TriaIterator(parent, level, index, local_data) +{ +# ifdef DEBUG + // do this like this, because: + // if we write + // "Assert (IteratorState::past_the_end || !has_children())" + // has_children() is called anyway, even if + // state==IteratorState::past_the_end, and will then + // throw the exception! + if (this->state() != IteratorState::past_the_end) + Assert(this->accessor.has_children() == false, + ExcAssignmentOfInactiveObject()); +# endif +} + + +template +inline TriaActiveIterator::TriaActiveIterator( + const TriaAccessorBase &tria_accessor, + const typename Accessor::AccessorData *local_data) + : TriaIterator(tria_accessor, local_data) +{ +# ifdef DEBUG + // do this like this, because: + // if we write + // "Assert (IteratorState::past_the_end || !has_children())" + // has_children() is called anyway, even if + // state==IteratorState::past_the_end, and will then + // throw the exception! + if (this->state() != IteratorState::past_the_end) + Assert(this->accessor.has_children() == false, + ExcAssignmentOfInactiveObject()); +# endif +} + + +template +inline TriaActiveIterator & +TriaActiveIterator::operator=(const TriaActiveIterator &i) +{ + this->accessor.copy_from(i.accessor); + return *this; +} + + +template +template +inline TriaActiveIterator & +TriaActiveIterator::operator=( + const TriaActiveIterator &i) +{ + this->accessor.copy_from(i.accessor); + return *this; +} + + +template +inline TriaActiveIterator & +TriaActiveIterator::operator=(const TriaRawIterator &i) +{ + this->accessor.copy_from(i.accessor); +# ifdef DEBUG + // do this like this, because: + // if we write + // "Assert (IteratorState::past_the_end || !has_children())" + // has_children() is called anyway, even if + // state==IteratorState::past_the_end, and will then + // throw the exception! + if (this->state() != IteratorState::past_the_end) + Assert(this->accessor.used() && this->accessor.has_children() == false, + ExcAssignmentOfInactiveObject()); +# endif + return *this; +} + + +template +template +inline TriaActiveIterator & +TriaActiveIterator::operator=(const TriaRawIterator &i) +{ + this->accessor.copy_from(i.accessor); +# ifdef DEBUG + // do this like this, because: + // if we write + // "Assert (IteratorState::past_the_end || !has_children())" + // has_children() is called anyway, even if + // state==IteratorState::past_the_end, and will then + // throw the exception! + if (this->state() != IteratorState::past_the_end) + Assert(this->accessor.used() && this->accessor.has_children() == false, + ExcAssignmentOfInactiveObject()); +# endif + return *this; +} + + +template +template +inline TriaActiveIterator & +TriaActiveIterator::operator=(const TriaIterator &i) +{ + this->accessor.copy_from(i.accessor); +# ifdef DEBUG + // do this like this, because: + // if we write + // "Assert (IteratorState::past_the_end || !has_children())" + // has_children() is called anyway, even if + // state==IteratorState::past_the_end, and will then + // throw the exception! + if (this->state() != IteratorState::past_the_end) + Assert(this->accessor.has_children() == false, + ExcAssignmentOfInactiveObject()); +# endif + return *this; +} + + +template +inline TriaActiveIterator & +TriaActiveIterator::operator=(const TriaIterator &i) +{ + this->accessor.copy_from(i.accessor); +# ifdef DEBUG + // do this like this, because: + // if we write + // "Assert (IteratorState::past_the_end || !has_children())" + // has_children() is called anyway, even if + // state==IteratorState::past_the_end, and will then + // throw the exception! + if (this->state() != IteratorState::past_the_end) + Assert(this->accessor.has_children() == false, + ExcAssignmentOfInactiveObject()); +# endif + return *this; +} + + +template +inline TriaActiveIterator & +TriaActiveIterator::operator++() +{ + while (TriaIterator::operator++(), + (this->state() == IteratorState::valid)) + if (this->accessor.has_children() == false) + return *this; + return *this; +} + + +template +inline TriaActiveIterator +TriaActiveIterator::operator++(int) +{ + TriaActiveIterator tmp(*this); + operator++(); + + return tmp; +} + + +template +inline TriaActiveIterator & +TriaActiveIterator::operator--() +{ + while (TriaIterator::operator--(), + (this->state() == IteratorState::valid)) + if (this->accessor.has_children() == false) + return *this; + return *this; +} + + +template +inline TriaActiveIterator +TriaActiveIterator::operator--(int) +{ + TriaActiveIterator tmp(*this); + operator--(); + + return tmp; +} -// if in optimized mode: include more templates -#ifndef DEBUG -# include #endif +DEAL_II_NAMESPACE_CLOSE + #endif diff --git a/include/deal.II/grid/tria_iterator.templates.h b/include/deal.II/grid/tria_iterator.templates.h index 9160190efe..6b6becbcd5 100644 --- a/include/deal.II/grid/tria_iterator.templates.h +++ b/include/deal.II/grid/tria_iterator.templates.h @@ -18,532 +18,7 @@ #include -#include -#include - -DEAL_II_NAMESPACE_OPEN - - -/* Note: This file only contains template definitions and will thus - not produce an object file. It is rather thought to be included - into the *_accessor.cc files. -*/ - - -/*------------------------ Functions: TriaRawIterator ------------------*/ - - -template -inline TriaRawIterator::TriaRawIterator() - : accessor(nullptr, -2, -2, nullptr) -{} - - -template -inline TriaRawIterator::TriaRawIterator( - const TriaRawIterator &i) - : accessor(i.accessor) -{} - - - -template -inline TriaRawIterator::TriaRawIterator( - const Triangulation *parent, - const int level, - const int index, - const typename Accessor::AccessorData *local_data) - : accessor(parent, level, index, local_data) -{} - - -template -inline TriaRawIterator::TriaRawIterator( - const TriaAccessorBase &tria_accessor, - const typename Accessor::AccessorData *local_data) - : accessor(nullptr, -2, -2, local_data) -{ - accessor.copy_from(tria_accessor); -} - - -template -inline TriaRawIterator & -TriaRawIterator::operator=(const TriaRawIterator &i) -{ - accessor.copy_from(i.accessor); - - return *this; -} - - - -template -template -inline std::enable_if_t, bool> -TriaRawIterator::operator==( - const TriaRawIterator &other) const -{ - return accessor == other.accessor; -} - - -template -inline bool -TriaRawIterator::operator!=( - const TriaRawIterator &other) const -{ - return !(*this == other); -} - - -template -inline TriaRawIterator -TriaRawIterator::operator++(int) -{ - TriaRawIterator tmp(*this); - operator++(); - - return tmp; -} - - -template -inline TriaRawIterator -TriaRawIterator::operator--(int) -{ - TriaRawIterator tmp(*this); - operator--(); - - return tmp; -} - - -/*----------------------- functions: TriaIterator ---------------*/ - - -template -inline TriaIterator::TriaIterator() - : TriaRawIterator() -{} - - -template -inline TriaIterator::TriaIterator(const TriaIterator &i) - : TriaRawIterator(i.accessor) -{} - - -template -inline TriaIterator::TriaIterator(const TriaRawIterator &i) - : TriaRawIterator(i.accessor) -{ -#ifdef DEBUG - // do this like this, because: - // if we write - // "Assert (IteratorState::past_the_end || used)" - // used() is called anyway, even if - // state==IteratorState::past_the_end, and will then - // throw the exception! - if (this->state() != IteratorState::past_the_end) - Assert(this->accessor.used(), ExcAssignmentOfUnusedObject()); -#endif -} - - -template -inline TriaIterator::TriaIterator( - const Triangulation *parent, - const int level, - const int index, - const typename Accessor::AccessorData *local_data) - : TriaRawIterator(parent, level, index, local_data) -{ -#ifdef DEBUG - // do this like this, because: - // if we write - // "Assert (IteratorState::past_the_end || used)" - // used() is called anyway, even if - // state==IteratorState::past_the_end, and will then - // throw the exception! - if (this->state() != IteratorState::past_the_end) - Assert(this->accessor.used(), ExcAssignmentOfUnusedObject()); -#endif -} - - -template -inline TriaIterator::TriaIterator( - const TriaAccessorBase &tria_accessor, - const typename Accessor::AccessorData *local_data) - : TriaRawIterator(tria_accessor, local_data) -{ -#ifdef DEBUG - // do this like this, because: - // if we write - // "Assert (IteratorState::past_the_end || used)" - // used() is called anyway, even if - // state==IteratorState::past_the_end, and will then - // throw the exception! - if (this->state() != IteratorState::past_the_end) - Assert(this->accessor.used(), ExcAssignmentOfUnusedObject()); -#endif -} - - -template -inline TriaIterator & -TriaIterator::operator=(const TriaIterator &i) -{ - this->accessor.copy_from(i.accessor); - return *this; -} - - -template -template -inline TriaIterator & -TriaIterator::operator=(const TriaIterator &i) -{ - this->accessor.copy_from(i.accessor); - return *this; -} - - -template -inline TriaIterator & -TriaIterator::operator=(const TriaRawIterator &i) -{ - this->accessor.copy_from(i.accessor); -#ifdef DEBUG - // do this like this, because: - // if we write - // "Assert (IteratorState::past_the_end || used)" - // used() is called anyway, even if - // state==IteratorState::past_the_end, and will then - // throw the exception! - if (this->state() != IteratorState::past_the_end) - Assert(this->accessor.used(), ExcAssignmentOfUnusedObject()); -#endif - return *this; -} - - -template -template -inline TriaIterator & -TriaIterator::operator=(const TriaRawIterator &i) -{ - this->accessor.copy_from(i.accessor); -#ifdef DEBUG - // do this like this, because: - // if we write - // "Assert (IteratorState::past_the_end || used)" - // used() is called anyway, even if - // state==IteratorState::past_the_end, and will then - // throw the exception! - if (this->state() != IteratorState::past_the_end) - Assert(this->accessor.used(), ExcAssignmentOfUnusedObject()); -#endif - return *this; -} - - -template -inline TriaIterator & -TriaIterator::operator++() -{ - while (TriaRawIterator::operator++(), - (this->state() == IteratorState::valid)) - if (this->accessor.used() == true) - return *this; - return *this; -} - - -template -inline TriaIterator -TriaIterator::operator++(int) -{ - TriaIterator tmp(*this); - operator++(); - - return tmp; -} - - -template -inline TriaIterator & -TriaIterator::operator--() -{ - while (TriaRawIterator::operator--(), - (this->state() == IteratorState::valid)) - if (this->accessor.used() == true) - return *this; - return *this; -} - - -template -inline TriaIterator -TriaIterator::operator--(int) -{ - TriaIterator tmp(*this); - operator--(); - - return tmp; -} - - -/*----------------------- functions: TriaActiveIterator ---------------*/ - - -template -inline TriaActiveIterator::TriaActiveIterator() - : TriaIterator() -{} - - -template -inline TriaActiveIterator::TriaActiveIterator( - const TriaActiveIterator &i) - : TriaIterator(static_cast>(i)) -{} - - -template -inline TriaActiveIterator::TriaActiveIterator( - const TriaRawIterator &i) - : TriaIterator(i) -{ -#ifdef DEBUG - // do this like this, because: - // if we write - // "Assert (IteratorState::past_the_end || !has_children())" - // has_children() is called anyway, even if - // state==IteratorState::past_the_end, and will then - // throw the exception! - if (this->state() != IteratorState::past_the_end) - Assert(this->accessor.has_children() == false, - ExcAssignmentOfInactiveObject()); -#endif -} - - -template -inline TriaActiveIterator::TriaActiveIterator( - const TriaIterator &i) - : TriaIterator(i) -{ -#ifdef DEBUG - // do this like this, because: - // if we write - // "Assert (IteratorState::past_the_end || !has_children())" - // has_children() is called anyway, even if - // state==IteratorState::past_the_end, and will then - // throw the exception! - if (this->state() != IteratorState::past_the_end) - Assert(this->accessor.has_children() == false, - ExcAssignmentOfInactiveObject()); -#endif -} - - -template -inline TriaActiveIterator::TriaActiveIterator( - const Triangulation *parent, - const int level, - const int index, - const typename Accessor::AccessorData *local_data) - : TriaIterator(parent, level, index, local_data) -{ -#ifdef DEBUG - // do this like this, because: - // if we write - // "Assert (IteratorState::past_the_end || !has_children())" - // has_children() is called anyway, even if - // state==IteratorState::past_the_end, and will then - // throw the exception! - if (this->state() != IteratorState::past_the_end) - Assert(this->accessor.has_children() == false, - ExcAssignmentOfInactiveObject()); -#endif -} - - -template -inline TriaActiveIterator::TriaActiveIterator( - const TriaAccessorBase &tria_accessor, - const typename Accessor::AccessorData *local_data) - : TriaIterator(tria_accessor, local_data) -{ -#ifdef DEBUG - // do this like this, because: - // if we write - // "Assert (IteratorState::past_the_end || !has_children())" - // has_children() is called anyway, even if - // state==IteratorState::past_the_end, and will then - // throw the exception! - if (this->state() != IteratorState::past_the_end) - Assert(this->accessor.has_children() == false, - ExcAssignmentOfInactiveObject()); -#endif -} - - -template -inline TriaActiveIterator & -TriaActiveIterator::operator=(const TriaActiveIterator &i) -{ - this->accessor.copy_from(i.accessor); - return *this; -} - - -template -template -inline TriaActiveIterator & -TriaActiveIterator::operator=( - const TriaActiveIterator &i) -{ - this->accessor.copy_from(i.accessor); - return *this; -} - - -template -inline TriaActiveIterator & -TriaActiveIterator::operator=(const TriaRawIterator &i) -{ - this->accessor.copy_from(i.accessor); -#ifdef DEBUG - // do this like this, because: - // if we write - // "Assert (IteratorState::past_the_end || !has_children())" - // has_children() is called anyway, even if - // state==IteratorState::past_the_end, and will then - // throw the exception! - if (this->state() != IteratorState::past_the_end) - Assert(this->accessor.used() && this->accessor.has_children() == false, - ExcAssignmentOfInactiveObject()); -#endif - return *this; -} - - -template -template -inline TriaActiveIterator & -TriaActiveIterator::operator=(const TriaRawIterator &i) -{ - this->accessor.copy_from(i.accessor); -#ifdef DEBUG - // do this like this, because: - // if we write - // "Assert (IteratorState::past_the_end || !has_children())" - // has_children() is called anyway, even if - // state==IteratorState::past_the_end, and will then - // throw the exception! - if (this->state() != IteratorState::past_the_end) - Assert(this->accessor.used() && this->accessor.has_children() == false, - ExcAssignmentOfInactiveObject()); -#endif - return *this; -} - - -template -template -inline TriaActiveIterator & -TriaActiveIterator::operator=(const TriaIterator &i) -{ - this->accessor.copy_from(i.accessor); -#ifdef DEBUG - // do this like this, because: - // if we write - // "Assert (IteratorState::past_the_end || !has_children())" - // has_children() is called anyway, even if - // state==IteratorState::past_the_end, and will then - // throw the exception! - if (this->state() != IteratorState::past_the_end) - Assert(this->accessor.has_children() == false, - ExcAssignmentOfInactiveObject()); -#endif - return *this; -} - - -template -inline TriaActiveIterator & -TriaActiveIterator::operator=(const TriaIterator &i) -{ - this->accessor.copy_from(i.accessor); -#ifdef DEBUG - // do this like this, because: - // if we write - // "Assert (IteratorState::past_the_end || !has_children())" - // has_children() is called anyway, even if - // state==IteratorState::past_the_end, and will then - // throw the exception! - if (this->state() != IteratorState::past_the_end) - Assert(this->accessor.has_children() == false, - ExcAssignmentOfInactiveObject()); -#endif - return *this; -} - - -template -inline TriaActiveIterator & -TriaActiveIterator::operator++() -{ - while (TriaIterator::operator++(), - (this->state() == IteratorState::valid)) - if (this->accessor.has_children() == false) - return *this; - return *this; -} - - -template -inline TriaActiveIterator -TriaActiveIterator::operator++(int) -{ - TriaActiveIterator tmp(*this); - operator++(); - - return tmp; -} - - -template -inline TriaActiveIterator & -TriaActiveIterator::operator--() -{ - while (TriaIterator::operator--(), - (this->state() == IteratorState::valid)) - if (this->accessor.has_children() == false) - return *this; - return *this; -} - - -template -inline TriaActiveIterator -TriaActiveIterator::operator--(int) -{ - TriaActiveIterator tmp(*this); - operator--(); - - return tmp; -} - -DEAL_II_NAMESPACE_CLOSE +DEAL_II_WARNING( + "The use of this header file is deprecated. Just include .") #endif -- 2.39.5