[vsipl++] Index and Length
Jules Bergmann
jules at codesourcery.com
Thu Mar 30 18:01:24 UTC 2006
Assem,
The code changes look good, but some of the comments appear unnecessary.
In particular, we don't need the comments about how some piece of code
used to use "Point" but now uses "Length/Index". Once "Point" is gone
from a particular section of code, there is no general need to mention
how it used to be implemented. We can get that history from the
changelog and from cvs. Moreover, once we've removed Point from the
library altogether, mentioning it will be confusing.
I don't see any substantive changes to length.hpp. You should revert
your local changes to this file and not commit it.
Some comments misspell 'deprecated".
Finally, I've given some thought to where these functions should go.
The reason that the Point stuff was split out into separate files
point.hpp and point-fcn.hpp was to keep the Point class definition
relatively lightweight so that it could be included without pulling in
the rest of the library. Some of the functions in point-fcn require the
definition of the views (i.e. the extent functions). Including
vector.hpp ends up including quite a bit.
On the surface, worrying about whether point.hpp includes ve,ctor.hpp
might seem silly, since any reasonable VSIPL++ program will end up
including vector.hpp anyway. However, keeping the header dependencies
simple helps improve maintainability. Every so often we make a change
that creates a circular requirement that take some effort to sort out.
Here's what I'd like to do:
- move the view get/put functions from point-fcn.hpp to the respecive
view headers. I.e. get(const_Vector, Index) should go into
vector.hpp. This makes sense becuase if you're going to use get
on a view, you will have to include that view's header. The
view headers should already include domain.hpp, so this doesn't
create a new dependency.
- Move everything else from point.hpp (next, valid, block get/put)
and point-fcn (domain_nth, first, domain constructor helper)
into domain-utils.
How does that sound?
-- Jules
Assem Salama wrote:
> Everyone,
> This patch takes out the use of Point and replaces it with Index and
> Length.
>
> Thanks,
> Assem Salama
>
>
> ------------------------------------------------------------------------
>
> 2006-03-30 Assem Salama <assem at codesourcery.com>
> * src/vsip/impl/length.hpp: Changed the extent function in this file
> to return Length instead of point. This extent takes a Block.
> * src/vsip/impl/par-util.hpp: Changed the foreach_point function to
> work on Index instead of Point.
> * src/vsip/impl/point-fcn.hpp: Added new extent functions to return
> Length instead of Point.
> * src/vsip/impl/point.hpp: Added new functions to make Index and
> Length work correctly. The new functions are get,put,next,valid,
> and domain_nth.
> * tests/appmap.cpp: Converted this test to use Length and Index.
> * tests/fast-block.cpp: Same as appmap.cpp
> * tests/us-block.cpp: Same as above.
> * tests/user_storage.cpp: Same as above.
> * tests/util-par.hpp: Same as above.
> * tests/view.cpp: Same as above.
> * tests/vmmul.cpp: Same as above.
>
>
>
>
> Index: src/vsip/impl/length.hpp
> ===================================================================
> RCS file: /home/cvs/Repository/vpp/src/vsip/impl/length.hpp,v
> retrieving revision 1.3
> diff -u -r1.3 length.hpp
> --- src/vsip/impl/length.hpp 15 Sep 2005 14:49:25 -0000 1.3
> +++ src/vsip/impl/length.hpp 30 Mar 2006 17:00:12 -0000
> @@ -15,8 +15,10 @@
> ***********************************************************************/
>
> #include <vsip/support.hpp>
> +#include <vsip/domain.hpp>
Why is it necessary to include domain.hpp from length.hpp? Domain
doesn't appear to be used in any of the changes to length.
> #include <vsip/impl/vertex.hpp>
>
> +
> namespace vsip
> {
> namespace impl
> @@ -47,6 +49,9 @@
> : Vertex<length_type, 3>(x, y, z) {}
> };
>
> +// This function used to return a Point. Now it returns a Length. The use of
> +// Point is depricated.
> +
This comment doesn't really add any value. Once we've removed Point,
talking about it will create confusion. This kind of history can be
extracted from the ChangeLog and cvs if necessary.
> template <dimension_type Dim,
> typename B>
> inline Length<Dim>
> @@ -69,7 +74,6 @@
> return size;
> }
>
> -
> } // namespace vsip::impl
> } // namespace vsip
>
> Index: src/vsip/impl/par-util.hpp
> ===================================================================
> RCS file: /home/cvs/Repository/vpp/src/vsip/impl/par-util.hpp,v
> retrieving revision 1.8
> diff -u -r1.8 par-util.hpp
> --- src/vsip/impl/par-util.hpp 27 Mar 2006 23:19:34 -0000 1.8
> +++ src/vsip/impl/par-util.hpp 30 Mar 2006 17:00:12 -0000
> @@ -21,6 +21,7 @@
> #include <vsip/impl/distributed-block.hpp>
> #include <vsip/impl/point.hpp>
> #include <vsip/impl/point-fcn.hpp>
> +#include <vsip/domain.hpp>
>
>
>
> @@ -113,10 +114,11 @@
> Domain<dim> ldom = local_domain(view, sb, p);
> Domain<dim> gdom = global_domain(view, sb, p);
>
> - for (Point<dim> idx; valid(extent_old(ldom), idx); next(extent_old(ldom), idx))
> + Length<dim> ext = extent(ldom);
> + for (Index<dim> idx; valid(ext,idx); next(ext, idx))
> {
> - Point<dim> l_idx = domain_nth(ldom, idx);
> - Point<dim> g_idx = domain_nth(gdom, idx);
> + Index<dim> l_idx = domain_nth(ldom, idx);
> + Index<dim> g_idx = domain_nth(gdom, idx);
>
> put(local_view, l_idx, fcn(get(local_view, l_idx), l_idx, g_idx));
> }
> Index: src/vsip/impl/point-fcn.hpp
> ===================================================================
> RCS file: /home/cvs/Repository/vpp/src/vsip/impl/point-fcn.hpp,v
> retrieving revision 1.3
> diff -u -r1.3 point-fcn.hpp
> --- src/vsip/impl/point-fcn.hpp 9 Sep 2005 11:55:00 -0000 1.3
> +++ src/vsip/impl/point-fcn.hpp 30 Mar 2006 17:00:12 -0000
> @@ -53,6 +53,24 @@
> }
>
>
> +// This function is like domain_nth function above but returns an Index
> +// instead of a point
This comment should stand on its own. That way we can remove the above
function.
> +template <dimension_type Dim>
> +Index<Dim>
> +domain_nth(
> + Domain<Dim> const& dom,
> + Index<Dim> const& idx)
> +{
> + Index<Dim> res;
> +
> + for (dimension_type d=0; d<Dim; ++d)
> + res[d] = dom[d].impl_nth(idx[d]);
> +
> + return res;
> +}
> +
> +
> +
>
> /// Get the first index of a domain.
>
> @@ -69,7 +87,8 @@
>
>
>
> -/// Get the extent of a domain, as a point.
> +/// Get the extent of a domain, as a point. This function is now depricated.
> +/// We should use Length now instead.
>
> template <dimension_type Dim>
> Point<Dim>
> @@ -84,9 +103,24 @@
> return res;
> }
>
> +/// Get the extent of a domain as a Length.
>
> +template <dimension_type Dim>
> +Length<Dim>
> +extent(
> + Domain<Dim> const& dom)
> +{
> + Length<Dim> res;
>
> -/// Get the extent of a vector view, as a point.
> + for (dimension_type d=0; d<Dim; ++d)
> + res[d] = dom[d].length();
> +
> + return res;
> +}
> +
> +
> +/// Get the extent of a vector view, as a point. This function is depricated.
> +/// We should use Length now instead.
>
> template <typename T,
> typename Block>
> @@ -96,9 +130,21 @@
> return Point<1>(v.size(0));
> }
>
> +/// Get the extent of a vector view, as a Length.
> +
> +template <typename T,
> + typename Block>
> +Length<1>
> +extent(const_Vector<T, Block> v)
> +{
> + return Length<1>(v.size(0));
> +}
> +
> +
>
>
> -/// Get the extent of a matrix view, as a point.
> +/// Get the extent of a matrix view, as a point. This function is depricated.
> +/// We should use Length now instead of point.
>
> template <typename T,
> typename Block>
> @@ -109,6 +155,16 @@
> }
>
>
> +/// Get the extent of a matrix view, as a Length.
> +
> +template <typename T,
> + typename Block>
> +Length<2>
> +extent(const_Matrix<T, Block> v)
> +{
> + return Length<2>(v.size(0), v.size(1));
> +}
> +
>
> /// Construct a 1-dim domain with an offset and a size (implicit
> /// stride of 1)
> Index: src/vsip/impl/point.hpp
> ===================================================================
> RCS file: /home/cvs/Repository/vpp/src/vsip/impl/point.hpp,v
> retrieving revision 1.8
> diff -u -r1.8 point.hpp
> --- src/vsip/impl/point.hpp 7 Mar 2006 02:15:22 -0000 1.8
> +++ src/vsip/impl/point.hpp 30 Mar 2006 17:00:12 -0000
> @@ -15,6 +15,7 @@
> ***********************************************************************/
>
> #include <vsip/support.hpp>
> +#include <vsip/impl/length.hpp>
>
>
> /***********************************************************************
> @@ -193,6 +194,58 @@
> return idx;
> }
>
> +/* Now let's make the "next" functions that work Index. This function is the
> + * same as the Point one but it operates on an Index
> + */
This comment should stand on its own.
Also, for comments like this that preceed a function and describe its
operation, you should use either C++ style comments '//', or preferably
C++ style comments with an extra '/' -> '///'. These comments get
recognized by synopsis for generating documentation.
For a function, the comments should be something like this:
/// Short descriptions (1-line or so)
/// Optional longer description, covering parameters, etc.
/// This can be multiple lines.
> +inline
> +Index<1>&
> +next(
> + Length<1> const& /*extent*/,
> + Index<1>& idx)
> +{
> + ++idx[0];
> + return idx;
> +}
> +
> +
> +
> +inline
> +Index<2>&
> +next(
> + Length<2> const& extent,
> + Index<2>& idx)
> +{
> + if (++idx[0] == extent[0])
> + {
> + if (++idx[1] != extent[1])
> + idx[0] = 0;
> + }
> + return idx;
> +}
> +
> +
> +
> +inline
> +Index<3>&
> +next(
> + Length<3> const& extent,
> + Index<3>& idx)
> +{
> + if (++idx[0] == extent[0])
> + {
> + if (++idx[1] == extent[1])
> + {
> + if (++idx[2] == extent[2])
> + return idx;
> + idx[1] = 0;
> + }
> + idx[0] = 0;
> + }
> +
> + return idx;
> +}
> +
> +
>
> template <dimension_type Dim>
> inline bool
> @@ -206,6 +259,21 @@
> return true;
> }
>
> +// This function checks if the index is valid given a certain length. This
> +// function works for multiple dimension spaces.
> +template <dimension_type D>
> +inline bool
> +valid(
> + Length<D> const& extent,
> + Index<D> const& idx)
> +{
> + for(dimension_type d=0;d<D;++d)
> + if(idx[d] >= extent[d])
> + return false;
> + return true;
> +}
> +
> +
>
> template <dimension_type Dim>
> inline
> @@ -297,7 +365,6 @@
> }
>
>
> -
> /// Put a value into a 2-dim block.
>
> template <typename Block>
> @@ -325,6 +392,84 @@
> }
>
>
> +// These functions use an Index instead of a Point.
> +// The use Point is depricated
> +
> +/// Get a value from a 1-dim block.
> +
> +template <typename Block>
> +inline typename Block::value_type
> +get(
> + Block const& block,
> + Index<1> const& idx)
> +{
> + return block.get(idx[0]);
> +}
> +
> +
> +
> +/// Get a value from a 2-dim block.
> +
> +template <typename Block>
> +inline typename Block::value_type
> +get(
> + Block const& block,
> + Index<2> const& idx)
> +{
> + return block.get(idx[0], idx[1]);
> +}
> +
> +
> +
> +/// Get a value from a 3-dim block.
> +
> +template <typename Block>
> +inline typename Block::value_type
> +get(
> + Block const& block,
> + Index<3> const& idx)
> +{
> + return block.get(idx[0], idx[1], idx[2]);
> +}
> +
> +
> +
> +/// Put a value into a 1-dim block.
> +
> +template <typename Block>
> +inline void
> +put(
> + Block& block,
> + Index<1> const& idx,
> + typename Block::value_type const& val)
> +{
> + block.put(idx[0], val);
> +}
> +
> +
> +/// Put a value into a 2-dim block.
> +
> +template <typename Block>
> +inline void
> +put(
> + Block& block,
> + Index<2> const& idx,
> + typename Block::value_type const& val)
> +{
> + block.put(idx[0], idx[1], val);
> +}
> +
> +
> +template <typename Block>
> +inline void
> +put(
> + Block& block,
> + Index<3> const& idx,
> + typename Block::value_type const& val)
> +{
> + block.put(idx[0], idx[1], idx[2], val);
> +}
> +
>
>
>
> Index: tests/appmap.cpp
> ===================================================================
> RCS file: /home/cvs/Repository/vpp/tests/appmap.cpp,v
> retrieving revision 1.10
> diff -u -r1.10 appmap.cpp
> --- tests/appmap.cpp 27 Mar 2006 23:19:34 -0000 1.10
> +++ tests/appmap.cpp 30 Mar 2006 17:00:12 -0000
> @@ -13,14 +13,15 @@
> #include <vsip/support.hpp>
> #include <vsip/map.hpp>
> #include <vsip/matrix.hpp>
> +#include <vsip/impl/length.hpp>
> #include "test.hpp"
> #include "output.hpp"
>
> using namespace std;
> using namespace vsip;
>
> -using vsip::impl::Point;
> -using vsip::impl::extent_old;
> +using vsip::impl::Length;
> +using vsip::impl::extent;
> using vsip::impl::valid;
> using vsip::impl::next;
> using vsip::impl::domain_nth;
> @@ -95,12 +96,6 @@
>
>
>
> -inline Index<1> as_index(Point<1> const& p) {return Index<1>(p[0]); }
> -inline Index<2> as_index(Point<2> const& p) {return Index<2>(p[0],p[1]); }
> -inline Index<3> as_index(Point<3> const& p) {return Index<3>(p[0],p[1],p[2]); }
> -
> -
> -
> // Check that local and global indices within a patch are consistent.
>
> template <dimension_type Dim,
> @@ -147,16 +142,20 @@
> }
> }
>
> - Point<Dim> ext = extent_old(gdom);
> + /* We can replace this segment of code with one that uses Length and Index.
> + * The use of Point is depricated and Length and Index should be used
> + * Instead
> + */
Comment not necessary
>
> - for (Point<Dim> idx; valid(ext, idx); next(ext, idx))
> + Length<Dim> ext = extent(gdom);
> + for(Index<Dim> idx; valid(ext,idx); next(ext,idx))
> {
> - Index<Dim> g_idx = as_index(domain_nth(gdom, idx));
> - Index<Dim> l_idx = as_index(domain_nth(ldom, idx));
> -
> + Index<Dim> g_idx = domain_nth(gdom,idx);
> + Index<Dim> l_idx = domain_nth(ldom,idx);
> test_assert(map.impl_subblock_from_global_index(g_idx) == sb);
> test_assert(map.impl_patch_from_global_index(g_idx) == p);
> }
> +
> }
>
>
> Index: tests/fast-block.cpp
> ===================================================================
> RCS file: /home/cvs/Repository/vpp/tests/fast-block.cpp,v
> retrieving revision 1.6
> diff -u -r1.6 fast-block.cpp
> --- tests/fast-block.cpp 20 Dec 2005 12:48:40 -0000 1.6
> +++ tests/fast-block.cpp 30 Mar 2006 17:00:12 -0000
> @@ -16,13 +16,16 @@
> #include <vsip/impl/point.hpp>
> #include <vsip/impl/point-fcn.hpp>
> #include <vsip/impl/fast-block.hpp>
> +#include <vsip/impl/length.hpp>
> #include "test.hpp"
>
> using namespace std;
> using namespace vsip;
>
> -using vsip::impl::Point;
> -using vsip::impl::extent_old;
> +using vsip::impl::Length;
> +using vsip::impl::extent;
> +using vsip::impl::valid;
> +using vsip::impl::next;
>
>
>
> @@ -30,33 +33,35 @@
> Definitions
> ***********************************************************************/
>
> +/* We no longer use Point. Instead we will use Index and Length. We need a
> + * different set of functions that operate on Index and Length instead of
> + * Point.
> + */
comment not necessary
> +
> template <typename T>
> inline T
> identity(
> - Point<1> /*extent*/,
> - Point<1> idx,
> + Length<1> /*extent*/,
> + Index<1> idx,
> int k)
> {
> return static_cast<T>(k*idx[0] + 1);
> }
>
>
> -
> template <typename T>
> inline T
> identity(
> - Point<2> extent,
> - Point<2> idx,
> - int k)
> + Length<2> extent,
> + Index<2> idx,
> + int k)
> {
> - Point<2> offset;
> + Index<2> offset;
> index_type i = (idx[0]+offset[0])*extent[1] + (idx[1]+offset[1]);
> return static_cast<T>(k*i+1);
> }
>
>
> -
> -
> template <dimension_type Dim,
> typename Block>
> void
> @@ -64,15 +69,14 @@
> {
> typedef typename Block::value_type value_type;
>
> - Point<Dim> ex = extent_old<Dim>(blk);
> - for (Point<Dim> idx; idx != ex; next(ex, idx))
> + Length<Dim> ex = extent<Dim>(blk);
> + for (Index<Dim> idx; valid(ex,idx); next(ex, idx))
> {
> put(blk, idx, identity<value_type>(ex, idx, k));
> }
> }
>
>
> -
> template <dimension_type Dim,
> typename Block>
> void
> @@ -80,8 +84,8 @@
> {
> typedef typename Block::value_type value_type;
>
> - Point<Dim> ex = extent_old<Dim>(blk);
> - for (Point<Dim> idx; idx != ex; next(ex, idx))
> + Length<Dim> ex = extent<Dim>(blk);
> + for (Index<Dim> idx; valid(ex,idx); next(ex, idx))
> {
> test_assert(equal( get(blk, idx),
> identity<value_type>(ex, idx, k)));
> @@ -89,7 +93,6 @@
> }
>
>
> -
> template <dimension_type Dim,
> typename Block>
> void
> Index: tests/us-block.cpp
> ===================================================================
> RCS file: /home/cvs/Repository/vpp/tests/us-block.cpp,v
> retrieving revision 1.1
> diff -u -r1.1 us-block.cpp
> --- tests/us-block.cpp 10 Feb 2006 22:24:02 -0000 1.1
> +++ tests/us-block.cpp 30 Mar 2006 17:00:12 -0000
> @@ -16,14 +16,15 @@
> #include <vsip/impl/point.hpp>
> #include <vsip/impl/point-fcn.hpp>
> #include <vsip/impl/us-block.hpp>
> +#include <vsip/impl/length.hpp>
>
> #include "test.hpp"
>
> using namespace std;
> using namespace vsip;
>
> -using vsip::impl::Point;
> -using vsip::impl::extent_old;
> +using vsip::impl::Length;
> +using vsip::impl::extent;
>
>
>
> @@ -31,32 +32,35 @@
> Definitions
> ***********************************************************************/
>
> +/* We no longer use Point. Instead we will use Index and Length. We need a
> + * different set of functions that operate on Index and Length instead of
> + * Point.
> + */
Comment not necessary
> +
> template <typename T>
> inline T
> identity(
> - Point<1> /*extent*/,
> - Point<1> idx,
> + Length<1> /*extent*/,
> + Index<1> idx,
> int k)
> {
> return static_cast<T>(k*idx[0] + 1);
> }
>
>
> -
> template <typename T>
> inline T
> identity(
> - Point<2> extent,
> - Point<2> idx,
> - int k)
> + Length<2> extent,
> + Index<2> idx,
> + int k)
> {
> - Point<2> offset;
> + Index<2> offset;
> index_type i = (idx[0]+offset[0])*extent[1] + (idx[1]+offset[1]);
> return static_cast<T>(k*i+1);
> }
>
>
> -
> template <dimension_type Dim,
> typename Block>
> void
> @@ -64,15 +68,14 @@
> {
> typedef typename Block::value_type value_type;
>
> - Point<Dim> ex = extent_old<Dim>(blk);
> - for (Point<Dim> idx; idx != ex; next(ex, idx))
> + Length<Dim> ex = extent<Dim>(blk);
> + for (Index<Dim> idx; valid(ex,idx); next(ex, idx))
> {
> put(blk, idx, identity<value_type>(ex, idx, k));
> }
> }
>
>
> -
> template <dimension_type Dim,
> typename Block>
> void
> @@ -80,16 +83,17 @@
> {
> typedef typename Block::value_type value_type;
>
> - Point<Dim> ex = extent_old<Dim>(blk);
> - for (Point<Dim> idx; idx != ex; next(ex, idx))
> + Length<Dim> ex = extent<Dim>(blk);
> + for (Index<Dim> idx; valid(ex,idx); next(ex, idx))
> {
> test_assert(equal( get(blk, idx),
> - identity<value_type>(ex, idx, k)));
> + identity<value_type>(ex, idx, k)));
> }
> }
>
>
>
> +
> template <dimension_type Dim,
> typename BlockT>
> void
> Index: tests/user_storage.cpp
> ===================================================================
> RCS file: /home/cvs/Repository/vpp/tests/user_storage.cpp,v
> retrieving revision 1.6
> diff -u -r1.6 user_storage.cpp
> --- tests/user_storage.cpp 20 Dec 2005 12:48:41 -0000 1.6
> +++ tests/user_storage.cpp 30 Mar 2006 17:00:12 -0000
> @@ -17,24 +17,24 @@
> #include <vsip/impl/point.hpp>
> #include <vsip/impl/point-fcn.hpp>
> #include <vsip/impl/domain-utils.hpp>
> +#include <vsip/impl/length.hpp>
> #include "test.hpp"
>
> using namespace std;
> using namespace vsip;
>
> -using vsip::impl::Point;
> +using vsip::impl::Length;
>
>
>
> /***********************************************************************
> Definitions
> ***********************************************************************/
> -
> template <typename Order,
> dimension_type Dim>
> index_type
> -to_index(Point<Dim> const& ext,
> - Point<Dim> const& idx)
> +to_index(Length<Dim> const& ext,
> + Index<Dim> const& idx)
> {
> if (Dim == 1)
> return idx[0];
> @@ -47,7 +47,6 @@
> }
>
>
> -
> template <typename Order,
> typename T,
> dimension_type Dim,
> @@ -58,8 +57,8 @@
> Domain<Dim> const& dom,
> Func fun)
> {
> - Point<Dim> ext = impl::extent_old(dom);
> - for (Point<Dim> idx; idx != ext; next(ext, idx))
> + Length<Dim> ext = impl::extent(dom);
> + for (Index<Dim> idx; valid(ext, idx); next(ext, idx))
> {
> index_type i = to_index<Order>(ext, idx);
> data[i] = fun(i);
> @@ -67,7 +66,6 @@
> }
>
>
> -
> template <typename Order,
> typename T,
> dimension_type Dim,
> @@ -78,8 +76,8 @@
> Domain<Dim> const& dom,
> Func fun)
> {
> - Point<Dim> ext = impl::extent_old(dom);
> - for (Point<Dim> idx; idx != ext; next(ext, idx))
> + Length<Dim> ext = impl::extent(dom);
> + for (Index<Dim> idx; valid(ext,idx); next(ext, idx))
> {
> index_type i = to_index<Order>(ext, idx);
> if (!equal(data[i], fun(i)))
> @@ -89,7 +87,6 @@
> }
>
>
> -
> template <typename Order,
> typename T,
> dimension_type Dim,
> @@ -100,8 +97,8 @@
> Domain<Dim> const& dom,
> Func fun)
> {
> - Point<Dim> ext = impl::extent_old(dom);
> - for (Point<Dim> idx; idx != ext; next(ext, idx))
> + Length<Dim> ext = impl::extent(dom);
> + for (Index<Dim> idx; valid(ext,idx); next(ext, idx))
> {
> index_type i = to_index<Order>(ext, idx);
> complex<T> val = fun(i);
> @@ -111,7 +108,6 @@
> }
>
>
> -
> template <typename Order,
> typename T,
> dimension_type Dim,
> @@ -122,8 +118,8 @@
> Domain<Dim> const& dom,
> Func fun)
> {
> - Point<Dim> ext = impl::extent_old(dom);
> - for (Point<Dim> idx; idx != ext; next(ext, idx))
> + Length<Dim> ext = impl::extent(dom);
> + for (Index<Dim> idx; valid(ext,idx); next(ext, idx))
> {
> index_type i = to_index<Order>(ext, idx);
> complex<T> val = fun(i);
> @@ -135,7 +131,6 @@
> }
>
>
> -
> template <typename Order,
> typename T,
> dimension_type Dim,
> @@ -147,8 +142,8 @@
> Domain<Dim> const& dom,
> Func fun)
> {
> - Point<Dim> ext = impl::extent_old(dom);
> - for (Point<Dim> idx; idx != ext; next(ext, idx))
> + Length<Dim> ext = impl::extent(dom);
> + for (Index<Dim> idx; valid(ext,idx); next(ext, idx))
> {
> index_type i = to_index<Order>(ext, idx);
> complex<T> val = fun(i);
> @@ -158,7 +153,6 @@
> }
>
>
> -
> template <typename Order,
> typename T,
> dimension_type Dim,
> @@ -170,8 +164,8 @@
> Domain<Dim> const& dom,
> Func fun)
> {
> - Point<Dim> ext = impl::extent_old(dom);
> - for (Point<Dim> idx; idx != ext; next(ext, idx))
> + Length<Dim> ext = impl::extent(dom);
> + for (Index<Dim> idx; valid(ext,idx); next(ext, idx))
> {
> index_type i = to_index<Order>(ext, idx);
> complex<T> val = fun(i);
> @@ -182,8 +176,6 @@
> return true;
> }
>
> -
> -
> template <typename Order,
> typename Block,
> dimension_type Dim,
> @@ -194,16 +186,14 @@
> Domain<Dim> const& dom,
> Func fun)
> {
> - Point<Dim> ext = impl::extent_old(dom);
> - for (Point<Dim> idx; idx != ext; next(ext, idx))
> + Length<Dim> ext = impl::extent(dom);
> + for (Index<Dim> idx; valid(ext,idx); next(ext, idx))
> {
> index_type i = to_index<Order>(ext, idx);
> put(block, idx, fun(i));
> }
> }
>
> -
> -
> template <typename Order,
> typename Block,
> dimension_type Dim,
> @@ -214,8 +204,8 @@
> Domain<Dim> const& dom,
> Func fun)
> {
> - Point<Dim> ext = impl::extent_old(dom);
> - for (Point<Dim> idx; idx != ext; next(ext, idx))
> + Length<Dim> ext = impl::extent(dom);
> + for (Index<Dim> idx; valid(ext,idx); next(ext, idx))
> {
> index_type i = to_index<Order>(ext, idx);
> if (!equal(get(block, idx), fun(i)))
> @@ -224,7 +214,6 @@
> return true;
> }
>
> -
> template <typename T>
> class Filler
> {
> Index: tests/util-par.hpp
> ===================================================================
> RCS file: /home/cvs/Repository/vpp/tests/util-par.hpp,v
> retrieving revision 1.8
> diff -u -r1.8 util-par.hpp
> --- tests/util-par.hpp 27 Mar 2006 23:19:34 -0000 1.8
> +++ tests/util-par.hpp 30 Mar 2006 17:00:12 -0000
> @@ -20,6 +20,7 @@
> #include <vsip/vector.hpp>
> #include <vsip/matrix.hpp>
> #include <vsip/parallel.hpp>
> +#include <vsip/domain.hpp>
>
> #include "output.hpp"
> #include "extdata-output.hpp"
> @@ -276,8 +277,8 @@
> Increment(T delta) : delta_(delta) {}
>
> T operator()(T value,
> - vsip::impl::Point<Dim> const&,
> - vsip::impl::Point<Dim> const&)
> + vsip::Index<Dim> const&,
> + vsip::Index<Dim> const&)
> { return value + delta_; }
>
> // Member Data
> @@ -294,19 +295,22 @@
> class Set_identity
> {
> public:
> + // The Set_identity () operators used to take Point as their argument. The
> + // use of Point is depricated. We need to use Index instead.
> +
> Set_identity(vsip::Domain<Dim> const& dom, int k = 1, int o = 0)
> : dom_(dom), k_(k), o_(o) {}
>
> template <typename T>
> T operator()(T /*value*/,
> - vsip::impl::Point<1> const& /*local*/,
> - vsip::impl::Point<1> const& global)
> + vsip::Index<1> const& /*local*/,
> + vsip::Index<1> const& global)
> { return T(k_*global[0] + o_); }
>
> template <typename T>
> T operator()(T /*value*/,
> - vsip::impl::Point<2> const& /*local*/,
> - vsip::impl::Point<2> const& global)
> + vsip::Index<2> const& /*local*/,
> + vsip::Index<2> const& global)
> {
> vsip::index_type i = global[0]*dom_[1].length()+global[1];
> return T(k_*i+o_);
> @@ -314,8 +318,8 @@
>
> template <typename T>
> T operator()(T /*value*/,
> - vsip::impl::Point<3> const& /*local*/,
> - vsip::impl::Point<3> const& global)
> + vsip::Index<3> const& /*local*/,
> + vsip::Index<3> const& global)
> {
> vsip::index_type i = global[0]*dom_[1].length()*dom_[2].length()
> + global[1]*dom_[2].length()
> @@ -343,10 +347,14 @@
>
> bool good() { return good_; }
>
> + // The Check_identity () operators used to take Point as their argument. The
> + // use of Point is depricated. We need to use Index instead.
> +
> +
> template <typename T>
> T operator()(T value,
> - vsip::impl::Point<1> const& /*local*/,
> - vsip::impl::Point<1> const& global)
> + vsip::Index<1> const& /*local*/,
> + vsip::Index<1> const& global)
> {
> int i = global[0];
> T expected = T(k_*i + o_);
> @@ -363,8 +371,8 @@
>
> template <typename T>
> T operator()(T value,
> - vsip::impl::Point<2> const& /*local*/,
> - vsip::impl::Point<2> const& global)
> + vsip::Index<2> const& /*local*/,
> + vsip::Index<2> const& global)
> {
> int i = global[0]*dom_[1].length()+global[1];
> T expected = T(k_*i+o_);
> @@ -383,8 +391,8 @@
>
> template <typename T>
> T operator()(T value,
> - vsip::impl::Point<3> const& /*local*/,
> - vsip::impl::Point<3> const& global)
> + vsip::Index<3> const& /*local*/,
> + vsip::Index<3> const& global)
> {
> int i = global[0]*dom_[1].length()*dom_[2].length()
> + global[1]*dom_[2].length()
> Index: tests/view.cpp
> ===================================================================
> RCS file: /home/cvs/Repository/vpp/tests/view.cpp,v
> retrieving revision 1.10
> diff -u -r1.10 view.cpp
> --- tests/view.cpp 20 Dec 2005 12:48:41 -0000 1.10
> +++ tests/view.cpp 30 Mar 2006 17:00:12 -0000
> @@ -23,14 +23,14 @@
> #include <vsip/impl/point.hpp>
> #include <vsip/domain.hpp>
> #include <vsip/impl/point-fcn.hpp>
> +#include <vsip/impl/length.hpp>
> #include "test.hpp"
> #include "test-storage.hpp"
>
> using namespace std;
> using namespace vsip;
>
> -using vsip::impl::Point;
> -using vsip::impl::extent_old;
> +using vsip::impl::Length;
>
>
>
> @@ -348,6 +348,9 @@
>
> // Check that all elements of a view have the same const values
>
> +// The use of Point is depricated. This function was converted to use Length
> +// and index instead.
> +
> template <typename View>
> bool
> check_view_const(
> @@ -355,7 +358,8 @@
> typename View::value_type scalar)
> {
> dimension_type const dim = View::dim;
> - for (Point<dim> idx; idx != extent_old(view); next(extent_old(view), idx))
> + Length<dim> ext = extent(view);
> + for (Index<dim> idx; valid(ext,idx); next(ext, idx))
> {
> if (!equal(get(view, idx), scalar))
> return false;
> Index: tests/vmmul.cpp
> ===================================================================
> RCS file: /home/cvs/Repository/vpp/tests/vmmul.cpp,v
> retrieving revision 1.4
> diff -u -r1.4 vmmul.cpp
> --- tests/vmmul.cpp 20 Dec 2005 12:48:41 -0000 1.4
> +++ tests/vmmul.cpp 30 Mar 2006 17:00:12 -0000
> @@ -19,6 +19,7 @@
> #include <vsip/map.hpp>
> #include <vsip/parallel.hpp>
> #include <vsip/math.hpp>
> +#include <vsip/domain.hpp>
>
> #include "test.hpp"
> #include "util-par.hpp"
> @@ -87,8 +88,8 @@
>
> template <typename T>
> T operator()(T value,
> - vsip::impl::Point<2> const& /*local*/,
> - vsip::impl::Point<2> const& global)
> + vsip::Index<2> const& /*local*/,
> + vsip::Index<2> const& global)
> {
> vsip::index_type i = global[0]*dom_[1].length()+global[1];
> T expected = (VecDim == 0) ? T(global[1] * i) : T(global[0] * i);
--
Jules Bergmann
CodeSourcery
jules at codesourcery.com
(650) 331-3385 x705
More information about the vsipl++
mailing list