- Olena-patches

proto-1.0 127: Extend mlc/bool.hh.
by Thierry GERAUD 08 Apr '05

08 Apr '05

2005-04-08 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> * mlc/bool.hh: Extend. Index: mlc/bool.hh =================================================================== --- mlc/bool.hh (revision 125) +++ mlc/bool.hh (working copy) @@ -85,10 +85,12 @@ /// Logical binary operators between a couple of Boolean types - template <typename L, typename R> struct and_ : public value <bool, (L::b && R::b)> {}; - template <typename L, typename R> struct or_ : public value <bool, (L::b || R::b)> {}; - template <typename L, typename R> struct nand_ : public value <bool, (L::b && !R::b)> {}; - template <typename L, typename R> struct xor_ : public value <bool, ((L::b && !R::b) || (!L::b && R::b))> {}; + template <typename L, typename R> struct and_ : public value <bool, (L::b && R::b) > {}; + template <typename L, typename R> struct nand_ : public value <bool, (!(L::b && R::b))> {}; + template <typename L, typename R> struct or_ : public value <bool, (L::b || R::b) > {}; + template <typename L, typename R> struct nor_ : public value <bool, (!(L::b || R::b))> {}; + template <typename L, typename R> struct xor_ : public value <bool, (L::b != R::b) > {}; + template <typename L, typename R> struct xnor_ : public value <bool, (!(L::b != R::b))> {}; } // end of namespace mlc

1 0

proto-1.0 126: Add to ntg a file with fwd-decls
by Thierry GERAUD 08 Apr '05

08 Apr '05

2005-04-08 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> * ntg/decls.hh: New file. Index: ntg/decls.hh =================================================================== --- ntg/decls.hh (revision 0) +++ ntg/decls.hh (revision 0) @@ -0,0 +1,63 @@ +// Copyright (C) 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef NTG_DECLS_HH +# define NTG_DECLS_HH + +# include <ntg/vect/cplx_representation.hh> + + +namespace ntg +{ + + // abstract classes + template <typename E> class value; + template <typename E> class enum_value; + template <typename E> class real_value; + template <typename E> class float_value; + template <typename E> class int_value; + template <typename E> class uint_value; + template <typename E> class sint_value; + template <typename E> class vect_value; + template <unsigned N, class T, class E> class vec; + template <typename E> class color_value; + + // concrete classes + class bin; + template <unsigned nbits, class behavior> class int_u; + template <unsigned nbits, class behavior> class int_s; + template <class T, class interval> class cycle; + template <class T, class interval, class behavior> class range; + template <cplx_representation R, class T> class cplx; + template <unsigned ncomps, unsigned qbits, + template <unsigned> class color_system> struct color; + +} // end of namespace ntg + + +#endif // ! NTG_DECLS_HH +

1 0

proto-1.0 125: Add neighborhood iterator.
by Nicolas Widynski 06 Apr '05

06 Apr '05

Index: ChangeLog from Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> * oln/core/abstract/niter.hh: New. Abstract neighborhood iterator class. * oln/core/abstract/regular_niter.hh: New. Abstract neighborhood iterator for windows. * oln/core/2d/fwd_regular_niter2d.hh: New. Concrete 2d neighborhood class 2d/fwd_regular_niter2d.hh | 138 +++++++++++++++++++++++++++++++++++++++ abstract/niter.hh | 159 ++++++++++++++++++++++++++++++++++++++++++++++ abstract/regular_niter.hh | 138 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 435 insertions(+) Index: oln/core/abstract/niter.hh --- oln/core/abstract/niter.hh (revision 0) +++ oln/core/abstract/niter.hh (revision 0) @@ -0,0 +1,159 @@ +// Copyright (C) 2001, 2002, 2003, 2004, 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_CORE_ABSTRACT_NITER_HH +# define OLENA_CORE_ABSTRACT_NITER_HH + +# include <vector> + +# include <mlc/any.hh> +# include <mlc/types.hh> +# include <mlc/contract.hh> + +# include <oln/core/gen/image_with_nbh.hh> +# include <oln/core/abstract/point.hh> +# include <oln/core/properties.hh> +# include <oln/core/abstract/image.hh> +# include <oln/core/abstract/neighborhood.hh> +# include <oln/core/abstract/image_neighbness.hh> + + +# define for_all_n(n) \ + for(n.start(); n.is_valid(); n.next()) + +# define for_all_remaining_n(n) \ + for(; n.is_valid(); n.next()) + + +// FIXME : bad place +# include <oln/core/abstract/piter.hh> + +# define for_all_n_of_p(p, n) \ + for(p.start(); p.is_valid(); p.next()) \ + for(n.center_at(p), n.start(); n.is_valid(); n.next()) + +namespace oln { + + // fwd decl + namespace abstract { + template <typename E> struct niter; + } + + // category + template <typename E> + struct set_category< abstract::niter<E> > { typedef category::niter ret; }; + + + /// properties of any type in category::niter + + template <typename type> + struct props_of < category::niter, type > + { + typedef mlc::true_type user_defined_; + + mlc_decl_prop(category::niter, point_type); + mlc_decl_prop(category::niter, dpoint_type); + mlc_decl_prop(category::niter, neighb_type); + mlc_decl_prop(category::niter, image_type); + + static void echo(std::ostream& ostr) + { + ostr << "props_of( category::niter, " + << typeid(type).name() << ") = {" + << " neighb_type = " << typeid(neighb_type).name() + << " image_type = " << typeid(image_type).name() + << " point_type = " << typeid(point_type).name() << " }" << std::endl; + } + + }; + + mlc_register_prop(category::niter, neighb_type); + mlc_register_prop(category::niter, point_type); + mlc_register_prop(category::niter, dpoint_type); + mlc_register_prop(category::niter, image_type); + + + namespace abstract { + + template <typename E> + struct niter : public mlc::any__best_speed<E> + { + + /// typedefs + + typedef niter<E> self_type; + + typedef oln_type_of(E, point) point_type; + typedef oln_type_of(E, neighb) neighb_type; + typedef oln_type_of(E, image) image_type; + + void start() + { + this->exact().impl_start(); + } + + void next() + { + this->exact().impl_next(); + } + + operator point_type() const + { + return this->exact().impl_cast_point(); + } + + void center_at(const point_type& pt) + { + this->exact().impl_center_at(pt); + } + + bool is_valid() const + { + return this->exact().impl_is_valid(); + } + + void invalidate() + { + return this->exact().impl_invalidate(); + } + + protected: + + template <typename T> + niter(const abstract::image_with_nbh<T>& ima) : + p_(), nbh_(ima.nbh_get()) + { + } + + point_type p_; + const neighb_type& nbh_; + }; + } +} + + +#endif // ! OLENA_CORE_ABSTRACT_NITER_HH Index: oln/core/abstract/regular_niter.hh --- oln/core/abstract/regular_niter.hh (revision 0) +++ oln/core/abstract/regular_niter.hh (revision 0) @@ -0,0 +1,138 @@ +// Copyright (C) 2001, 2002, 2003, 2004, 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_CORE_ABSTRACT_REGULAR_NITER_HH +# define OLENA_CORE_ABSTRACT_REGULAR_NITER_HH + +# include <vector> + +# include <mlc/any.hh> +# include <mlc/types.hh> +# include <mlc/contract.hh> + +# include <oln/core/abstract/niter.hh> +# include <oln/core/gen/image_with_nbh.hh> +# include <oln/core/abstract/point.hh> +# include <oln/core/abstract/dpoint.hh> +# include <oln/core/properties.hh> +# include <oln/core/abstract/image.hh> +# include <oln/core/abstract/neighborhood.hh> +# include <oln/core/abstract/image_neighbness.hh> + + +namespace oln { + + // fwd decls + + namespace abstract { + template <typename E> struct regular_niter; + } + + // category + + template <typename E> + struct set_category< abstract::regular_niter<E> > { + typedef category::niter ret; + }; + + // super type + + template <typename E> + struct set_super_type < abstract::regular_niter<E> > + { + typedef abstract::niter<E> ret; + }; + + + namespace abstract { + + template <typename E> + struct regular_niter : public niter<E> + { + + /// typedefs + typedef oln_type_of(E, point) point_type; + typedef oln_type_of(E, dpoint) dpoint_type; + typedef regular_niter<E> self_type; + + void impl_start() + { + dp_cur_ = dp_.begin(); + } + + void impl_next() + { + precondition(this->is_valid()); + dp_cur_ ++; + } + + void impl_center_at(const point_type& pt) + { + this->p_ = pt; + dp_.clear(); + this->exact().impl_determine_neighb(); + } + + bool impl_is_valid() const + { + return dp_cur_ != dp_.end(); + } + + const point_type impl_cast_point() const + { + precondition(this->is_valid()); + return *dp_cur_ + this->p_; + } + + void impl_invalidate() + { + dp_cur_ = dp_.end(); + postcondition(! this->is_valid()); + } + + protected: + + void impl_determine_neighb() + { + for (unsigned i = 0; i < this->nbh_.card(); ++i) + dp_.push_back(this->nbh_[i]); + } + + template <typename T> + regular_niter(const abstract::image_with_nbh<T>& ima) : + niter<E>(ima) + { + } + + typename std::vector<dpoint_type>::iterator dp_cur_; + std::vector<dpoint_type> dp_; + }; + } +} + + +#endif // ! OLENA_CORE_ABSTRACT_REGULAR_NITER_HH Index: oln/core/2d/fwd_regular_niter2d.hh --- oln/core/2d/fwd_regular_niter2d.hh (revision 0) +++ oln/core/2d/fwd_regular_niter2d.hh (revision 0) @@ -0,0 +1,138 @@ +// Copyright (C) 2001, 2002, 2003, 2004, 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_CORE_ABSTRACT_REGULAR_NITER_HH +# define OLENA_CORE_ABSTRACT_REGULAR_NITER_HH + +# include <vector> + +# include <mlc/any.hh> +# include <mlc/types.hh> +# include <mlc/contract.hh> + +# include <oln/core/abstract/niter.hh> +# include <oln/core/gen/image_with_nbh.hh> +# include <oln/core/abstract/point.hh> +# include <oln/core/abstract/dpoint.hh> +# include <oln/core/properties.hh> +# include <oln/core/abstract/image.hh> +# include <oln/core/abstract/neighborhood.hh> +# include <oln/core/abstract/image_neighbness.hh> + + +namespace oln { + + // fwd decls + + namespace abstract { + template <typename E> struct regular_niter; + } + + // category + + template <typename E> + struct set_category< abstract::regular_niter<E> > { + typedef category::niter ret; + }; + + // super type + + template <typename E> + struct set_super_type < abstract::regular_niter<E> > + { + typedef abstract::niter<E> ret; + }; + + + namespace abstract { + + template <typename E> + struct regular_niter : public niter<E> + { + + /// typedefs + typedef oln_type_of(E, point) point_type; + typedef oln_type_of(E, dpoint) dpoint_type; + typedef regular_niter<E> self_type; + + void impl_start() + { + dp_cur_ = dp_.begin(); + } + + void impl_next() + { + precondition(this->is_valid()); + dp_cur_ ++; + } + + void impl_center_at(const point_type& pt) + { + this->p_ = pt; + dp_.clear(); + this->exact().impl_determine_neighb(); + } + + bool impl_is_valid() const + { + return dp_cur_ != dp_.end(); + } + + const point_type impl_cast_point() const + { + precondition(this->is_valid()); + return *dp_cur_ + this->p_; + } + + void impl_invalidate() + { + dp_cur_ = dp_.end(); + postcondition(! this->is_valid()); + } + + protected: + + void impl_determine_neighb() + { + for (unsigned i = 0; i < this->nbh_.card(); ++i) + dp_.push_back(this->nbh_[i]); + } + + template <typename T> + regular_niter(const abstract::image_with_nbh<T>& ima) : + niter<E>(ima) + { + } + + typename std::vector<dpoint_type>::iterator dp_cur_; + std::vector<dpoint_type> dp_; + }; + } +} + + +#endif // ! OLENA_CORE_ABSTRACT_REGULAR_NITER_HH

1 0

proto-1.0 124: Add neighborhood hierarchy.
by Nicolas Widynski 06 Apr '05

06 Apr '05

Index: ChangeLog from Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> * oln/core/properties.hh: Change properties for neighborhood hierarchy. * oln/core/abstract/image.hh: Add neigbh_type property. * oln/core/abstract/image_neighbness.hh: New. Add neighborhood hierarchy. * oln/core/abstract/entry.hh: Add image_neighbness into hierarchy. * oln/core/abstract/image_with_extension.hh: New. Add image with extension hierarchy. * oln/core/gen/image_with_nbh.hh: New. Concrete image and neighborhood class. abstract/entry.hh | 4 - abstract/image.hh | 8 ++ abstract/image_neighbness.hh | 76 +++++++++++++++++++++++++ abstract/image_with_extension.hh | 118 +++++++++++++++++++++++++++++++++++++++ gen/image_with_nbh.hh | 110 ++++++++++++++++++++++++++++++++++++ properties.hh | 3 6 files changed, 318 insertions(+), 1 deletion(-) Index: oln/core/properties.hh --- oln/core/properties.hh (revision 123) +++ oln/core/properties.hh (working copy) @@ -55,9 +55,11 @@ { struct data_type; struct value_type; + struct neighb_type; struct value_storage_type; struct storage_type; struct point_type; + struct image_type; struct concrete_type; struct dpoint_type; struct piter_type; @@ -70,6 +72,7 @@ struct se_type; struct window_type; + struct image_neighbness_type; struct image_constness_type; struct image_dimension_type; struct image_vectorialness_type; Index: oln/core/abstract/image.hh --- oln/core/abstract/image.hh (revision 123) +++ oln/core/abstract/image.hh (working copy) @@ -45,6 +45,7 @@ namespace abstract { template <typename E> struct image; template <typename E> struct readonly_image; + template <typename E> struct image_without_nbh; } // category @@ -70,7 +71,10 @@ mlc_decl_prop_with_default(category::image, value_storage_type, mlc::no_type); mlc_decl_prop_with_default(category::image, storage_type, mlc::no_type); mlc_decl_prop_with_default(category::image, delegated_type, mlc::no_type); + mlc_decl_prop_with_default(category::image, neighb_type, mlc::no_type); + + mlc_decl_prop_with_default(category::image, image_neighbness_type, is_a<abstract::image_without_nbh>); mlc_decl_prop_with_default(category::image, image_constness_type, is_a<abstract::readonly_image>); mlc_decl_prop(category::image, image_dimension_type); mlc_decl_prop(category::image, image_vectorialness_type); @@ -83,6 +87,7 @@ << ", " << typeid(type).name() << ") = {" << " concrete_type = " << typeid(concrete_type).name() << " value_type = " << typeid(value_type).name() + << " neighb_type = " << typeid(neighb_type).name() << " point_type = " << typeid(point_type).name() << " size_type = " << typeid(size_type).name() << " fwd_piter_type = " << typeid(fwd_piter_type).name() @@ -93,12 +98,14 @@ << " image_constness_type = " << typeid(image_constness_type).name() << " image_dimension_type = " << typeid(image_dimension_type).name() << " image_vectorialness_type = " << typeid(image_vectorialness_type).name() + << " image_neighbness_type = " << typeid(image_neighbness_type).name() << " }" << std::endl; } }; + mlc_register_prop(category::image, neighb_type); mlc_register_prop(category::image, concrete_type); mlc_register_prop(category::image, value_type); mlc_register_prop(category::image, point_type); @@ -113,6 +120,7 @@ mlc_register_prop(category::image, image_constness_type); mlc_register_prop(category::image, image_dimension_type); mlc_register_prop(category::image, image_vectorialness_type); + mlc_register_prop(category::image, image_neighbness_type); Index: oln/core/abstract/image_neighbness.hh --- oln/core/abstract/image_neighbness.hh (revision 0) +++ oln/core/abstract/image_neighbness.hh (revision 0) @@ -0,0 +1,76 @@ +// Copyright (C) 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_CORE_ABSTRACT_IMAGE_NEIGHBNESS_HH +# define OLENA_CORE_ABSTRACT_IMAGE_NEIGHBNESS_HH + +# include <mlc/bool.hh> + +# include <ntg/basics.hh> + +# include <oln/core/abstract/image.hh> + +/*! \namespace oln +** \brief oln namespace. +*/ +namespace oln { + + /*! \namespace oln::abstract + ** \brief oln::abstract namespace. + */ + namespace abstract { + + + template <typename E> + struct image_with_nbh : public virtual image<E> + { + public: + + typedef oln_type_of(E, neighb) neighb_type; + + const neighb_type& nbh_get() const + { + return this->exact().impl_nbh_get(); + } + + protected: + image_with_nbh() {} + }; + + template <typename E> + struct image_without_nbh : public virtual image<E> + { + protected: + image_without_nbh() {} + }; + + + } // end of namespace oln::abstract + +} // end of namespace oln + +#endif // ! OLENA_CORE_ABSTRACT_IMAGE_NEIGHBNESS_HH Index: oln/core/abstract/entry.hh --- oln/core/abstract/entry.hh (revision 123) +++ oln/core/abstract/entry.hh (working copy) @@ -31,6 +31,7 @@ # include <oln/core/abstract/image_constness.hh> # include <oln/core/abstract/image_dimension.hh> # include <oln/core/abstract/image_vectorialness.hh> +# include <oln/core/abstract/image_neighbness.hh> // FIXME: this file should move to oln/core/abstract/ @@ -70,8 +71,9 @@ // intrusive: public oln_type_of_(E, image_constness) ::template instantiated_with<E>::ret, public oln_type_of_(E, image_dimension) ::template instantiated_with<E>::ret, + public oln_type_of_(E, image_neighbness) ::template instantiated_with<E>::ret, public oln_type_of_(E, image_vectorialness) ::template instantiated_with<E>::ret - // ... + // ... { protected: image_entry() {} Index: oln/core/abstract/image_with_extension.hh --- oln/core/abstract/image_with_extension.hh (revision 0) +++ oln/core/abstract/image_with_extension.hh (revision 0) @@ -0,0 +1,118 @@ +// Copyright (C) 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_CORE_ABSTRACT_IMAGE_WITH_EXTENSION__HH +# define OLENA_CORE_ABSTRACT_IMAGE_WITH_EXTENSION__HH + +# include <oln/core/abstract/image_by_delegation.hh> + + +namespace oln { + + + // fwd decl + namespace abstract { + template <typename I, typename E> struct image_with_extension_; + } + + // category + + template <typename I, typename E> + struct set_category< abstract::image_with_extension_<I, E> > { + typedef category::image ret; + }; + + // super type + + template <typename I, typename E> + struct set_super_type < abstract::image_with_extension_<I, E> > + { + typedef abstract::image_by_delegation<I, E> ret; + }; + + // props + + template <typename I, typename E> + struct set_props < category::image, abstract::image_with_extension_<I, E> > : public props_of<category::image> + { + typedef oln_type_of(I, concrete) concrete_type; + }; + + + namespace abstract { + + /// Mutable version of image_with_extension_. + + template <typename I, typename E> + struct image_with_extension_ : public image_by_delegation<I, E> + { + typedef image_by_delegation<I, E> super_type; + + public: + + image_with_extension_ () + { + } + + image_with_extension_(abstract::image& image) : + super_type(image) + { + } + + const I& real() const + { + return this->image_.unbox(); + } + + I& real() + { + return this->image_.unbox(); + } + + ~image_with_extension_ () + { + // FIXME : This class must check all properties + +// mlc_or( mlc_eq(oln_type_of(I,neighb_type), mlc::no_type), +// mlc_eq(oln_type_of(I,neighb_type), oln_type_of(E,neighb_type)) +// )::ensure(); + + // if (Prop(I) != no_type) + // Prop(E) = Prop(I) + } + + + }; + + } // end of namespace oln::abstract + + + +} // end of namespace oln + + +#endif // ! OLENA_CORE_ABSTRACT_IMAGE_WITH_EXTENSION__HH Index: oln/core/gen/image_with_nbh.hh --- oln/core/gen/image_with_nbh.hh (revision 0) +++ oln/core/gen/image_with_nbh.hh (revision 0) @@ -0,0 +1,110 @@ +// Copyright (C) 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_CORE_GEN_IMAGE_WITH_NBH_HH +# define OLENA_CORE_GEN_IMAGE_WITH_NBH_HH + +# include <oln/core/abstract/image_with_extension.hh> +# include <oln/core/abstract/image.hh> +# include <oln/core/abstract/neighborhood.hh> +# include <oln/core/properties.hh> + +namespace oln { + + // fwd decls + + namespace internal { + template <typename I, typename N> struct image_with_nbh; + } + + // category + + template <typename I, typename N> + struct set_category< internal::image_with_nbh<I, N> > { + typedef category::image ret; + }; + + // super type + + template <typename I, typename N> + struct set_super_type < internal::image_with_nbh<I, N> > + { + typedef abstract::image_with_extension_ < I, internal::image_with_nbh<I, N> > ret; + }; + + template <typename I, typename N> + struct set_props < category::image, internal::image_with_nbh<I, N> > : public props_of<category::image> + { + typedef is_a<abstract::image_with_nbh> image_neighbness_type; + typedef N neighb_type; + }; + + namespace internal + { + + template <typename I, typename N> + struct image_with_nbh : public oln::abstract::image_with_extension_ < I, image_with_nbh<I, N> > + { + typedef image_with_nbh<I, N> self_type; + typedef oln::abstract::image_with_extension_ < I, self_type > super_type; + + public: + + image_with_nbh(abstract::image& rhs, + abstract::neighborhood<N>& nbh) : + super_type(rhs), nbh_(nbh.exact()) + { + } + + const N& impl_nbh_get() const + { + return nbh_; + } + + protected: + N& nbh_; + }; + + } // end of namespace oln::internal + + + + /// the 'image_with_nbh' method for images + + template <typename I, typename N> + internal::image_with_nbh<I, N> + join(abstract::image& ima, + abstract::neighborhood<N>& nbh) + { + internal::image_with_nbh<I, N> tmp(ima, nbh); + return tmp; + } + +} // end of namespace oln + + +#endif // ! OLENA_CORE_GEN_IMAGE_WITH_NBH_HH

1 0

proto-1.0 123: Fix value_box cmp ops.
by Thierry GERAUD 06 Apr '05

06 Apr '05

2005-04-06 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> * oln/core/value_box.hh: Fix. Index: oln/core/value_box.hh =================================================================== --- oln/core/value_box.hh (revision 122) +++ oln/core/value_box.hh (working copy) @@ -29,7 +29,6 @@ # define OLENA_CORE_VALUE_BOX_HH # include <iostream> - # include <oln/core/properties.hh> @@ -79,58 +78,42 @@ typedef oln_type_of(I, point) point_type; - /// op== - - bool operator==(const value_box& rhs) const - { - return this->value() == rhs.value(); - } - + /// Operator == (rhs is a value_box). template <typename II> bool operator==(const value_box<II>& rhs) const { - return this->value() < rhs.value(); + return this->value() == rhs.value(); } + /// Operator == (rhs is a value). template <typename V> bool operator==(const V& rhs) const { return this->value() == rhs; } + /// Operator !=. template <typename V> bool operator!=(const V& rhs) const { return ! this->operator==(rhs); } - /*! \brief operator < - ** - ** Define the main comparison operator for value_box. <= >= and > - ** are computed using integre operators \see ntg/core/global_ops.hh:138. - */ - - template <typename V> - bool operator<(const V& rhs) const - { - return this->value() < rhs; - } - + /// Operator < (rhs is a value_box). template <typename II> bool operator<(const value_box<II>& rhs) const { return this->value() < rhs.value(); } - /*! \brief specialized version for value_box - ** - ** FIXME: why do we need this class ??? - */ - bool operator<(const value_box& rhs) const + /// Operator < (rhs is a value). + template <typename V> + bool operator<(const V& rhs) const { - return this->value() < rhs.value(); + return this->value() < rhs; } + /*! \brief op= ** FIXME:... ** \return (*this) @@ -277,47 +260,42 @@ typedef oln_type_of(I, point) point_type; - /// op== - bool operator==(const value_box<const I>& rhs) const + /// Operator == (rhs is a value_box). + template <typename II> + bool operator==(const value_box<II>& rhs) const { return this->value() == rhs.value(); } - template <typename II> - bool operator==(const value_box<const II>& rhs) const - { - return this->value() < rhs.value(); - } - + /// Operator == (rhs is a value). template <typename V> bool operator==(const V& rhs) const { return this->value() == rhs; } + /// Operator !=. template <typename V> bool operator!=(const V& rhs) const { return ! this->operator==(rhs); } - template <typename V> - bool operator<(const V& rhs) const - { - return this->value() < rhs; - } - + /// Operator < (rhs is a value_box). template <typename II> - bool operator<(const value_box<const II>& rhs) const + bool operator<(const value_box<II>& rhs) const { return this->value() < rhs.value(); } - bool operator<(const value_box<const I>& rhs) const + /// Operator < (rhs is a value). + template <typename V> + bool operator<(const V& rhs) const { - return this->value() < rhs.value(); + return this->value() < rhs; } + /*! \brief Assignment (op=) is declared but undefined. */ @@ -400,7 +378,7 @@ } // end of namespace oln - +/// Operator <<. template <typename I> std::ostream& operator<<(std::ostream& ostr, const oln::value_box& vb) { @@ -408,5 +386,4 @@ } - #endif // ! OLENA_CORE_VALUE_BOX_HH

1 0

proto-1.0 122: Conform to mlc.
by Thierry GERAUD 06 Apr '05

06 Apr '05

2005-04-06 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> * oln/core/abstract/image_vectorialness.hh: Conform to mlc. Index: oln/core/abstract/image_vectorialness.hh =================================================================== --- oln/core/abstract/image_vectorialness.hh (revision 121) +++ oln/core/abstract/image_vectorialness.hh (working copy) @@ -93,19 +93,19 @@ { typedef typename mlc::bool_switch_< - mlc::bool_case_<ntg_is_a(T, ntg::binary)::ret, + mlc::bool_case_<ntg_is_a(T, ntg::binary)::val, is_a<abstract::binary_image>, - mlc::bool_case_<ntg_is_a(T, ntg::integer)::ret, + mlc::bool_case_<ntg_is_a(T, ntg::integer)::val, is_a<abstract::integer_image>, - mlc::bool_case_<ntg_is_a(T, ntg::decimal)::ret, + mlc::bool_case_<ntg_is_a(T, ntg::decimal)::val, is_a<abstract::decimal_image>, - mlc::bool_case_<ntg_is_a(T, ntg::vectorial)::ret, + mlc::bool_case_<ntg_is_a(T, ntg::vectorial)::val, is_a<abstract::vectorial_image>, - mlc::bool_case_<ntg_is_a(T, ntg::non_vectorial)::ret, + mlc::bool_case_<ntg_is_a(T, ntg::non_vectorial)::val, is_a<abstract::non_vectorial_image>, mlc::bool_case_<true,

1 0

proto-1.0 121: Fix bugs.
by Thierry GERAUD 06 Apr '05

06 Apr '05

2005-04-06 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> * mlc/int.hh: Remove (redundant with mlc/arith.hh). * mlc/fun.hh: Add fwd decls for std::unary_function and std::binary_function. Index: mlc/fun.hh =================================================================== --- mlc/fun.hh (revision 120) +++ mlc/fun.hh (working copy) @@ -30,6 +30,15 @@ # include <mlc/any.hh> + +// fwd decls +namespace std { + template <class Arg, class Ret> struct unary_function; + template <class Arg1, class Arg2, class Ret> struct binary_function; +} + + + namespace mlc { @@ -45,7 +54,7 @@ namespace abstract { template <typename E> - class unary_function : public mlc::any__best_memory<E> + class unary_function : public mlc::any<E> { public: typedef E exact_type; @@ -71,7 +80,7 @@ // FIXME: Add meta_unary_function. template <typename E> - class binary_function : public mlc::any__best_memory<E> + class binary_function : public mlc::any<E> { public: typedef E exact_type; Index: mlc/int.hh =================================================================== --- mlc/int.hh (revision 120) +++ mlc/int.hh (working copy) @@ -1,62 +0,0 @@ -// Copyright (C) 2001, 2002, 2003, 2004, 2005 EPITA Research and Development Laboratory -// -// This file is part of the Olena Library. This library is free -// software; you can redistribute it and/or modify it under the terms -// of the GNU General Public License version 2 as published by the -// Free Software Foundation. -// -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with this library; see the file COPYING. If not, write to -// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, -// MA 02111-1307, USA. -// -// As a special exception, you may use this file as part of a free -// software library without restriction. Specifically, if other files -// instantiate templates or use macros or inline functions from this -// file, or you compile this file and link it with other files to -// produce an executable, this file does not by itself cause the -// resulting executable to be covered by the GNU General Public -// License. This exception does not however invalidate any other -// reasons why the executable file might be covered by the GNU General -// Public License. - -#ifndef METALIC_ARITH_HH -# define METALIC_ARITH_HH - -# include <mlc/bool.hh> - - - -namespace mlc -{ - - namespace arith { - - template <typename T, T i, T j> struct eq : public value <bool, (i == j)> {}; - template <typename T, T i, T j> struct neq : public value <bool, (i != j)> {}; - - template <typename T, T i, T j> struct less : public value <bool, (i < j)> {}; - template <typename T, T i, T j> struct leq : public value <bool, (i <= j)> {}; - - template <typename T, T i, T j> struct greater : public value <bool, (i > j)> {}; - template <typename T, T i, T j> struct geq : public value <bool, (i >= j)> {}; - - template <typename T, T i, T j> struct min : public value<T, (i < j ? i : j)> {}; - template <typename T, T i, T j> struct max : public value<T, (i > j ? i : j)> {}; - - template <typename T, T i, T j, T N> struct maxN : public value<T, (i > j ? - (i > N ? N : i) : - (j > N ? N : j))> {}; - template <typename T, T i, T N> struct saturateN : public value<T, (i > N ? N : i)> {}; - - } // end of namespace mlc::arith - -} // end of namespace mlc - - -#endif // ! METALIC_ARITH_HH

1 0

proto-1.0 120: Add static arithmetics.
by Thierry GERAUD 06 Apr '05

06 Apr '05

2005-04-06 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> * mlc/int.hh: New file. Index: mlc/int.hh =================================================================== --- mlc/int.hh (revision 0) +++ mlc/int.hh (revision 0) @@ -0,0 +1,62 @@ +// Copyright (C) 2001, 2002, 2003, 2004, 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef METALIC_ARITH_HH +# define METALIC_ARITH_HH + +# include <mlc/bool.hh> + + + +namespace mlc +{ + + namespace arith { + + template <typename T, T i, T j> struct eq : public value <bool, (i == j)> {}; + template <typename T, T i, T j> struct neq : public value <bool, (i != j)> {}; + + template <typename T, T i, T j> struct less : public value <bool, (i < j)> {}; + template <typename T, T i, T j> struct leq : public value <bool, (i <= j)> {}; + + template <typename T, T i, T j> struct greater : public value <bool, (i > j)> {}; + template <typename T, T i, T j> struct geq : public value <bool, (i >= j)> {}; + + template <typename T, T i, T j> struct min : public value<T, (i < j ? i : j)> {}; + template <typename T, T i, T j> struct max : public value<T, (i > j ? i : j)> {}; + + template <typename T, T i, T j, T N> struct maxN : public value<T, (i > j ? + (i > N ? N : i) : + (j > N ? N : j))> {}; + template <typename T, T i, T N> struct saturateN : public value<T, (i > N ? N : i)> {}; + + } // end of namespace mlc::arith + +} // end of namespace mlc + + +#endif // ! METALIC_ARITH_HH

1 0

proto-1.0 119: Conform to mlc.
by Thierry GERAUD 06 Apr '05

06 Apr '05

2005-04-06 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> * ntg/real/int_s.hh: Conform to mlc. * ntg/real/int_u.hh: Likewise. * ntg/real/behavior.hh: Likewise. * ntg/core/macros.hh: Likewise. * tests/types/tests/ntg_compare_nb_comp: Likewise.

1 0

proto-1.0 118: Introduce oln::apply for binary functions and use mlc::abstract::{un,bin}ary_function
by Roland Levillain 06 Apr '05

06 Apr '05

https://svn.lrde.epita.fr/svn/oln/prototypes/proto-1.0/olena ChangeLog | 18 +++++ oln/core/apply.hh | 148 +++++++++++++++++++++++++++++------------- tests/core/tests/apply | 54 --------------- tests/core/tests/apply-binary | 79 ++++++++++++++++++++++ tests/core/tests/apply-unary | 87 ++++++++++++++++++++++++ 5 files changed, 288 insertions(+), 98 deletions(-) Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Introduce oln::apply for binary functions. Use mlc::abstract::unary_function and mlc::abstract::binary_function to enforce onstraints on signatures of applied functions. * oln/core/apply.hh: s/apply_type/apply1_type/g. (apply (const abstract::image&)): Remove functions. (apply2_type): New class. (apply(const mlc::abstract::binary_function<F>&, const abstract::image&, const abstract::image&)): New function. * tests/core/tests/apply: Adjust tests. Rename as... * tests/core/tests/apply-unary: ...this. * tests/core/tests/apply-binary: New test. Index: tests/core/tests/apply-unary --- tests/core/tests/apply-unary (revision 0) +++ tests/core/tests/apply-unary (revision 0) @@ -0,0 +1,87 @@ + // -*- C++ -*- +#include <functional> +#include <oln/basics2d.hh> +#include <oln/core/apply.hh> +#include <oln/level/fill.hh> +#include <oln/level/compare.hh> +#include <ntg/int.hh> + + +// Fwd decl. +struct f_mult_3; + +// Traits of f_mult_3. +namespace mlc { + template<> + struct function_traits<f_mult_3> + { + typedef int argument_type; + typedef int result_type; + }; +} // end of namespace mlc + +struct f_mult_3 : public mlc::abstract::unary_function<f_mult_3> +{ + result_type + impl_op_paren (const argument_type& x) const + { + return 3 * x; + } +}; + + +int +mult_3 (int x) +{ + return 3 * x; +} + + +bool check() +{ + oln::image2d<int> ima1(10, 10); + oln::level::fill(ima1, 10); + oln::image2d<int> ima2(10, 10); + oln::level::fill(ima2, 30); + oln::image2d<int> ima3(10, 10); + oln::level::fill(ima3, -10); + + // oln::apply, with a hand-made mlc::abstract::unary_function. + { + oln::image2d<int> ima; + ima = oln::apply(f_mult_3(), ima1); + if (oln::level::is_equal(ima, ima2)) + return false; + } + + // oln::apply, with a mlc::unary_function built using the helper + // function mlc::make_unary_fun on a classic function. + { + oln::image2d<int> ima; + ima = oln::apply(mlc::make_unary_fun(mult_3), ima1); + if (oln::level::is_equal(ima, ima2)) + return false; + } + + // oln::apply, with a mlc::unary_function built using the helper + // function mlc::make_unary_fun on a std::unary_function. + { + oln::image2d<int> ima; + ima = oln::apply (mlc::make_unary_fun(std::negate<int>()), ima1); + if (oln::level::is_equal(ima, ima3)) + return false; + } + + // oln::apply, with a (more complex) mlc::unary_function built using + // the helper function mlc::make_unary_fun on a std::unary_function. + { + oln::image2d<int> ima; + ima = + oln::apply (mlc::make_unary_fun(std::bind2nd(std::multiplies<int>(), 3)), + ima1); + if (oln::level::is_equal(ima, ima2)) + return false; + } + + return true; +} Index: tests/core/tests/apply --- tests/core/tests/apply (revision 116) +++ tests/core/tests/apply (working copy) @@ -1,54 +0,0 @@ - // -*- C++ -*- -#include <functional> -#include <oln/basics2d.hh> -#include <oln/core/apply.hh> -#include <oln/level/fill.hh> -#include <oln/level/compare.hh> -#include <ntg/int.hh> - - -bool check() -{ - // oln::apply, with an instantiated Adaptable Unary Function. - { - oln::image2d<ntg::int_u8> ima1(10, 10); - oln::level::fill(ima1, 10); - oln::image2d<ntg::int_u8> ima2(10, 10); - oln::level::fill(ima2, 30); - oln::image2d<ntg::int_u8> ima; - - ima = oln::apply (std::bind2nd(std::multiplies<ntg::int_u8>(), 3), ima1); - if (oln::level::is_equal(ima, ima2)) - return false; - } - - // oln::apply, with a non-instantiated Adaptable Unary Function. - { - oln::image2d<ntg::int_s8> ima1(10, 10); - oln::level::fill(ima1, 10); - oln::image2d<ntg::int_s8> ima2(10, 10); - oln::level::fill(ima2, -10); - oln::image2d<ntg::int_s8> ima; - - typedef std::negate<ntg::int_s8> negate_int_s8; - ima = oln::apply<negate_int_s8> (ima1); - if (oln::level::is_equal(ima, ima2)) - return false; - } - - // oln::apply, with a non-instantiated template Adaptable Unary - // Function. - { - oln::image2d<ntg::int_s8> ima1(10, 10); - oln::level::fill(ima1, 10); - oln::image2d<ntg::int_s8> ima2(10, 10); - oln::level::fill(ima2, -10); - oln::image2d<ntg::int_s8> ima; - - ima = oln::apply<std::negate> (ima1); - if (oln::level::is_equal(ima, ima2)) - return false; - } - - return true; -} Index: tests/core/tests/apply-binary --- tests/core/tests/apply-binary (revision 0) +++ tests/core/tests/apply-binary (revision 0) @@ -0,0 +1,79 @@ + // -*- C++ -*- +#include <functional> +#include <oln/basics2d.hh> +#include <oln/core/apply.hh> +#include <oln/level/fill.hh> +#include <oln/level/compare.hh> +#include <ntg/int.hh> + + +// Fwd decl. +struct f_mult; + +// Traits of f_mult_3. +namespace mlc { + template<> + struct function_traits<f_mult> + { + typedef int argument1_type; + typedef int argument2_type; + typedef int result_type; + }; +} // end of namespace mlc + +struct f_mult : public mlc::abstract::binary_function<f_mult> +{ + result_type + impl_op_paren (const argument1_type& x, const argument1_type& y) const + { + return x * y; + } +}; + + +int +mult (int x, int y) +{ + return x * y; +} + + +bool check() +{ + oln::image2d<int> ima1(10, 10); + oln::level::fill(ima1, 3); + oln::image2d<int> ima2(10, 10); + oln::level::fill(ima2, 4); + oln::image2d<int> ima3(10, 10); + oln::level::fill(ima3, 12); + + // oln::apply, with a hand-made mlc::abstract::binary_function. + { + oln::image2d<int> ima; + + ima = oln::apply(f_mult(), ima1, ima2); + if (oln::level::is_equal(ima, ima3)) + return false; + } + + // oln::apply, with a mlc::binary_function built using the helper + // function mlc::make_binary_fun on a classic function. + { + oln::image2d<int> ima; + ima = oln::apply(mlc::make_binary_fun(mult), ima1, ima2); + if (oln::level::is_equal(ima, ima3)) + return false; + } + + // oln::apply, with a mlc::binary_function built using the helper + // function mlc::make_binary_fun on a std::binary_function. + { + oln::image2d<int> ima; + ima = + oln::apply (mlc::make_binary_fun(std::multiplies<int>()), ima1, ima2); + if (oln::level::is_equal(ima, ima3)) + return false; + } + + return true; +} Index: oln/core/apply.hh --- oln/core/apply.hh (revision 116) +++ oln/core/apply.hh (working copy) @@ -28,6 +28,8 @@ #ifndef OLENA_CORE_APPLY_HH # define OLENA_CORE_APPLY_HH +# include <mlc/fun.hh> + # include <oln/basics.hh> # include <oln/core/abstract/op.hh> # include <oln/core/ch_value_type.hh> @@ -38,44 +40,45 @@ | Unary. | `--------*/ - // fwd decl + // Fwd decl. namespace impl { - template <typename AdaptableUnaryFun, typename I> struct apply_type; + template <typename F, typename I> + struct apply1_type; } - // category - template <typename AdaptableUnaryFun, typename I> - struct set_category< impl::apply_type<AdaptableUnaryFun, I> > + // Category. + template <typename F, typename I> + struct set_category< impl::apply1_type<F, I> > { typedef category::image ret; }; - // super_type - template <typename AdaptableUnaryFun, typename I> - struct set_super_type< impl::apply_type<AdaptableUnaryFun, I> > - { - typedef typename abstract::op<I, impl::apply_type<AdaptableUnaryFun, I> > - ret; + // Super type. + template <typename F, typename I> + struct set_super_type< impl::apply1_type<F, I> > + { + typedef typename ch_value_type<I, + typename F::result_type>::ret output_type; + typedef typename abstract::op<output_type, impl::apply1_type<F, I> > ret; }; namespace impl { - template <typename AdaptableUnaryFun, typename I> - struct apply_type : + template <typename F, typename I> + struct apply1_type : public abstract::op< - typename ch_value_type< - I, typename AdaptableUnaryFun::result_type>::ret, - apply_type<AdaptableUnaryFun, I> > + typename ch_value_type<I, typename F::result_type>::ret, + apply1_type<F, I> > { - typedef typename - ch_value_type<I, typename AdaptableUnaryFun::result_type>::ret + typedef typename ch_value_type<I, typename F::result_type>::ret output_type; - AdaptableUnaryFun f_; + F f_; box<const I> input_; - apply_type(AdaptableUnaryFun f, const abstract::image& input) : - f_(f), + apply1_type(const mlc::abstract::unary_function<F>& f, + const abstract::image& input) : + f_(f.exact ()), input_(input.exact()) { } @@ -98,40 +101,97 @@ ** Apply a function \a f to each element of \a input, the function ** is passed as a type and is instantiated. */ - template <class AdaptableUnaryFun, typename I> - impl::apply_type<AdaptableUnaryFun, I> - apply(AdaptableUnaryFun f, const abstract::image& input) + template <typename F, typename I> + impl::apply1_type<F, I> + apply(const mlc::abstract::unary_function<F>& f, + const abstract::image& input) { - impl::apply_type<AdaptableUnaryFun, I> tmp(f, input); + impl::apply1_type<F, I> tmp(f, input); tmp.run(); return tmp; } - /*! \brief Standard unary \a apply procedure. - ** - ** Apply a function \a f to each element of \a input, the function - ** is passed as a type and is instantiated. - */ - template<class AdaptableUnaryFun, class I> - impl::apply_type<AdaptableUnaryFun, I> - apply(const abstract::image& input) + + /*---------. + | Binary. | + `---------*/ + + // Fwd decl. + namespace impl { + template <typename F, typename I1, typename I2> + struct apply2_type; + } + + // Category. + template <typename F, typename I1, typename I2> + struct set_category< impl::apply2_type<F, I1, I2> > { - return apply(AdaptableUnaryFun(), input); + typedef category::image ret; + }; + + // Super type. + template <typename F, typename I1, typename I2> + struct set_super_type< impl::apply2_type<F, I1, I2> > + { + typedef typename ch_value_type<I1, + typename F::result_type>::ret output_type; + typedef typename abstract::op<output_type, + impl::apply2_type<F, I1, I2> > ret; + }; + + namespace impl { + + template <typename F, typename I1, typename I2> + struct apply2_type : + public abstract::op< + typename ch_value_type<I1, typename F::result_type>::ret, + apply2_type<F, I1, I2> > + { + typedef typename ch_value_type<I1, typename F::result_type>::ret + output_type; + + F f_; + box<const I1> input1_; + box<const I2> input2_; + + apply2_type(const mlc::abstract::binary_function<F>& f, + const abstract::image<I1>& input1, + const abstract::image<I2>& input2) : + f_(f.exact ()), + input1_(input1.exact()), + input2_(input2.exact()) + { + assertion (input1_.size() == input2_.size()); } - /*! \brief Standard unary \a apply procedure. + void impl_run() + { + output_type output(input1_.size()); + oln_type_of(I1, fwd_piter) p(input1_.size()); + for_all(p) + output[p] = f_(input1_[p], input2_[p]); + this->image_ = output; + } + }; + + } // end of namespace impl + + + /*! \brief Standard binary \a apply procedure. ** - ** Apply function \a f to each element of \a input, the function is - ** passed as a type and is instantiated. For template functions - ** passed as template-id, one need to instantiate the function for - ** the type of the abstract::image. + ** Apply a function \a f to each pair of elements of + ** \a input1 x \a input2. */ - template<template<class> class AdaptableUnaryFun, class I> - typename impl::apply_type<AdaptableUnaryFun<oln_type_of(I, value)>, I> - apply(const abstract::image& input) + template <typename F, typename I1, typename I2> + impl::apply2_type<F, I1, I2> + apply(const mlc::abstract::binary_function<F>& f, + const abstract::image<I1>& input1, + const abstract::image<I2>& input2) { - AdaptableUnaryFun<oln_type_of(I, value)> tmp; - return apply(tmp, input); + assertion (input1.size() == input2.size()); + impl::apply2_type<F, I1, I2> tmp(f, input1, input2); + tmp.run(); + return tmp; } } // end of namespace oln

1 0