Patch: Fix Typos in Comments
Jeffrey
oldham at mail.codesourcery.com
Tue Jan 29 17:59:47 UTC 2002
2002-Jan-29 Jeffrey D. Oldham <oldham at codesourcery.com>
* Domain/Grid.h: Fix typos in comments. Change "bidirectional
iterator" to "forward iterator" in comment to reflect code.
* Domain/IndirectionList.h: Likewise.
* Domain/Interval.h: Likewise.
* Domain/Loc.h: Likewise.
* Domain/Range.h: Likewise.
* Domain/Region.h: Likewise.
* Domain/tests/grid.cpp: End comment with a period.
* Engine/BrickBase.h (BrickBase<Dim>::first):
s/direction/dimension/ in comment.
(BrickBase<Dim>::strides_m): Likewise.
(BrickViewBase<Dim>::first): Likewise.
* Engine/DynamicEngine.h (Engine<1,T,Dynamic>::destroy): Remove
incorrect space in comment.
(Engine<1,T,Dynamic>::performDestroy): Remove incorrect apostrophe
in comment.
* Engine/RemoteDynamicEngine.h: End comment with a period.
* Engine/Stencil.h: Remove non-existent 'ArrayStencil' from comment.
* Field/DiffOps/FieldStencil.h: Fix spacing in comment.
* Field/tests/TestBasicRelations.cpp: Fix spacing.
* PETE/Combiners.h: Fix typos in comments.
* PETE/TypeComputations.h: Fix typo in comment.
* Tiny/VectorTensor.h: Likewise.
* Utilities/DataBlockPtr.h (DataBlockController): Fix spelling
mistake in comment.
Applied to mainline
Approved by Stephen Smith
Not tested. Only comments (and one whitespace change) so no testing.
Thanks,
Jeffrey D. Oldham
oldham at codesourcery.com
-------------- next part --------------
Index: Domain/Grid.h
===================================================================
RCS file: /home/pooma/Repository/r2/src/Domain/Grid.h,v
retrieving revision 1.13
diff -c -p -r1.13 Grid.h
*** Domain/Grid.h 2002/01/14 16:48:21 1.13
--- Domain/Grid.h 2002/01/25 03:50:52
***************
*** 84,90 ****
// in the constructor for Grid; it acts like a Loc<1> object
// in that context. The domain arguments for the Grid
// constructors are combined together to form a single domain object with
! // a dimension equal to the sum of the arguments dimensions; for example,
// if you try to create a Grid<3> from a Loc<2> and an Interval<1>, e.g.
// Grid<3> a(Loc<2>(1,2), Interval<1>(3,5));
// the Loc<2> and Interval arguments are combined into a (2+1=3) dimensional
--- 84,90 ----
// in the constructor for Grid; it acts like a Loc<1> object
// in that context. The domain arguments for the Grid
// constructors are combined together to form a single domain object with
! // a dimension equal to the sum of the argument's dimensions; for example,
// if you try to create a Grid<3> from a Loc<2> and an Interval<1>, e.g.
// Grid<3> a(Loc<2>(1,2), Interval<1>(3,5));
// the Loc<2> and Interval arguments are combined into a (2+1=3) dimensional
***************
*** 116,122 ****
// Grid<N> interface:
// -------------------
// long size() - return the 'volume' of the domain, which is the product
! // of the lenghts of the N 1D Grids
// bool empty() - return if any of the Grid<1> objects have length == 0
// Grid<1> operator[](int N) - return the Nth Grid<1> in a
// multidimensional Grid<M>. For Grid<1> objects, this just
--- 116,122 ----
// Grid<N> interface:
// -------------------
// long size() - return the 'volume' of the domain, which is the product
! // of the lengths of the N 1D Grids
// bool empty() - return if any of the Grid<1> objects have length == 0
// Grid<1> operator[](int N) - return the Nth Grid<1> in a
// multidimensional Grid<M>. For Grid<1> objects, this just
***************
*** 124,130 ****
// comparison operators: <, >, !=, ==, <=, >= : compare a Grid<N> to
// another domain object. The compared domains must have the same
// number of dimensions.
! // arithmetic accumulation operators +=, -=, *=, /= : add or substract in a
// given domain. The added domain must have the same number of
// dimensions, or a dimension of 1 (in which case, the same value
// is used for all dimensions), and be known to be single-valued (which
--- 124,130 ----
// comparison operators: <, >, !=, ==, <=, >= : compare a Grid<N> to
// another domain object. The compared domains must have the same
// number of dimensions.
! // arithmetic accumulation operators +=, -=, *=, /= : add or subtract in a
// given domain. The added domain must have the same number of
// dimensions, or a dimension of 1 (in which case, the same value
// is used for all dimensions), and be known to be single-valued (which
***************
*** 134,140 ****
// the length (and size) the same. += and -= shift the beginning
// endpoints by the given values, also leaving the length and size the
// same. Negation of a Grid negates the endpoints and stride.
! // binary arithmethic operators +, -, *, / : for + and -, adding a Grid
// to another Loc or int returns a new Grid. For * and /, scaling
// by a Loc or int also returns a Grid object, since the stride may
// change.
--- 134,140 ----
// the length (and size) the same. += and -= shift the beginning
// endpoints by the given values, also leaving the length and size the
// same. Negation of a Grid negates the endpoints and stride.
! // binary arithmetic operators +, -, *, / : for + and -, adding a Grid
// to another Loc or int returns a new Grid. For * and /, scaling
// by a Loc or int also returns a Grid object, since the stride may
// change.
***************
*** 152,159 ****
// int first() - the beginning endpoint.
// int last() - the ending endpoint.
// int min(), int max() - min or max of the endpoints.
! // Interval<1>::iterator begin() and end() - return iterators for the 1D
! // domain. These act like (at least) bidirectional iterators.
//
// For the special case of Grid<1>, there is a specialization given
// after the general case that has different constructors.
--- 152,159 ----
// int first() - the beginning endpoint.
// int last() - the ending endpoint.
// int min(), int max() - min or max of the endpoints.
! // Grid<1>::iterator begin() and end() - return iterators for the 1D
! // domain. These act like (at least) forward iterators.
//
// For the special case of Grid<1>, there is a specialization given
// after the general case that has different constructors.
Index: Domain/IndirectionList.h
===================================================================
RCS file: /home/pooma/Repository/r2/src/Domain/IndirectionList.h,v
retrieving revision 1.16
diff -c -p -r1.16 IndirectionList.h
*** Domain/IndirectionList.h 2001/04/13 02:12:59 1.16
--- Domain/IndirectionList.h 2002/01/25 03:50:52
***************
*** 85,91 ****
// IndirectionList<T> interface:
// -------------------
// long size() - return the 'volume' of the domain, which is the product
! // of the lenghts of the N 1D IndirectionLists
// bool empty() - return if any of the IndirectionList objects have
// length == 0
// IndirectionList operator[](int N) - return the Nth IndirectionList
--- 85,91 ----
// IndirectionList<T> interface:
// -------------------
// long size() - return the 'volume' of the domain, which is the product
! // of the lengths of the N 1D IndirectionLists
// bool empty() - return if any of the IndirectionList objects have
// length == 0
// IndirectionList operator[](int N) - return the Nth IndirectionList
***************
*** 94,100 ****
// comparison operators: <, >, !=, ==, <=, >= : compare a IndirectionList
// to another domain object. The compared domains must have the same
// number of dimensions.
! // arithmetic accumulation operators +=, -=, *=, /= : add or substract in a
// given domain. The added domain must have the same number of
// dimensions, or a dimension of 1 (in which case, the same value
// is used for all dimensions), and be known to be single-valued (which
--- 94,100 ----
// comparison operators: <, >, !=, ==, <=, >= : compare a IndirectionList
// to another domain object. The compared domains must have the same
// number of dimensions.
! // arithmetic accumulation operators +=, -=, *=, /= : add or subtract in a
// given domain. The added domain must have the same number of
// dimensions, or a dimension of 1 (in which case, the same value
// is used for all dimensions), and be known to be single-valued (which
***************
*** 120,126 ****
// int last() - the ending endpoint.
// int min(), int max() - min or max of the endpoints.
// IndirectionList::iterator begin() and end() - return iterators for
! // the 1D domain. These act like (at least) bidirectional iterators.
//
//-----------------------------------------------------------------------------
--- 120,126 ----
// int last() - the ending endpoint.
// int min(), int max() - min or max of the endpoints.
// IndirectionList::iterator begin() and end() - return iterators for
! // the 1D domain. These act like (at least) forward iterators.
//
//-----------------------------------------------------------------------------
Index: Domain/Interval.h
===================================================================
RCS file: /home/pooma/Repository/r2/src/Domain/Interval.h,v
retrieving revision 1.19
diff -c -p -r1.19 Interval.h
*** Domain/Interval.h 2002/01/14 16:48:21 1.19
--- Domain/Interval.h 2002/01/25 03:50:52
***************
*** 78,84 ****
// in the constructor for Interval; it acts like a Loc<1> object
// in that context. The domain arguments for the Interval
// constructors are combined together to form a single domain object with
! // a dimension equal to the sum of the arguments dimensions; for example,
// if you try to create an Interval<3> from a Loc<2> and an Interval<1>, e.g.
// Interval<3> a(Loc<2>(1,2), Interval<1>(3,5));
// the Loc<2> and Interval arguments are combined into a (2+1=3) dimensional
--- 78,84 ----
// in the constructor for Interval; it acts like a Loc<1> object
// in that context. The domain arguments for the Interval
// constructors are combined together to form a single domain object with
! // a dimension equal to the sum of the arguments' dimensions; for example,
// if you try to create an Interval<3> from a Loc<2> and an Interval<1>, e.g.
// Interval<3> a(Loc<2>(1,2), Interval<1>(3,5));
// the Loc<2> and Interval arguments are combined into a (2+1=3) dimensional
***************
*** 104,110 ****
// Interval<N> interface:
// ----------------------
// long size() - return the 'volume' of the domain, which is the product
! // of the lenghts of the N 1D Intervals
// bool empty() - return if any of the Interval<1> objects have length == 0
// Interval<1> operator[](int N) - return the Nth Interval<1> in a
// multidimensional Interval<M>. For Interval<1> objects, this just
--- 104,110 ----
// Interval<N> interface:
// ----------------------
// long size() - return the 'volume' of the domain, which is the product
! // of the lengths of the N 1D Intervals
// bool empty() - return if any of the Interval<1> objects have length == 0
// Interval<1> operator[](int N) - return the Nth Interval<1> in a
// multidimensional Interval<M>. For Interval<1> objects, this just
***************
*** 112,118 ****
// comparison operators: <, >, !=, ==, <=, >= : compare an Interval <N> to
// another domain object. The compared domains must have the same
// number of dimensions.
! // arithmetic accumulation operators +=, -= : add or substract in a
// given domain. The added domain must have the same number of
// dimensions, or a dimension of 1 (in which case, the same value
// is used for all dimensions), and be known to be single-valued (which
--- 112,118 ----
// comparison operators: <, >, !=, ==, <=, >= : compare an Interval <N> to
// another domain object. The compared domains must have the same
// number of dimensions.
! // arithmetic accumulation operators +=, -= : add or subtract in a
// given domain. The added domain must have the same number of
// dimensions, or a dimension of 1 (in which case, the same value
// is used for all dimensions), and be known to be single-valued (which
***************
*** 120,126 ****
// allowed, since these operators would change the stride and that is
// not allowed for Interval (it has a hard-coded stride of 1).
// The negation operator (operator-) is also NOT allowed for Interval.
! // binary arithmethic operators +, -, *, / : for + and -, adding an Interval
// to another Loc or int returns a new Interval. For * and /, scaling
// by a Loc or int returns a Range object, since the stride may
// change.
--- 120,126 ----
// allowed, since these operators would change the stride and that is
// not allowed for Interval (it has a hard-coded stride of 1).
// The negation operator (operator-) is also NOT allowed for Interval.
! // binary arithmetic operators +, -, *, / : for + and -, adding an Interval
// to another Loc or int returns a new Interval. For * and /, scaling
// by a Loc or int returns a Range object, since the stride may
// change.
***************
*** 135,141 ****
// int last() - the ending endpoint.
// int min(), int max() - min or max of the endpoints.
// Interval<1>::iterator begin() and end() - return iterators for the 1D
! // domain. These act like (at least) bidirectional iterators.
//
// Interval inherits much of its activity from Domain<DomainTraits<Interval>>.
//
--- 135,141 ----
// int last() - the ending endpoint.
// int min(), int max() - min or max of the endpoints.
// Interval<1>::iterator begin() and end() - return iterators for the 1D
! // domain. These act like (at least) forward iterators.
//
// Interval inherits much of its activity from Domain<DomainTraits<Interval>>.
//
Index: Domain/Loc.h
===================================================================
RCS file: /home/pooma/Repository/r2/src/Domain/Loc.h,v
retrieving revision 1.25
diff -c -p -r1.25 Loc.h
*** Domain/Loc.h 2002/01/14 16:48:21 1.25
--- Domain/Loc.h 2002/01/25 03:50:52
***************
*** 113,119 ****
// dimensions, or a dimension of 1 (in which case, the same value
// is used for all dimensions), and be known to be single-valued (which
// is true for Loc and int's).
! // binary arithmethic operators +, -, *, / : for + and -, adding a Loc
// to another Loc or int returns a new Loc object. For * and /, scaling
// by a Loc or int returns a Range object, since the stride may
// change.
--- 113,119 ----
// dimensions, or a dimension of 1 (in which case, the same value
// is used for all dimensions), and be known to be single-valued (which
// is true for Loc and int's).
! // binary arithmetic operators +, -, *, / : for + and -, adding a Loc
// to another Loc or int returns a new Loc object. For * and /, scaling
// by a Loc or int returns a Range object, since the stride may
// change.
***************
*** 129,135 ****
// int last() - the ending endpoint, for Loc<1> just the point itself.
// int min(), int max() - min or max of the endpoints.
// Loc<1>::iterator begin() and end() - return iterators for the 1D domain.
! // These act like (at least) bidirectional iterators.
//
// Loc inherits much of its activity from Domain<DomainTraits<Loc>,Dim>.
// Domain is a base class that uses the template argument as a traits class
--- 129,135 ----
// int last() - the ending endpoint, for Loc<1> just the point itself.
// int min(), int max() - min or max of the endpoints.
// Loc<1>::iterator begin() and end() - return iterators for the 1D domain.
! // These act like (at least) forward iterators.
//
// Loc inherits much of its activity from Domain<DomainTraits<Loc>,Dim>.
// Domain is a base class that uses the template argument as a traits class
Index: Domain/Range.h
===================================================================
RCS file: /home/pooma/Repository/r2/src/Domain/Range.h,v
retrieving revision 1.20
diff -c -p -r1.20 Range.h
*** Domain/Range.h 2002/01/14 16:48:21 1.20
--- Domain/Range.h 2002/01/25 03:50:52
*************** void fillRangeScalar(Range<Dim> &r, cons
*** 111,117 ****
// Range<N> interface:
// -------------------
// long size() - return the 'volume' of the domain, which is the product
! // of the lenghts of the N 1D Ranges
// bool empty() - return if any of the Range<1> objects have length == 0
// Range<1> operator[](int N) - return the Nth Range<1> in a
// multidimensional Range<M>. For Range<1> objects, this just
--- 111,117 ----
// Range<N> interface:
// -------------------
// long size() - return the 'volume' of the domain, which is the product
! // of the lengths of the N 1D Ranges
// bool empty() - return if any of the Range<1> objects have length == 0
// Range<1> operator[](int N) - return the Nth Range<1> in a
// multidimensional Range<M>. For Range<1> objects, this just
*************** void fillRangeScalar(Range<Dim> &r, cons
*** 119,125 ****
// comparison operators: <, >, !=, ==, <=, >= : compare a Range<N> to
// another domain object. The compared domains must have the same
// number of dimensions.
! // arithmetic accumulation operators +=, -=, *=, /= : add or substract in a
// given domain. The added domain must have the same number of
// dimensions, or a dimension of 1 (in which case, the same value
// is used for all dimensions), and be known to be single-valued (which
--- 119,125 ----
// comparison operators: <, >, !=, ==, <=, >= : compare a Range<N> to
// another domain object. The compared domains must have the same
// number of dimensions.
! // arithmetic accumulation operators +=, -=, *=, /= : add or subtract in a
// given domain. The added domain must have the same number of
// dimensions, or a dimension of 1 (in which case, the same value
// is used for all dimensions), and be known to be single-valued (which
*************** void fillRangeScalar(Range<Dim> &r, cons
*** 129,135 ****
// the length (and size) the same. += and -= shift the beginning
// endpoints by the given values, also leaving the length and size the
// same. Negation of a Range negates the endpoints and stride.
! // binary arithmethic operators +, -, *, / : for + and -, adding a Range
// to another Loc or int returns a new Range. For * and /, scaling
// by a Loc or int also returns a Range object, since the stride may
// change.
--- 129,135 ----
// the length (and size) the same. += and -= shift the beginning
// endpoints by the given values, also leaving the length and size the
// same. Negation of a Range negates the endpoints and stride.
! // binary arithmetic operators +, -, *, / : for + and -, adding a Range
// to another Loc or int returns a new Range. For * and /, scaling
// by a Loc or int also returns a Range object, since the stride may
// change.
*************** void fillRangeScalar(Range<Dim> &r, cons
*** 147,154 ****
// int first() - the beginning endpoint.
// int last() - the ending endpoint.
// int min(), int max() - min or max of the endpoints.
! // Interval<1>::iterator begin() and end() - return iterators for the 1D
! // domain. These act like (at least) bidirectional iterators.
//
// For the special case of Range<1>, there is a specialization given
// after the general case that has different constructors.
--- 147,154 ----
// int first() - the beginning endpoint.
// int last() - the ending endpoint.
// int min(), int max() - min or max of the endpoints.
! // Range<1>::iterator begin() and end() - return iterators for the 1D
! // domain. These act like (at least) forward iterators.
//
// For the special case of Range<1>, there is a specialization given
// after the general case that has different constructors.
Index: Domain/Region.h
===================================================================
RCS file: /home/pooma/Repository/r2/src/Domain/Region.h,v
retrieving revision 1.23
diff -c -p -r1.23 Region.h
*** Domain/Region.h 2001/04/13 02:12:59 1.23
--- Domain/Region.h 2002/01/25 03:50:52
***************
*** 78,84 ****
//
// You can construct a Region object using other domain objects.
// The constructors accept up to 7 domain objects of various types.
! // Domain types are, for example, Loc, Region, Interval. an int, double, or
// float may also be used
// in the constructor for Region; it acts like a Loc<1> object
// in that context. The domain arguments for the Region
--- 78,84 ----
//
// You can construct a Region object using other domain objects.
// The constructors accept up to 7 domain objects of various types.
! // Domain types are, for example, Loc, Region, Interval. An int, double, or
// float may also be used
// in the constructor for Region; it acts like a Loc<1> object
// in that context. The domain arguments for the Region
***************
*** 117,123 ****
// Region<N,T> interface:
// -------------------
// T size() - return the 'volume' of the domain, which is the product
! // of the lenghts of the N 1D Regions
// bool empty() - always false here
// Region<1,T> operator[](int N) - return the Nth Region<1,T> in a
// multidimensional Region<M,T>. For Region<1,T> objects, this just
--- 117,123 ----
// Region<N,T> interface:
// -------------------
// T size() - return the 'volume' of the domain, which is the product
! // of the lengths of the N 1D Regions
// bool empty() - always false here
// Region<1,T> operator[](int N) - return the Nth Region<1,T> in a
// multidimensional Region<M,T>. For Region<1,T> objects, this just
***************
*** 125,131 ****
// comparison operators: <, >, !=, ==, <=, >= : compare a Region<N,T> to
// another domain object. The compared domains must have the same
// number of dimensions.
! // arithmetic accumulation operators +=, -=, *=, /= : add or substract in a
// given domain. The added domain must have the same number of
// dimensions, or a dimension of 1 (in which case, the same value
// is used for all dimensions), and be known to be single-valued (which
--- 125,131 ----
// comparison operators: <, >, !=, ==, <=, >= : compare a Region<N,T> to
// another domain object. The compared domains must have the same
// number of dimensions.
! // arithmetic accumulation operators +=, -=, *=, /= : add or subtract in a
// given domain. The added domain must have the same number of
// dimensions, or a dimension of 1 (in which case, the same value
// is used for all dimensions), and be known to be single-valued (which
***************
*** 135,141 ****
// the length (and size) the same. += and -= shift the beginning
// endpoints by the given values, also leaving the length and size the
// same. Negation of a Region negates the endpoints and stride.
! // binary arithmethic operators +, -, *, / : for + and -, adding a Region
// to another Loc or int returns a new Region. For * and /, scaling
// by a Loc or int also returns a Region object, since the stride may
// change.
--- 135,141 ----
// the length (and size) the same. += and -= shift the beginning
// endpoints by the given values, also leaving the length and size the
// same. Negation of a Region negates the endpoints and stride.
! // binary arithmetic operators +, -, *, / : for + and -, adding a Region
// to another Loc or int returns a new Region. For * and /, scaling
// by a Loc or int also returns a Region object, since the stride may
// change.
***************
*** 147,162 ****
// all the methods for Region<N,T> are also available for Region<1,T>. Plus:
// T length() - number of elements (including endpoints) of the domain.
// Really, this should be either 1 or infinity, but it defined here
! // somewhat differently, as just the distance betweent the endpoints. So
// a length of zero really means this just refers to one point, not that
! // this is empty. A Region cannot be empty, it must refer to SOME point(s)
// T first() - the beginning endpoint.
// T last() - the ending endpoint.
// T stride() - here, the same as the length()
// T min(), T max() - min or max of the endpoints.
// bool empty() - always false for a Region
// Region<1,T>::iterator begin() and end() - return iterators for the 1D
! // domain. These act like (at least) bidirectional iterators.
//
// For the special case of Region<1,T>, there is a specialization given
// after the general case that has different constructors.
--- 147,162 ----
// all the methods for Region<N,T> are also available for Region<1,T>. Plus:
// T length() - number of elements (including endpoints) of the domain.
// Really, this should be either 1 or infinity, but it defined here
! // somewhat differently, as just the distance between the endpoints. So
// a length of zero really means this just refers to one point, not that
! // this is empty. A Region cannot be empty, it must refer to SOME point(s).
// T first() - the beginning endpoint.
// T last() - the ending endpoint.
// T stride() - here, the same as the length()
// T min(), T max() - min or max of the endpoints.
// bool empty() - always false for a Region
// Region<1,T>::iterator begin() and end() - return iterators for the 1D
! // domain. These act like (at least) forward iterators.
//
// For the special case of Region<1,T>, there is a specialization given
// after the general case that has different constructors.
Index: Domain/tests/grid.cpp
===================================================================
RCS file: /home/pooma/Repository/r2/src/Domain/tests/grid.cpp,v
retrieving revision 1.5
diff -c -p -r1.5 grid.cpp
*** Domain/tests/grid.cpp 2000/03/07 13:16:42 1.5
--- Domain/tests/grid.cpp 2002/01/25 03:50:53
*************** int main(int argc, char *argv[]) {
*** 60,66 ****
tester.out() << "Created Range = " << range << std::endl;
! // Construct a 1D Grid from the IndirectionList, and from the range
Grid<1> g1(list);
Grid<1> g2(range);
--- 60,66 ----
tester.out() << "Created Range = " << range << std::endl;
! // Construct a 1D Grid from the IndirectionList and from the range.
Grid<1> g1(list);
Grid<1> g2(range);
Index: Engine/BrickBase.h
===================================================================
RCS file: /home/pooma/Repository/r2/src/Engine/BrickBase.h,v
retrieving revision 1.13
diff -c -p -r1.13 BrickBase.h
*** Engine/BrickBase.h 2001/10/24 15:39:42 1.13
--- Engine/BrickBase.h 2002/01/25 03:50:53
*************** public:
*** 173,179 ****
inline const int *originalStrides() const { return &ostrides_m[0]; }
! // Return the first index value for the specified direction.
int first(int i) const;
--- 173,179 ----
inline const int *originalStrides() const { return &ostrides_m[0]; }
! // Return the first index value for the specified dimension.
int first(int i) const;
*************** protected:
*** 315,321 ****
Layout_t layout_m;
! // Strides through actual data block when stepping in different directions.
// We keep two copies - strides_m is used by the offset calculations.
// If we are compressible, then when compressed, these will all be
// set to zero.
--- 315,321 ----
Layout_t layout_m;
! // Strides through actual data block when stepping in different dimensions.
// We keep two copies - strides_m is used by the offset calculations.
// If we are compressible, then when compressed, these will all be
// set to zero.
*************** public:
*** 538,544 ****
inline const int *originalStrides() const { return &ostrides_m[0]; }
! // Return the first index value for the specified direction.
// (Always zero since views are zero-based).
inline int first(int) const { return 0; }
--- 538,544 ----
inline const int *originalStrides() const { return &ostrides_m[0]; }
! // Return the first index value for the specified dimension.
// (Always zero since views are zero-based).
inline int first(int) const { return 0; }
*************** protected:
*** 663,669 ****
Domain_t domain_m;
! // Strides through actual data block when stepping in each direction.
// We keep two copies - strides_m is used by the offset calculations.
// If we are compressible, then when compressed, these will all be
// set to zero.
--- 663,669 ----
Domain_t domain_m;
! // Strides through actual data block when stepping in each dimension.
// We keep two copies - strides_m is used by the offset calculations.
// If we are compressible, then when compressed, these will all be
// set to zero.
Index: Engine/DynamicEngine.h
===================================================================
RCS file: /home/pooma/Repository/r2/src/Engine/DynamicEngine.h,v
retrieving revision 1.16
diff -c -p -r1.16 DynamicEngine.h
*** Engine/DynamicEngine.h 2001/04/09 21:34:27 1.16
--- Engine/DynamicEngine.h 2002/01/25 03:50:53
*************** public:
*** 275,281 ****
void destroy(const Dom &killList);
// Same, but with iterators into some container holding the
! // points of the domain. These must be random-access iterators ( a
// requirement of the underlying delete algorithm).
template <class Iter>
--- 275,281 ----
void destroy(const Dom &killList);
// Same, but with iterators into some container holding the
! // points of the domain. These must be random-access iterators (a
// requirement of the underlying delete algorithm).
template <class Iter>
*************** private:
*** 359,365 ****
// versions that take iterators into the killList. This allows one
// to use many more data structures for holding the kill list.
! // If offsetFlag is true (delete default's it to false), the domain
// is interpreted as a list of offsets rather than a subset of
// the engine's domain.
--- 359,365 ----
// versions that take iterators into the killList. This allows one
// to use many more data structures for holding the kill list.
! // If offsetFlag is true (delete defaults it to false), the domain
// is interpreted as a list of offsets rather than a subset of
// the engine's domain.
Index: Engine/RemoteDynamicEngine.h
===================================================================
RCS file: /home/pooma/Repository/r2/src/Engine/RemoteDynamicEngine.h,v
retrieving revision 1.16
diff -c -p -r1.16 RemoteDynamicEngine.h
*** Engine/RemoteDynamicEngine.h 2001/05/16 21:21:06 1.16
--- Engine/RemoteDynamicEngine.h 2002/01/25 03:50:54
***************
*** 40,46 ****
//
// Engine<1, T, Remote<Dynamic> >
// - A wrapper engine that remotifies an Engine<1, T, Dynamic>.
! // The remote version belongs to a particular context
//
//-----------------------------------------------------------------------------
--- 40,46 ----
//
// Engine<1, T, Remote<Dynamic> >
// - A wrapper engine that remotifies an Engine<1, T, Dynamic>.
! // The remote version belongs to a particular context.
//
//-----------------------------------------------------------------------------
Index: Engine/Stencil.h
===================================================================
RCS file: /home/pooma/Repository/r2/src/Engine/Stencil.h,v
retrieving revision 1.44
diff -c -p -r1.44 Stencil.h
*** Engine/Stencil.h 2001/09/14 22:37:56 1.44
--- Engine/Stencil.h 2002/01/25 03:50:54
***************
*** 30,37 ****
// Classes:
// Stencil - Base class for defining stencils
// StencilEngine - An tag for an engine for representing a stencil
- // ArrayStencil - contains utility functions for building stencils
- // on arrays
// View1 - Specialization for Stencil
// Engine - Specialization for StencilEngine
// NewEngine - Specialization for StencilEngine
--- 30,35 ----
Index: Field/DiffOps/FieldStencil.h
===================================================================
RCS file: /home/pooma/Repository/r2/src/Field/DiffOps/FieldStencil.h,v
retrieving revision 1.1
diff -c -p -r1.1 FieldStencil.h
*** Field/DiffOps/FieldStencil.h 2001/08/30 01:15:09 1.1
--- Field/DiffOps/FieldStencil.h 2002/01/25 03:50:54
*************** struct LeafFunctor<Engine<Dim, T, ApplyF
*** 716,722 ****
};
//---------------------------------------------------------------------------
! // Specialization of DataObjectRequest engineFunctor to pass the request to
// the contained engine.
//---------------------------------------------------------------------------
--- 716,722 ----
};
//---------------------------------------------------------------------------
! // Specialization of DataObjectRequest engineFunctor to pass the request to
// the contained engine.
//---------------------------------------------------------------------------
Index: Field/tests/TestBasicRelations.cpp
===================================================================
RCS file: /home/pooma/Repository/r2/src/Field/tests/TestBasicRelations.cpp,v
retrieving revision 1.2
diff -c -p -r1.2 TestBasicRelations.cpp
*** Field/tests/TestBasicRelations.cpp 2001/10/12 02:09:27 1.2
--- Field/tests/TestBasicRelations.cpp 2002/01/25 03:50:54
*************** struct ComputeVelocity
*** 63,69 ****
{
void doit(const Field_t &v, const Field_t &p, const Field_t &m)
{
! v = p / m;
}
};
--- 63,69 ----
{
void doit(const Field_t &v, const Field_t &p, const Field_t &m)
{
! v = p / m;
}
};
Index: PETE/Combiners.h
===================================================================
RCS file: /home/pooma/Repository/r2/src/PETE/Combiners.h,v
retrieving revision 1.10
diff -c -p -r1.10 Combiners.h
*** PETE/Combiners.h 2000/12/04 21:19:37 1.10
--- PETE/Combiners.h 2002/01/25 03:50:55
*************** peteCombine(const A &a, const B &b, cons
*** 158,164 ****
// back with modified leaves.
//
// This type of operation is useful when expressions are being
! // passed around. For example, you might subset and expression and pass
// that result to another function. The type of expression tree that you
// are passing has subsetted nodes, and could be a different type from the
// original expression.
--- 158,164 ----
// back with modified leaves.
//
// This type of operation is useful when expressions are being
! // passed around. For example, you might subset an expression and pass
// that result to another function. The type of expression tree that you
// are passing has subsetted nodes, and could be a different type from the
// original expression.
*************** struct Combine2<bool, bool, Op, OrCombin
*** 311,317 ****
//
// DESCRIPTION
// This combiner doesn't do anything. Used when the combination isn't meant
! // return anything since combiners cannot return void.
//
//-----------------------------------------------------------------------------
--- 311,317 ----
//
// DESCRIPTION
// This combiner doesn't do anything. Used when the combination isn't meant
! // to return anything since combiners cannot return void.
//
//-----------------------------------------------------------------------------
Index: PETE/TypeComputations.h
===================================================================
RCS file: /home/pooma/Repository/r2/src/PETE/TypeComputations.h,v
retrieving revision 1.11
diff -c -p -r1.11 TypeComputations.h
*** PETE/TypeComputations.h 2000/08/08 17:34:09 1.11
--- PETE/TypeComputations.h 2002/01/25 03:50:55
***************
*** 44,50 ****
// function/operation. For example, operator-(T) should return a T.
// o return a type based entirely on the operation.
// For example, operator! always returns a bool.
! // o sythesize a type based on the type of the argument and the operation.
// The first case is most common. We therefore make it the behavior
// for the base template. The other cases are handled by partial
// specialization.
--- 44,50 ----
// function/operation. For example, operator-(T) should return a T.
// o return a type based entirely on the operation.
// For example, operator! always returns a bool.
! // o synthesize a type based on the type of the argument and the operation.
// The first case is most common. We therefore make it the behavior
// for the base template. The other cases are handled by partial
// specialization.
Index: Tiny/VectorTensor.h
===================================================================
RCS file: /home/pooma/Repository/r2/src/Tiny/VectorTensor.h,v
retrieving revision 1.14
diff -c -p -r1.14 VectorTensor.h
*** Tiny/VectorTensor.h 2000/03/07 13:18:16 1.14
--- Tiny/VectorTensor.h 2002/01/25 03:50:55
*************** dot( const Tensor<D,T1,E1>& v1 , const V
*** 297,303 ****
//
// Full Description:
//
! // Subroutine for taking outper product between two vectors, yielding a tensor.
// Takes the outer product of vector of type V1 and vector of type V2
//
// The chain of operations is:
--- 297,303 ----
//
// Full Description:
//
! // Subroutine for taking outer product between two vectors, yielding a tensor.
// Takes the outer product of vector of type V1 and vector of type V2
//
// The chain of operations is:
Index: Utilities/DataBlockPtr.h
===================================================================
RCS file: /home/pooma/Repository/r2/src/Utilities/DataBlockPtr.h,v
retrieving revision 1.20
diff -c -p -r1.20 DataBlockPtr.h
*** Utilities/DataBlockPtr.h 2001/05/04 15:41:29 1.20
--- Utilities/DataBlockPtr.h 2002/01/25 03:50:55
*************** public:
*** 190,196 ****
// Ordinarily, this will NOT be used. However, if one
// wants to have a RefCountedBlockPtr<T1> where T1 itself
// is or contains a RefCountedBlockPtr<T2>, then this
! // may occaisionally be used. When it IS used, a DEEP
// copy is required. The RefCounted base class's copy
// constructor properly sets the count of the new
// class to zero.
--- 190,196 ----
// Ordinarily, this will NOT be used. However, if one
// wants to have a RefCountedBlockPtr<T1> where T1 itself
// is or contains a RefCountedBlockPtr<T2>, then this
! // may occasionally be used. When it IS used, a DEEP
// copy is required. The RefCounted base class's copy
// constructor properly sets the count of the new
// class to zero.
More information about the pooma-dev
mailing list