Olena-patches March 2005

olena-patches@lrde.epita.fr

10 participants
59 discussions

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * mlc/makefile.src: Add new files. * mlc/array: New. * mlc/array/nd.hh: New. * mlc/array/1d.hh: New. * mlc/array/2d.hh: New. * mlc/array/3d.hh: New. * mlc/array/all.hh: New. * mlc/array/1d.hxx: New. * mlc/array/2d.hxx: New. * mlc/array/objs.hh: New. * mlc/array/3d.hxx: New. array/1d.hh | 294 +++++++++++++++++++++++++++++++++++++++++++++++++++ array/1d.hxx | 237 +++++++++++++++++++++++++++++++++++++++++ array/2d.hh | 326 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ array/2d.hxx | 283 +++++++++++++++++++++++++++++++++++++++++++++++++ array/3d.hh | 333 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ array/3d.hxx | 293 +++++++++++++++++++++++++++++++++++++++++++++++++++ array/all.hh | 35 ++++++ array/nd.hh | 50 ++++++++ array/objs.hh | 78 +++++++++++++ makefile.src | 11 + 10 files changed, 1940 insertions(+) Index: mlc/makefile.src --- mlc/makefile.src (revision 61) +++ mlc/makefile.src (working copy) @@ -5,11 +5,22 @@ MLC_DEP = \ any.hh \ + array/1d.hh \ + array/1d.hxx \ + array/2d.hh \ + array/2d.hxx \ + array/3d.hh \ + array/3d.hxx \ + array/all.hh \ + array/nd.hh \ + array/objs.hh \ bool.hh \ box.hh \ cmp.hh \ config/system.hh \ contract.hh \ + is_a.hh \ + properties.hh \ tracked_ptr.hh \ traits.hh \ types.hh Index: mlc/array/nd.hh --- mlc/array/nd.hh (revision 0) +++ mlc/array/nd.hh (revision 0) @@ -0,0 +1,50 @@ +// Copyright (C) 2001, 2003 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_ARRAY_ND_HH +# define METALIC_ARRAY_ND_HH + + +namespace mlc +{ + + namespace internal + { + + // + // mlc::internal misc + // + //////////////////////////////////////// + + static const unsigned max_card_ = 4096; // 64 x 64 + static const unsigned unknown_ = max_card_ + 1; + + } // end of internal + +} // end of namespace mlc + +#endif // ! METALIC_ARRAY_ND_HH Index: mlc/array/1d.hh --- mlc/array/1d.hh (revision 0) +++ mlc/array/1d.hh (revision 0) @@ -0,0 +1,294 @@ +// Copyright (C) 2001, 2002, 2003, 2004 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_ARRAY_1D_HH +# define METALIC_ARRAY_1D_HH + +# include <mlc/contract.hh> +# include <mlc/cmp.hh> +# include <mlc/array/objs.hh> +# include <ntg/basics.hh> +# include <iostream> + + +// impl +# include <mlc/array/1d.hxx> + +namespace mlc +{ + + template<class Info_, class T_> + struct array1d + { + typedef array1d self; + typedef T_ T; + typedef Info_ Info; + + + // + // Constructors + // + + array1d() + { + } + + array1d(T* ptr) + { + less<0, Info_::card>::ensure(); + less< Info_::card, internal::max_card_ >::ensure(); + for (unsigned i = 0; i < Info_::card; ++i) + buffer_[i] = *ptr++; + } + + // Copy + + array1d(const self& rhs) + { + for (unsigned i = 0; i < Info_::card; ++i) + buffer_[i] = rhs[i]; + } + self& operator=(const self& rhs) + { + for (unsigned i = 0; i < Info_::card; ++i) + buffer_[i] = rhs[i]; + return *this; + } + + + // Name + + static std::string + name() + { + return std::string("array1d< Info, ") + ntg_name(T) + " >"; + } + + + + // + // Operations on array + // + + // Normalize (absolute values -> relative values) + + array1d<Info_, ntg::float_s> + normalize() + { + array1d<Info_, ntg::float_s> tmp; + ntg::float_s sum = 0.f; + const ntg::float_s epsilon = 0.01f; // FIXME : epsilon should be global + unsigned i; + for (i = 0; i < Info_::card; ++i) + sum += this->buffer_[i]; + for (i = 0; i < Info_::card; ++i) + tmp[i] = this->buffer_[i] / sum; + // security + sum = 0.f; + for (i = 0; i < Info_::card; ++i) + sum += tmp[i]; + postcondition(std::abs(sum - 1) <= epsilon); + return tmp; + } + + // Central symmetry + + array1d<array1d_info<Info_::card, + Info_::card - Info_::center - 1, + Info_::i>, T> + operator-() const + { + enum { new_center = Info_::card - Info_::center - 1 }; + array1d<array1d_info< Info_::card, new_center, Info_::i>,T> tmp; + + for (unsigned i = 0; i < Info_::card; ++i) + tmp[Info_::card - i - 1] = this->operator[](i); + return tmp; + } + + + // Operators + + // FIXME: This code should be factorized between 1d, 2d and 3d. + // Think of a mechanism similar to apply() and apply2(). + + template <class U> + array1d< Info, ntg_return_type(times, T, U) > + operator*(U w) + { + array1d< Info, ntg_return_type(times, T, U) > tmp; + for (unsigned i = 0; i < Info::card; ++i) + tmp[i] = this->buffer_[i] * w; + return tmp; + } + + template <class U> + array1d< Info, ntg_return_type(div, T, U) > + operator/(U w) + { + array1d< Info, ntg_return_type(div, T, U) > tmp; + for (unsigned i = 0; i < Info::card; ++i) + tmp[i] = this->buffer_[i] / w; + return tmp; + } + + self operator+(const self& rhs) const + { + self tmp; + for (unsigned i = 0; i < Info::card; ++i) + tmp[i] = this->buffer_[i] + rhs.buffer_[i]; + return tmp; + } + self& operator+=(const self& rhs) + { + for (unsigned i = 0; i < Info::card; ++i) + this->buffer_[i] += rhs.buffer_[i]; + return *this; + } + + self operator-(const self& rhs) const + { + self tmp; + for (unsigned i = 0; i < Info::card; ++i) + tmp[i] = this->buffer_[i] - rhs.buffer_[i]; + return tmp; + } + self& operator-=(const self& rhs) + { + for (unsigned i = 0; i < Info::card; ++i) + this->buffer_[i] -= rhs.buffer_[i]; + return *this; + } + + + // + // Accessors + // + + unsigned size() const + { + return Info_::card; + } + + const T* buffer() const + { + return buffer_; + } + + // dynamic accessors: + + T operator[](unsigned i) const // Absolute position + { + precondition(i < Info_::card); + return *(buffer_ + i); + } + T& operator[](unsigned i) + { + precondition(i < Info_::card); + return *(buffer_ + i); + } + + T operator()(int i) const // Relative position + { + precondition(-Info_::center <= i); + precondition(i <= Info_::card - Info_::center - 1); + return *(buffer_ + Info_::center + i); + } + T& operator()(int i) + { + precondition(-Info_::center <= i); + precondition(i <= Info_::card - Info_::center - 1); + return *(buffer_ + Info_::center + i); + } + + + // do not use these methods... + + template<unsigned i> + T get_at_() const { + lesseq<i, Info_::card>::ensure(); + return *(buffer_ + i); + } + + template<int i> + T get_() const { + lesseq<-Info_::center, i>::ensure(); + lesseq<i, Info_::card - Info_::center - 1>::ensure(); + return *(buffer_ + Info_::center + i); + } + + protected: + + T buffer_[Info_::card]; + }; + + + // ...but these static accessors: + + template<unsigned i, class Info, class T> inline + T get_at(const array1d<Info, T>& arr) + { + return arr.template get_at_<i>(); + } + + template<int i, class Info, class T> inline + T get(const array1d<Info, T>& arr) + { + return arr.template get_<i>(); + } + + // starter objects + + // FIXME: what about other types? Replace this by a function + // returning a starter. + +# define array1d_starter(T) \ + static internal::array1d_start_<T > T##s_1d = internal::array1d_start_<T >() + + array1d_starter(int); // ints_1d + array1d_starter(float); // floats_1d + + + + // print + + template<class Info, class T> + std::ostream& operator<<(std::ostream& ostr, const array1d<Info, T>& rhs) + { + for (int i = 0; i < Info::card; ++i) + if (i == Info::center) + ostr << "<" << rhs[i] << "> "; + else + ostr << rhs[i] << " "; + ostr << std::endl; + + return ostr; + } + +} // end of mlc + +#endif // ! METALIC_ARRAY_1D_HH Index: mlc/array/2d.hh --- mlc/array/2d.hh (revision 0) +++ mlc/array/2d.hh (revision 0) @@ -0,0 +1,326 @@ +// Copyright (C) 2001, 2002, 2003, 2004 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_ARRAY_2D_HH +# define METALIC_ARRAY_2D_HH + +# include <mlc/array/objs.hh> +# include <mlc/contract.hh> +# include <mlc/cmp.hh> +# include <ntg/basics.hh> + +# include <iostream> + +// impl +# include <mlc/array/2d.hxx> + +namespace mlc +{ + + template<class Info_, class T_> + struct array2d + { + typedef array2d self; + typedef T_ T; + typedef Info_ Info; + + // + // Constructors + // + + array2d() + { + } + + array2d(T* ptr) + { + less< 0, Info_::nrows >::ensure(); + less< 0, Info_::ncols >::ensure(); + less< Info_::card, internal::max_card_ >::ensure(); + for (unsigned i = 0; i < Info_::card; ++i) + buffer_[i] = *ptr++; + } + + // Copy + + array2d(const self& rhs) + { + for (unsigned i = 0; i < Info_::card; ++i) + buffer_[i] = rhs[i]; + } + self& operator=(const self& rhs) + { + for (unsigned i = 0; i < Info_::card; ++i) + buffer_[i] = rhs[i]; + return *this; + } + + + // Name + + static std::string + name() + { + return std::string("array2d< Info, ") + ntg_name(T) + " >"; + } + + + + // + // Operations on array + // + + + // Normalize (absolute values -> relative values) + + array2d<Info_, ntg::float_s> + normalize() + { + array2d<Info_, ntg::float_s> tmp; + ntg::float_s sum = 0.f; + const ntg::float_s epsilon = 0.01f; // FIXME : epsilon should be global + unsigned i; + for (i = 0; i < Info_::card; ++i) + sum += this->buffer_[i]; + for (i = 0; i < Info_::card; ++i) + tmp[i] = this->buffer_[i] / sum; + // security + sum = 0.f; + for (i = 0; i < Info_::card; ++i) + sum += tmp[i]; + postcondition(std::abs(sum - 1) <= epsilon); + return tmp; + } + + // Central symmetry + + array2d<array2d_info<Info_::nrows, + Info_::ncols, + Info_::card - Info_::center - 1, + Info_::i>, T> + operator-() const + { + enum { new_center = Info_::card - Info_::center - 1 }; + array2d<array2d_info< Info_::nrows, Info_::ncols, new_center, Info_::i>,T> tmp; + + for (unsigned i = 0; i < Info_::card; ++i) + tmp[Info_::card - i - 1] = this->operator[](i); + return tmp; + } + + + // Transpose + + typedef array2d<array2d_info< + Info_::ncols, + Info_::nrows, + (Info_::center * Info_::nrows + Info_::center / Info_::ncols) % Info_::card, + Info_::i + >, T> transposed_array_t; + + transposed_array_t transpose() const + { + transposed_array_t tmp; + for (int i = 0; i < Info::card; ++i) + tmp[i] = this->operator[]((i * Info_::ncols + i / Info_::nrows) % Info_::card); + return tmp; + } + + // Operators + + // FIXME: This code should be factorized between 1d, 2d and 3d. + // Think of a mechanism similar to apply() and apply2(). + + template <class U> + array2d< Info, ntg_return_type(times, T, U) > + operator*(U w) + { + array2d< Info, ntg_return_type(times, T, U) > tmp; + for (unsigned i = 0; i < Info::card; ++i) + tmp[i] = this->buffer_[i] * w; + return tmp; + } + + template <class U> + array2d< Info, ntg_return_type(div, T, U) > + operator/(U w) + { + array2d< Info, ntg_return_type(div, T, U) > tmp; + for (unsigned i = 0; i < Info::card; ++i) + tmp[i] = this->buffer_[i] / w; + return tmp; + } + + self operator+(const self& rhs) const + { + self tmp; + for (unsigned i = 0; i < Info::card; ++i) + tmp[i] = this->buffer_[i] + rhs.buffer_[i]; + return tmp; + } + self& operator+=(const self& rhs) + { + for (unsigned i = 0; i < Info::card; ++i) + this->buffer_[i] += rhs.buffer_[i]; + return *this; + } + + self operator-(const self& rhs) const + { + self tmp; + for (unsigned i = 0; i < Info::card; ++i) + tmp[i] = this->buffer_[i] - rhs.buffer_[i]; + return tmp; + } + self& operator-=(const self& rhs) + { + for (unsigned i = 0; i < Info::card; ++i) + this->buffer_[i] -= rhs.buffer_[i]; + return *this; + } + + + // + // Accessors + // + + unsigned size() const + { + return Info_::card; + } + + const T* buffer() const + { + return buffer_; + } + + // dynamic accessors: + + T operator[](unsigned i) const // Absolute position + { + precondition(i < Info_::card); + return *(buffer_ + i); + } + T& operator[](unsigned i) + { + precondition(i < Info_::card); + return *(buffer_ + i); + } + + + T operator()(int row, int col) const // Relative position + { + precondition(-Info_::center_row <= row); + precondition(row <= Info_::nrows - Info_::center_row - 1); + precondition(-Info_::center_col <= col); + precondition(col <= Info_::ncols - Info_::center_col - 1); + + return *(buffer_ + Info_::center + (row * Info_::ncols) + col); + } + T& operator()(int row, int col) + { + precondition(-Info_::center_row <= row); + precondition(row <= Info_::nrows - Info_::center_row - 1); + precondition(-Info_::center_col <= col); + precondition(col <= Info_::ncols - Info_::center_col - 1); + + return *(buffer_ + Info_::center + (row * Info_::ncols) + col); + } + + + // do not use these methods... + + template<unsigned i> + T get_at_() const { + lesseq<i, Info_::card>::ensure(); + return *(buffer_ + i); + } + + template<int nrow, int ncol> + T get_() const { + lesseq< -Info_::center_row, nrow >::ensure(); + lesseq< nrow, Info_::nrows - Info_::center_row - 1 >::ensure(); + lesseq< -Info_::center_col, ncol >::ensure(); + lesseq< ncol, Info_::ncols - Info_::center_col - 1 >::ensure(); + return *(buffer_ + Info_::center + (nrow * Info_::ncols) + ncol); + } + + + protected: + + T buffer_[internal::max_card_]; + }; + + + // ...but these static accessors: + + template<unsigned i, class Info, class T> inline + T get_at(const array2d<Info, T>& arr) + { + return arr.template get_at_<i>(); + } + + template<int row, int col, class Info, class T> inline + T get(const array2d<Info, T>& arr) + { + return arr.template get_<row, col>(); + } + + // starter objects + + // FIXME: what about other types? Replace this by a function + // returning a starter. + +# define array2d_starter(T) \ + static internal::array2d_start_<T > T##s_2d = internal::array2d_start_<T >() + + array2d_starter(int); // ints_2d + array2d_starter(float); // floats_2d + + + // print + + template<class Info, class T> + std::ostream& operator<<(std::ostream& ostr, const array2d<Info, T>& rhs) + { + for (int i = 0; i < Info::card; ++i) + { + if (i == Info::center) + ostr << "<" << rhs[i] << ">"; + else + ostr << rhs[i]; + + ostr << ((i + 1) % Info::ncols == 0 ? "\n" : "\t"); + } + ostr << std::flush; + return ostr; + } + +} // end of mlc + + +#endif // ! METALIC_ARRAY_2D_HH Index: mlc/array/3d.hh --- mlc/array/3d.hh (revision 0) +++ mlc/array/3d.hh (revision 0) @@ -0,0 +1,333 @@ +// Copyright (C) 2001, 2002, 2003, 2004 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_ARRAY_3D_HH +# define METALIC_ARRAY_3D_HH + +# include <mlc/array/objs.hh> +# include <mlc/contract.hh> +# include <mlc/cmp.hh> +# include <ntg/basics.hh> + +# include <iostream> + +// impl +# include <mlc/array/3d.hxx> + +namespace mlc +{ + + class not_implemented_yet{}; // FIXME + + template<class Info_, class T_> + struct array3d + { + typedef array3d self; + typedef T_ T; + typedef Info_ Info; + + // + // Constructors + // + + array3d() + { + } + + array3d(T* ptr) + { + less< 0, Info_::nplanes >::ensure(); + less< 0, Info_::nrows >::ensure(); + less< 0, Info_::ncols >::ensure(); + less< Info_::card, internal::max_card_ >::ensure(); + for (unsigned i = 0; i < Info_::card; ++i) + buffer_[i] = *ptr++; + } + + // Copy + + array3d(const self& rhs) + { + for (unsigned i = 0; i < Info_::card; ++i) + buffer_[i] = rhs[i]; + } + self& operator=(const self& rhs) + { + for (unsigned i = 0; i < Info_::card; ++i) + buffer_[i] = rhs[i]; + return *this; + } + + + // Name + + static std::string + name() + { + return std::string("array3d< Info, ") + ntg_name(T) + " >"; + } + + + + // + // Operations on array + // + + // Normalize (absolute values -> relative values) + + array3d<Info_, ntg::float_s> + normalize() + { + array3d<Info_, ntg::float_s> tmp; + ntg::float_s sum = 0.f; + const ntg::float_s epsilon = 0.01f; // FIXME : epsilon should be global + unsigned i; + for (i = 0; i < Info_::card; ++i) + sum += this->buffer_[i]; + for (i = 0; i < Info_::card; ++i) + tmp[i] = this->buffer_[i] / sum; + // security + sum = 0.f; + for (i = 0; i < Info_::card; ++i) + sum += tmp[i]; + postcondition(std::abs(sum - 1) <= epsilon); + return tmp; + } + + // Central symmetry + + array3d<array3d_info<Info_::nplanes, + Info_::nrows, + Info_::ncols, + Info_::card - Info_::center - 1, + Info_::i>, T> + operator-() const + { + enum { new_center = Info_::card - Info_::center - 1 }; + array3d<array3d_info< Info_::nplanes, Info_::nrows, Info_::ncols, new_center, Info_::i>,T> tmp; + + for (unsigned i = 0; i < Info_::card; ++i) + tmp[Info_::card - i - 1] = this->operator[](i); + return tmp; + } + + + // Transpose + + array3d<Info, T> transpose() const // FIXME + { + std::cerr << "[31m===> 3D transposition not implemented yet. <===[0m" << std::endl; + throw not_implemented_yet(); + } + + + // Operators + + // FIXME: This code should be factorized between 1d, 2d and 3d. + // Think of a mechanism similar to apply() and apply2(). + + template <class U> + array3d< Info, ntg_return_type(times, T, U) > + operator*(U w) + { + array3d< Info, ntg_return_type(times, T, U) > tmp; + for (unsigned i = 0; i < Info::card; ++i) + tmp[i] = this->buffer_[i] * w; + return tmp; + } + + template <class U> + array3d< Info, ntg_return_type(div, T, U) > + operator/(U w) + { + array3d< Info, ntg_return_type(div, T, U) > tmp; + for (unsigned i = 0; i < Info::card; ++i) + tmp[i] = this->buffer_[i] / w; + return tmp; + } + + self operator+(const self& rhs) const + { + self tmp; + for (unsigned i = 0; i < Info::card; ++i) + tmp[i] = this->buffer_[i] + rhs.buffer_[i]; + return tmp; + } + self& operator+=(const self& rhs) + { + for (unsigned i = 0; i < Info::card; ++i) + this->buffer_[i] += rhs.buffer_[i]; + return *this; + } + + self operator-(const self& rhs) const + { + self tmp; + for (unsigned i = 0; i < Info::card; ++i) + tmp[i] = this->buffer_[i] - rhs.buffer_[i]; + return tmp; + } + self& operator-=(const self& rhs) + { + for (unsigned i = 0; i < Info::card; ++i) + this->buffer_[i] -= rhs.buffer_[i]; + return *this; + } + + + + // template<class U> int operator,(U); // FIXME: why this? + + // + // Accessors + // + + unsigned size() const + { + return Info_::card; + } + + const T* buffer() const + { + return buffer_; + } + + // dynamic accessors: + + T operator[](unsigned i) const // Absolute position + { + precondition(i < Info_::card); + return *(buffer_ + i); + } + T& operator[](unsigned i) + { + precondition(i < Info_::card); + return *(buffer_ + i); + } + + + T operator()(int plane, int row, int col) const // Relative position + { + precondition(-Info_::center_plane <= plane); + precondition(plane <= Info::nplanes - Info_::center_plane - 1); + precondition(-Info_::center_row <= row); + precondition(row <= Info_::nrows - Info_::center_row - 1); + precondition(-Info_::center_col <= col); + precondition(col <= Info_::ncols - Info_::center_col - 1); + + return *(buffer_ + Info_::center + (plane * Info::nrows * Info::ncols) + (row * Info::ncols) + col); + } + + T& operator()(int plane, int row, int col) + { + precondition(-Info_::center_plane <= plane); + precondition(plane <= Info::nplanes - Info_::center_plane - 1); + precondition(-Info_::center_row <= row); + precondition(row <= Info_::nrows - Info_::center_row - 1); + precondition(-Info_::center_col <= col); + precondition(col <= Info_::ncols - Info_::center_col - 1); + + return *(buffer_ + Info_::center + (plane * Info::nrows * Info::ncols) + (row * Info::ncols) + col); + } + + + // do not use these methods... + + template<unsigned i> + T get_at_() const { + lesseq<i, Info_::card>::ensure(); + return *(buffer_ + i); + } + + template<int nplane, int nrow, int ncol> + T get_() const { + lesseq< -Info_::center_plane, nplane >::ensure(); + lesseq< nplane, Info::nplanes - Info_::center_plane - 1 >::ensure(); + lesseq< -Info_::center_row, nrow >::ensure(); + lesseq< nrow, Info_::nrows - Info_::center_row - 1 >::ensure(); + lesseq< -Info_::center_col, ncol >::ensure(); + lesseq< ncol, Info_::ncols - Info_::center_col - 1 >::ensure(); + return *(buffer_ + Info_::center + (nplane * Info::nrows * Info::ncols) + (nrow * Info::ncols) + ncol); + } + + + protected: + + T buffer_[internal::max_card_]; + }; + + + // ...but these static accessors: + + template<unsigned i, class Info, class T> inline + T get_at(const array3d<Info, T>& arr) + { + return arr.template get_at_<i>(); + } + + template<int plane, int row, int col, class Info, class T> inline + T get(const array3d<Info, T>& arr) + { + return arr.template get_<plane, row, col>(); + } + + // starter objects + + // FIXME: what about other types? Replace this by a function + // returning a starter. + +# define array3d_starter(T) \ + static internal::array3d_start_<T > T##s_3d = internal::array3d_start_<T >() + + array3d_starter(int); // ints_3d + array3d_starter(float); // floats_3d + + + // print + + template<class Info, class T> + std::ostream& operator<<(std::ostream& ostr, const array3d<Info, T>& rhs) + { + for (int i = 0; i < Info::card; ++i) + { + if (i == Info::center) + ostr << "<" << rhs[i] << "> "; + else + ostr << rhs[i] << " "; + + ostr << ((i + 1) % Info::ncols == 0 ? "\n" : "\t"); + ostr << ((i + 1) % (Info::ncols * Info::nrows) == 0 ? "\n" : ""); + } + ostr << std::flush; + + return ostr; + } + + +} // end of mlc + +#endif // ! METALIC_ARRAY_3D_HH Index: mlc/array/all.hh --- mlc/array/all.hh (revision 0) +++ mlc/array/all.hh (revision 0) @@ -0,0 +1,35 @@ +// Copyright (C) 2001, 2002, 2003 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_ARRAY__HH +# define METALIC_ARRAY__HH + +# include <mlc/array/1d.hh> +# include <mlc/array/2d.hh> +# include <mlc/array/3d.hh> + +#endif // ! METALIC_ARRAY__HH Index: mlc/array/1d.hxx --- mlc/array/1d.hxx (revision 0) +++ mlc/array/1d.hxx (revision 0) @@ -0,0 +1,237 @@ +// Copyright (C) 2001, 2002, 2003 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_ARRAY_1D_HXX +# define METALIC_ARRAY_1D_HXX + +# include <mlc/array/nd.hh> + +namespace mlc +{ + + // + // mlc::array1d_info + // + //////////////////////////////////////// + + + // card_ -> total number of elements (1-indexed) + + // center_ -> position of the central element (0-indexed) + // domain : [ 0, card [ + + // i_ -> number of elements that have been eaten yet (0-indexed) + // domain : [ 0, card ] -> watch out !! + + + template < unsigned card_, unsigned center_ = card_ / 2, unsigned i_ = card_> + struct array1d_info + { + enum { + card = card_, + center = center_, + i = i_, + well_formed = true, + get_real_center = center_ + }; + + typedef array1d_info< card_, center_, i + 1 > next_elt; + + }; + + template < unsigned card_, unsigned i_ > + struct array1d_info <card_, internal::unknown_, i_ > + { + enum { + card = card_, + center = internal::unknown_, + i = i_, + well_formed = true, + get_real_center = i_ / 2 + }; + + typedef array1d_info< card_, internal::unknown_, i + 1 > next_elt; + + }; + + // fwd decl + template<class, class> struct array1d; + + + namespace internal + { + + // fwd decl + + template<class T, class Info> + struct array1d_elt_; + + // for error messages + + template<class U> + struct here_a_value_is_not_of_type_; + + + // + // mlc::internal::array1d_start_ decl + // + //////////////////////////////////////// + + template<class T> + struct array1d_start_ { + + array1d_elt_< T, array1d_info< unknown_, unknown_, 1 > > operator=(T val); + array1d_elt_< T, array1d_info< unknown_, 0, 1 > > operator=(x_<T> val); + array1d_elt_< T, array1d_info< unknown_, 0, 1 > > operator=(x_<void> val); + + T ptr[max_card_]; // could be static + }; + + + + // + // mlc::internal::array1d_elt_ + // + //////////////////////////////////////// + + template<class T, class Info> + struct array1d_elt_ + { + typedef array1d_elt_<T, typename Info::next_elt> next_elt_t_; + + typedef array1d_elt_< T, array1d_info< Info::card, Info::i, Info::i + 1> > eat_center_t_; + + typedef array1d< array1d_info< Info::i, Info::get_real_center, Info::i > , T> array1d_t_; + + public: + + // Constructor + + array1d_elt_(T* ptr, array1d_start_<T>* arr) : ptr(ptr), arr(arr) + { + } + + + + // + // Overloading "operator," + // + + + // elt, elt + + next_elt_t_ operator,(T val) + { + is_true<Info::card == unknown_>::ensure(); + *ptr = val; + return next_elt_t_(ptr + 1, arr); + } + + + // elt, x(elt) -> center + + eat_center_t_ operator,(x_<T> val) + { + is_true<Info::center == unknown_>::ensure(); + *ptr = val.ue; // FIXME : give a *name* to this variable !! + return eat_center_t_(ptr+1, arr); + } + + + // elt, x() -> center + + eat_center_t_ operator,(x_<void>) + { + is_true<Info::center == unknown_>::ensure(); + *ptr = T(0); + return eat_center_t_(ptr+1, arr); + } + + + // elt, end + + array1d_t_ operator,(end_type) + { + // array is well-formed : + is_true<Info::well_formed>::ensure(); + // centering is automatic or user-defined : + // (commented out to allow automatic centering on even sized arrays) + // mlc::logical_or< mlc::eq< Info::i % 2, 1 >::ret, mlc::neq< Info::center, unknown_ >::ret >::ensure(); + return array1d_t_(arr->ptr); + } + + + // else -> error + + template<class U> + void operator,(array1d< Info, U >); + + template<class U> + here_a_value_is_not_of_type_<T> operator,(U u) const; + + T* ptr; + array1d_start_<T>* arr; + }; + + + + // + // mlc::internal::array1d_start_ impl + // + //////////////////////////////////////// + + template<class T> inline + array1d_elt_< T, array1d_info< unknown_, unknown_, 1 > > + array1d_start_<T>::operator=(T val) + { + ptr[0] = val; + return array1d_elt_< T, array1d_info< unknown_, unknown_, 1 > >(ptr+1, this); + } + + template<class T> inline + array1d_elt_< T, array1d_info< unknown_, 0, 1 > > + array1d_start_<T>::operator=(x_<T> val) + { + ptr[0] = val.ue; + // center <- 0 + return array1d_elt_< T, array1d_info< unknown_, 0, 1 > >(ptr+1, this); + } + + template<class T> inline + array1d_elt_< T, array1d_info< unknown_, 0, 1 > > + array1d_start_<T>::operator=(x_<void> val) + { + ptr[0] = T(0); + // center <- 0 + return array1d_elt_< T, array1d_info< unknown_, 0, 1 > >(ptr+1,this); + } + + } // end of internal + +} // end of mlc + +#endif // ! METALIC_ARRAY_1D_HXX Index: mlc/array/2d.hxx --- mlc/array/2d.hxx (revision 0) +++ mlc/array/2d.hxx (revision 0) @@ -0,0 +1,283 @@ +// Copyright (C) 2001, 2002, 2003 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_ARRAY_2D_HXX +# define METALIC_ARRAY_2D_HXX + +# include <mlc/array/nd.hh> + +namespace mlc +{ + + // + // mlc::array2d_info + // + //////////////////////////////////////// + + + // nrows_ -> total number of rows (1-indexed) + // ncols_ -> total number of columns (1-indexed) + + // center_ -> position of the central element (0-indexed) + // domain : [ 0, card [ + + // i_ -> number of elements that have been eaten yet (0-indexed) + // domain : [ 0, card ] -> watch out !! + + + + // Center is user-defined + + template < unsigned nrows_, + unsigned ncols_, + unsigned center_ = ncols_ * (nrows_ / 2) + (ncols_ / 2), + unsigned i_ = nrows_ * ncols_> + struct array2d_info + { + enum { + nrows = nrows_, + ncols = ncols_, + center = center_, + center_row = center_ / ncols_, + center_col = center_ % ncols_, + card = nrows_ * ncols_, + i = i_, + well_formed = ((i_ % ncols_) == 0), + get_real_center = center_ + }; + + typedef array2d_info< nrows_, ncols_, center_, i + 1 > next_elt; + + }; + + // Center is defined automatically, if nrows and ncols are both odd + + template < unsigned nrows_, unsigned ncols_, unsigned i_ > + struct array2d_info <nrows_, ncols_, internal::unknown_, i_ > + { + enum { + nrows = nrows_, + ncols = ncols_, + center = internal::unknown_, + i = i_, + card = nrows_ * ncols_, + well_formed = ((i_ % ncols_) == 0), + get_real_center = i_ / 2 + }; + + typedef array2d_info< nrows_, ncols_, internal::unknown_, i + 1 > next_elt; + + }; + + // fwd decl + template<class, class> struct array2d; + + + namespace internal + { + + // fwd decl + + template<class T, class Info> + struct array2d_elt_; + + // for error messages + + template<class U> + struct here_a_value_is_not_of_type_; + + + // + // mlc::internal::array2d_start_ decl + // + //////////////////////////////////////// + + template<class T> + struct array2d_start_ { + + array2d_elt_< T, array2d_info< unknown_, unknown_, unknown_, 1 > > + operator=(T val); + + array2d_elt_< T, array2d_info< unknown_, unknown_, 0, 1 > > + operator=(x_<T> val); + + array2d_elt_< T, array2d_info< unknown_, unknown_, 0, 1 > > + operator=(x_<void> val); + + T ptr[max_card_]; // could be static + }; + + + // + // mlc::internal::array2d_elt_ + // + //////////////////////////////////////// + + template<class T, class Info> + struct array2d_elt_ + { + typedef array2d_elt_< T, typename Info::next_elt > + next_elt_t_; + + typedef array2d_elt_< T, array2d_info< Info::nrows, Info::ncols, Info::i, Info::i + 1> > + eat_center_t_; + + typedef array2d_elt_< T, array2d_info< Info::nrows, Info::i, Info::center, Info::i > > + eat_lbrk_t_; + + typedef array2d< array2d_info< Info::i / Info::ncols, Info::ncols, Info::get_real_center, Info::i > , T> + array2d_t_; + + public: + + // Constructor + + array2d_elt_(T* ptr, array2d_start_<T>* arr) : ptr(ptr), arr(arr) + { + } + + + // + // Overloading "operator," + // + + + // elt, elt + + next_elt_t_ operator,(T val) + { + is_true<Info::nrows == unknown_>::ensure(); + *ptr = val; + return next_elt_t_(ptr + 1, arr); + } + + + // elt, x(elt) -> center + + eat_center_t_ operator,(x_<T> val) + { + is_true<Info::center == unknown_>::ensure(); + *ptr = val.ue; // FIXME : give a *name* to this variable !! + return eat_center_t_(ptr + 1, arr); + } + + + // elt, x() -> center + + eat_center_t_ operator,(x_<void>) + { + is_true<Info::center == unknown_>::ensure(); + *ptr = T(0); + return eat_center_t_(ptr + 1, arr); + } + + + // elt, lbrk + + eat_lbrk_t_ operator,(lbrk_) + { + is_true<Info::ncols == unknown_>::ensure(); + is_true<Info::ncols != 0>::ensure(); + return eat_lbrk_t_(ptr, arr); + } + + + // elt, end + + array2d_t_ operator,(end_type) + { + enum { nrows = Info::i / Info::ncols }; + + // array is well-formed : + is_true<Info::well_formed == true>::ensure(); + // centering is automatic or user-defined : + + is_true<Info::ncols != unknown_>::ensure(); + + + // both nrows and ncols must be odd + // or the center must be user-defined + + is_true< + ((Info::ncols % 2 == 1) && (nrows % 2 == 1)) + || (Info::center != unknown_) + >::ensure(); + + return array2d_t_(arr->ptr); + } + + + // else -> error + + template<class U> + void operator,(array2d< Info, U >); + + template<class U> + here_a_value_is_not_of_type_<T> operator,(U u) const; + + T* ptr; + array2d_start_<T>* arr; + }; + + + + // + // mlc::internal::array2d_start_ impl + // + //////////////////////////////////////// + + template<class T> inline + array2d_elt_< T, array2d_info< unknown_, unknown_, unknown_, 1 > > + array2d_start_<T>::operator=(T val) + { + ptr[0] = val; + return array2d_elt_< T, array2d_info< unknown_, unknown_, unknown_, 1 > >(ptr+1,this); + } + + template<class T> inline + array2d_elt_< T, array2d_info< unknown_, unknown_, 0, 1 > > + array2d_start_<T>::operator=(x_<T> val) + { + ptr[0] = val.ue; + // center <- 0 + return array2d_elt_< T, array2d_info< unknown_, unknown_, 0, 1 > >(ptr+1,this); + } + + template<class T> inline + array2d_elt_< T, array2d_info< unknown_, unknown_, 0, 1 > > + array2d_start_<T>::operator=(x_<void> val) + { + ptr[0] = T(0); + // center <- 0 + return array2d_elt_< T, array2d_info< unknown_, unknown_, 0, 1 > >(ptr+1,this); + } + + } // end of internal + +} // end of mlc + +#endif // ! METALIC_ARRAY_2D_HXX Index: mlc/array/objs.hh --- mlc/array/objs.hh (revision 0) +++ mlc/array/objs.hh (revision 0) @@ -0,0 +1,78 @@ +// Copyright (C) 2001, 2002, 2003, 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_ARRAY_OBJS_HH +# define METALIC_ARRAY_OBJS_HH + +// FIXME: rename, objs is not precise enough. + +// +// Defines common objects useful for array declarations. +// + +namespace mlc +{ + + class begin_type {}; + class end_type {}; + + static const begin_type begin = begin_type(); + static const end_type end = end_type(); + + namespace internal + { + + class lbrk_ {}; + class pbrk_ {}; + + template<class T> + struct x_ { + x_(T val) : ue(val) {} + T ue; + }; + template<> struct x_<void> {}; + template<> struct x_<lbrk_>; + template<> struct x_<end_type>; + + } // end of internal + + // cross means origin + + template<class T> inline + internal::x_<T> + x(T val) { return internal::x_<T>(val); } + + inline + internal::x_<void> + x() { return internal::x_<void>(); } + + static const internal::lbrk_ lbrk = internal::lbrk_(); + static const internal::pbrk_ pbrk = internal::pbrk_(); + +} // end of mlc + +#endif // METALIC_ARRAY_OBJS_HH Index: mlc/array/3d.hxx --- mlc/array/3d.hxx (revision 0) +++ mlc/array/3d.hxx (revision 0) @@ -0,0 +1,293 @@ +// Copyright (C) 2001, 2002, 2003 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_ARRAY_3D_HXX +# define METALIC_ARRAY_3D_HXX + +# include <mlc/array/nd.hh> + +namespace mlc +{ + + // + // mlc::array3d_info + // + //////////////////////////////////////// + + + // nrows_ -> total number of rows (1-indexed) + // ncols_ -> total number of columns (1-indexed) + // nplanes_ -> total number of planes (1-indexed) + + // center_ -> position of the central element (0-indexed) + // domain : [ 0, card [ + + // i_ -> number of elements that have been eaten yet (0-indexed) + // domain : [ 0, card ] -> watch out !! + + // Center is user-defined + + template < unsigned nplanes_, + unsigned nrows_, + unsigned ncols_, + unsigned center_ = (ncols_ * nrows_) * (nplanes_ / 2) + ncols_ * (nrows_ / 2) + (ncols_ / 2), + unsigned i_ = nplanes_ * nrows_ * ncols_> + struct array3d_info + { + enum { + nplanes = nplanes_, + nrows = nrows_, + ncols = ncols_, + center = center_, + center_plane = center_ / (nrows_ * ncols_), + center_row = (center_ % (nrows_ * ncols_)) / ncols_, + center_col = (center_ % (nrows_ * ncols_)) % ncols_, + i = i_, + card = nplanes_ * nrows_ * ncols_, + well_formed = (i_ % (ncols_ * nrows) == 0), + get_real_center = center_ + }; + + typedef array3d_info< nplanes_, nrows_, ncols_, center_, i + 1 > next_elt; + + }; + + // Center is defined automatically, if nrows and ncols are both odd + + template < unsigned nplanes_, unsigned nrows_, unsigned ncols_, unsigned i_ > + struct array3d_info < nplanes_, nrows_, ncols_, internal::unknown_, i_ > + { + enum { + nplanes = nplanes_, + nrows = nrows_, + ncols = ncols_, + center = internal::unknown_, + i = i_, + card = nplanes_ * nrows_ * ncols_, + well_formed = (i_ % (ncols_ * nrows_) == 0), + get_real_center = i_ / 2 + }; + + typedef array3d_info< nplanes_, nrows_, ncols_, internal::unknown_, i + 1 > next_elt; + + }; + + // fwd decl + template<class, class> struct array3d; + + namespace internal + { + + // fwd decl + + template<class T, class Info> + struct array3d_elt_; + + // for error messages + + template<class U> + struct here_a_value_is_not_of_type_; + + + // + // mlc::internal::array3d_start_ decl + // + //////////////////////////////////////// + + template<class T> + struct array3d_start_ { + + array3d_elt_< T, array3d_info< unknown_, unknown_, unknown_, unknown_, 1 > > + operator=(T val); + + array3d_elt_< T, array3d_info< unknown_, unknown_, unknown_, 0, 1 > > + operator=(x_<T> val); + + array3d_elt_< T, array3d_info< unknown_, unknown_, unknown_, 0, 1 > > + operator=(x_<void> val); + + T ptr[max_card_]; // could be static + }; + + // + // mlc::internal::array3d_elt_ + // + //////////////////////////////////////// + + template<class T, class Info> + struct array3d_elt_ + { + typedef array3d_elt_< T, typename Info::next_elt > + next_elt_t_; + + typedef array3d_elt_< T, array3d_info< Info::nplanes, Info::nrows, Info::ncols, Info::i, Info::i + 1> > + eat_center_t_; + + typedef array3d_elt_< T, array3d_info< Info::nplanes, Info::nrows, Info::i, Info::center, Info::i > > + eat_lbrk_t_; + + typedef array3d_elt_< T, array3d_info< Info::nplanes, Info::i / Info::ncols, Info::ncols, Info::center, Info::i > > + eat_pbrk_t_; + + typedef array3d< array3d_info< Info::i / (Info::ncols * Info::nrows), Info::nrows, Info::ncols, Info::get_real_center, Info::i > , T> + array3d_t_; + + public: + + // Constructor + + array3d_elt_(T* ptr, array3d_start_<T>* arr) : ptr(ptr), arr(arr) + { + } + + + // + // Overloading "operator," + // + + + // elt, elt + + next_elt_t_ operator,(T val) + { + is_true<Info::nplanes == unknown_>::ensure(); + *ptr = val; + return next_elt_t_(ptr + 1, arr); + } + + + // elt, x(elt) -> center + + eat_center_t_ operator,(x_<T> val) + { + is_true<Info::center == unknown_>::ensure(); + *ptr = val.ue; // FIXME : give a *name* to this variable !! + return eat_center_t_(ptr + 1, arr); + } + + + // elt, x() -> center + + eat_center_t_ operator,(x_<void>) + { + is_true<Info::center == unknown_>::ensure(); + *ptr = T(0); + return eat_center_t_(ptr + 1, arr); + } + + + // elt, lbrk + + eat_lbrk_t_ operator,(lbrk_) + { + is_true<Info::ncols == unknown_>::ensure(); + return eat_lbrk_t_(ptr, arr); + } + + + // elt, pbrk + eat_pbrk_t_ operator,(pbrk_) + { + is_true<Info::nplanes == unknown_>::ensure(); + return eat_pbrk_t_(ptr, arr); + } + + // elt, end + + array3d_t_ operator,(end_type) + { + enum { nplanes = (Info::i / (Info::ncols * Info::nrows)) }; + + // array is well-formed : + is_true<Info::well_formed>::ensure(); + // centering is automatic or user-defined : + + is_true<Info::ncols != unknown_>::ensure(); + is_true<Info::nrows != unknown_>::ensure(); + + // all of nplanes, nrows and ncols are odd + // or the center is user-defined + + is_true< + (Info::ncols % 2 == 1 && Info::nrows % 2 == 1 && nplanes % 2 == 1) + || (Info::center != unknown_) + >::ensure(); + + return array3d_t_(arr->ptr); + } + + + // else -> error + + template<class U> + void operator,(array3d< Info, U >); + + template<class U> + here_a_value_is_not_of_type_<T> operator,(U u) const; + + T* ptr; + array3d_start_<T>* arr; + }; + + + // + // mlc::internal::array3d_start_ impl + // + //////////////////////////////////////// + + template<class T> inline + array3d_elt_< T, array3d_info< unknown_, unknown_, unknown_, unknown_, 1 > > + array3d_start_<T>::operator=(T val) + { + ptr[0] = val; + return array3d_elt_< T, array3d_info< unknown_, unknown_, unknown_, unknown_, 1 > >(ptr+1,this); + } + + template<class T> inline + array3d_elt_< T, array3d_info< unknown_, unknown_, unknown_, 0, 1 > > + array3d_start_<T>::operator=(x_<T> val) + { + ptr[0] = val.ue; + // center <- 0 + return array3d_elt_< T, array3d_info< unknown_, unknown_, unknown_, 0, 1 > >(ptr+1,this); + } + + template<class T> inline + array3d_elt_< T, array3d_info< unknown_, unknown_, unknown_, 0, 1 > > + array3d_start_<T>::operator=(x_<void> val) + { + ptr[0] = T(0); + // center <- 0 + return array3d_elt_< T, array3d_info< unknown_, unknown_, unknown_, 0, 1 > >(ptr+1,this); + } + + } // end of internal + +} // end of mlc + + +#endif // ! METALIC_ARRAY_3D_HXX

19 years, 1 month

proto-1.0 60: Import integre in proto-1.0

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * tests/utils: New. * tests/utils/tests: New. * tests/utils/tests/debug1: New. * tests/utils/Makefile.am: New. * tests/types: New. * tests/types/tests: New. * tests/types/tests/range3b: New. * tests/types/tests/range3c: New. * tests/types/tests/range3d: New. * tests/types/tests/int_s1: New. * tests/types/tests/int_s2: New. * tests/types/tests/range1: New. * tests/types/tests/range2: New. * tests/types/tests/range3: New. * tests/types/tests/range4: New. * tests/types/tests/int4b: New. * tests/types/tests/bin1: New. * tests/types/tests/bin2: New. * tests/types/tests/bin3: New. * tests/types/tests/sizes: New. * tests/types/tests/unsafe1: New. * tests/types/tests/unsafe2: New. * tests/types/tests/int_u5c: New. * tests/types/tests/float_r1: New. * tests/types/tests/float_r2: New. * tests/types/tests/int1b: New. * tests/types/tests/comp1: New. * tests/types/tests/comp2: New. * tests/types/tests/comp3: New. * tests/types/tests/conv1: New. * tests/types/tests/conv2: New. * tests/types/tests/builtin1: New. * tests/types/tests/float_c1: New. * tests/types/tests/vec1: New. * tests/types/tests/char1: New. * tests/types/tests/vec2: New. * tests/types/tests/op1: New. * tests/types/tests/int_u1: New. * tests/types/tests/vec3: New. * tests/types/tests/int_s2b: New. * tests/types/tests/op2: New. * tests/types/tests/vec4: New. * tests/types/tests/int_u2a: New. * tests/types/tests/vec5: New. * tests/types/tests/int_u2b: New. * tests/types/tests/int_u4: New. * tests/types/tests/vec6: New. * tests/types/tests/int_u2c: New. * tests/types/tests/vec7: New. * tests/types/tests/int_u2d: New. * tests/types/tests/int_u6: New. * tests/types/tests/optrait1a: New. * tests/types/tests/int_u7: New. * tests/types/tests/int_u2e: New. * tests/types/tests/optrait1b: New. * tests/types/tests/int_u8: New. * tests/types/tests/int_u2f: New. * tests/types/tests/int1: New. * tests/types/tests/int2: New. * tests/types/tests/int3: New. * tests/types/tests/int4: New. * tests/types/tests/int5: New. * tests/types/tests/int6: New. * tests/types/tests/range2b: New. * tests/types/tests/int7: New. * tests/types/tests/int6b: New. * tests/types/tests/int6c: New. * tests/types/tests/int6d: New. * tests/types/tests/float1: New. * tests/types/tests/cplx1: New. * tests/types/tests/float2: New. * tests/types/tests/cplx2: New. * tests/types/tests/cplx3: New. * tests/types/tests/cplx4: New. * tests/types/tests/cplx5: New. * tests/types/tests/ntg_compare_nb_comp: New. * tests/types/tests/cplx6: New. * tests/types/tests/int_sc1: New. * tests/types/tests/int_sc2: New. * tests/types/tests/int_u3a: New. * tests/types/tests/int_sc3: New. * tests/types/tests/int_u3b: New. * tests/types/tests/int_sc4: New. * tests/types/tests/int_sc5: New. * tests/types/tests/optrait3: New. * tests/types/tests/optrait2a: New. * tests/types/tests/optrait2b: New. * tests/types/runtests: New. * tests/types/Makefile.am: New. * ntg/real/builtin_properties.hh: New. * ntg/real/builtin_float.hh: New. * ntg/real/range.hh: New. * ntg/real/integer.hh: Remove. * ntg/real/behavior.hh: New. * ntg/real/cycle.hh: New. * ntg/real/optraits_builtin_int.hh: New. * ntg/real/int_u8.hh: Remove. * ntg/real/optraits_real.hh: New. * ntg/real/typetraits_builtin_int.hh: New. * ntg/real/optraits_real_defs.hh: New. * ntg/real/int_s.hh: New. * ntg/real/int_u.hh: New. * ntg/real/real_value.hh: New. * ntg/real/builtin_int.hh: New. * ntg/core/abstract_hierarchy.hh: New. * ntg/core/predecls.hh: New. * ntg/core/type.hh: New. * ntg/core/props.hh: Remove. * ntg/core/macros.hh: Import former macros from integre. * ntg/core/interval.hh: New. * ntg/core/pred_succ.hh: New. * ntg/core/type_traits.hh: New. * ntg/core/math.hh: New. * ntg/core/cats.hh: Remove. * ntg/core/value.hh: New. * ntg/core/contract.hh: New. * ntg/core/internal: New. * ntg/core/internal/global_ops.hh: New. * ntg/core/internal/global_ops_defs.hh: New. * ntg/core/internal/macros.hh: New. * ntg/core/internal/traits.hh: New. * ntg/core/internal/global_ops_traits.hh: New. * ntg/int.hh: New. * ntg/range.hh: New. * ntg/cycle.hh: New. * ntg/utils: New. * ntg/utils/debug.hh: New. * ntg/utils/cast.hh: New. * ntg/vect: New. * ntg/vect/cplx.hh: New. * ntg/vect/cplx_representation.hh: New. * ntg/vect/vect_value.hh: New. * ntg/vect/vec.hh: New. * ntg/basics.hh: New. * ntg/makefile.src: Add new files. * ntg/float.hh: New. * ntg/enum/builtin_bool.hh: New. * ntg/enum/enum.hh: Remove. * ntg/enum/bin.hh: Import from integre. * ntg/enum/enum_value.hh: New. * ntg/cplx.hh: New. * ntg/all.hh: Import from integre. * ntg/bin.hh: New. * ntg/Makefile.am: Import from integre. * ntg/vec.hh: New. * ntg/color.hh: New. * ntg/color/rgb_8.hh: Remove. * ntg/color/yiq.hh: New. * ntg/color/hsi.hh: New. * ntg/color/yuv.hh: New. * ntg/color/hsl.hh: New. * ntg/color/nrgb.hh: New. * ntg/color/rgb.hh: New. * ntg/color/xyz.hh: New. * ntg/color/color.hh: Import from integre. * ntg/color/hsv.hh: New. ntg/Makefile.am | 58 ++ ntg/all.hh | 26 + ntg/basics.hh | 61 +++ ntg/bin.hh | 37 + ntg/color.hh | 44 ++ ntg/color/color.hh | 311 +++++++++++++-- ntg/color/hsi.hh | 63 +++ ntg/color/hsl.hh | 54 ++ ntg/color/hsv.hh | 55 ++ ntg/color/nrgb.hh | 130 ++++++ ntg/color/rgb.hh | 58 ++ ntg/color/rgb_8.hh | 153 ------- ntg/color/xyz.hh | 54 ++ ntg/color/yiq.hh | 64 +++ ntg/color/yuv.hh | 63 +++ ntg/core/abstract_hierarchy.hh | 84 ++++ ntg/core/cats.hh | 77 --- ntg/core/contract.hh | 57 ++ ntg/core/internal/global_ops.hh | 243 ++++++++++++ ntg/core/internal/global_ops_defs.hh | 274 +++++++++++++ ntg/core/internal/global_ops_traits.hh | 213 ++++++++++ ntg/core/internal/macros.hh | 87 ++++ ntg/core/internal/traits.hh | 82 ++++ ntg/core/interval.hh | 118 +++++ ntg/core/macros.hh | 189 +++++++++ ntg/core/math.hh | 82 ++++ ntg/core/pred_succ.hh | 95 ++++ ntg/core/predecls.hh | 134 ++++++ ntg/core/props.hh | 77 --- ntg/core/type.hh | 139 +++++++ ntg/core/type_traits.hh | 66 +++ ntg/core/value.hh | 122 ++++++ ntg/cplx.hh | 37 + ntg/cycle.hh | 37 + ntg/enum/bin.hh | 259 ++++++++++--- ntg/enum/builtin_bool.hh | 87 ++++ ntg/enum/enum.hh | 97 ---- ntg/enum/enum_value.hh | 59 ++ ntg/float.hh | 38 + ntg/int.hh | 42 ++ ntg/makefile.src | 60 ++- ntg/range.hh | 37 + ntg/real/behavior.hh | 462 +++++++++++++++++++++++ ntg/real/builtin_float.hh | 427 +++++++++++++++++++++ ntg/real/builtin_int.hh | 38 + ntg/real/builtin_properties.hh | 162 ++++++++ ntg/real/cycle.hh | 187 +++++++++ ntg/real/int_s.hh | 580 +++++++++++++++++++++++++++++ ntg/real/int_u.hh | 412 ++++++++++++++++++++ ntg/real/int_u8.hh | 131 ------ ntg/real/integer.hh | 94 ---- ntg/real/optraits_builtin_int.hh | 92 ++++ ntg/real/optraits_real.hh | 148 +++++++ ntg/real/optraits_real_defs.hh | 213 ++++++++++ ntg/real/range.hh | 197 +++++++++ ntg/real/real_value.hh | 58 ++ ntg/real/typetraits_builtin_int.hh | 173 ++++++++ ntg/utils/cast.hh | 236 +++++++++++ ntg/utils/debug.hh | 94 ++++ ntg/vec.hh | 35 + ntg/vect/cplx.hh | 655 +++++++++++++++++++++++++++++++++ ntg/vect/cplx_representation.hh | 43 ++ ntg/vect/vec.hh | 443 ++++++++++++++++++++++ ntg/vect/vect_value.hh | 68 +++ tests/types/Makefile.am | 16 tests/types/runtests | 126 ++++++ tests/types/tests/bin1 | 30 + tests/types/tests/bin2 | 37 + tests/types/tests/bin3 | 37 + tests/types/tests/builtin1 | 31 + tests/types/tests/char1 | 33 + tests/types/tests/comp1 | 31 + tests/types/tests/comp2 | 31 + tests/types/tests/comp3 | 31 + tests/types/tests/conv1 | 31 + tests/types/tests/conv2 | 31 + tests/types/tests/cplx1 | 37 + tests/types/tests/cplx2 | 45 ++ tests/types/tests/cplx3 | 44 ++ tests/types/tests/cplx4 | 39 + tests/types/tests/cplx5 | 38 + tests/types/tests/cplx6 | 34 + tests/types/tests/float1 | 30 + tests/types/tests/float2 | 33 + tests/types/tests/float_c1 | 31 + tests/types/tests/float_r1 | 31 + tests/types/tests/float_r2 | 31 + tests/types/tests/int1 | 31 + tests/types/tests/int1b | 30 + tests/types/tests/int2 | 31 + tests/types/tests/int3 | 31 + tests/types/tests/int4 | 30 + tests/types/tests/int4b | 30 + tests/types/tests/int5 | 30 + tests/types/tests/int6 | 31 + tests/types/tests/int6b | 30 + tests/types/tests/int6c | 31 + tests/types/tests/int6d | 32 + tests/types/tests/int7 | 30 + tests/types/tests/int_s1 | 32 + tests/types/tests/int_s2 | 32 + tests/types/tests/int_s2b | 32 + tests/types/tests/int_sc1 | 35 + tests/types/tests/int_sc2 | 33 + tests/types/tests/int_sc3 | 32 + tests/types/tests/int_sc4 | 33 + tests/types/tests/int_sc5 | 30 + tests/types/tests/int_u1 | 30 + tests/types/tests/int_u2a | 30 + tests/types/tests/int_u2b | 30 + tests/types/tests/int_u2c | 30 + tests/types/tests/int_u2d | 31 + tests/types/tests/int_u2e | 31 + tests/types/tests/int_u2f | 32 + tests/types/tests/int_u3a | 31 + tests/types/tests/int_u3b | 31 + tests/types/tests/int_u4 | 30 + tests/types/tests/int_u5c | 31 + tests/types/tests/int_u6 | 32 + tests/types/tests/int_u7 | 31 + tests/types/tests/int_u8 | 37 + tests/types/tests/ntg_compare_nb_comp | 42 ++ tests/types/tests/op1 | 40 ++ tests/types/tests/op2 | 31 + tests/types/tests/optrait1a | 52 ++ tests/types/tests/optrait1b | 52 ++ tests/types/tests/optrait2a | 30 + tests/types/tests/optrait2b | 30 + tests/types/tests/optrait3 | 36 + tests/types/tests/range1 | 65 +++ tests/types/tests/range2 | 30 + tests/types/tests/range2b | 30 + tests/types/tests/range3 | 30 + tests/types/tests/range3b | 30 + tests/types/tests/range3c | 31 + tests/types/tests/range3d | 31 + tests/types/tests/range4 | 31 + tests/types/tests/sizes | 34 + tests/types/tests/unsafe1 | 31 + tests/types/tests/unsafe2 | 30 + tests/types/tests/vec1 | 33 + tests/types/tests/vec2 | 34 + tests/types/tests/vec3 | 36 + tests/types/tests/vec4 | 36 + tests/types/tests/vec5 | 34 + tests/types/tests/vec6 | 36 + tests/types/tests/vec7 | 34 + tests/utils/Makefile.am | 3 tests/utils/tests/debug1 | 41 ++ 149 files changed, 11214 insertions(+), 751 deletions(-) Index: tests/utils/tests/debug1 --- tests/utils/tests/debug1 (revision 0) +++ tests/utils/tests/debug1 (revision 0) @@ -0,0 +1,41 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +// #define NTG_DEBUG + +#include <ntg/int.hh> + +using namespace ntg; + +ntg_debug_define_vars(true) + +int main() +{ + int_u32 u = 65537U * 65535U; + u = u - 1; // ABORT +} Index: tests/utils/Makefile.am --- tests/utils/Makefile.am (revision 0) +++ tests/utils/Makefile.am (revision 0) @@ -0,0 +1,3 @@ +## Process this file with Automake to produce Makefile.in -*- Makefile -*- + +include ../check/Makefile.runtests Index: tests/types/tests/range3b --- tests/types/tests/range3b (revision 0) +++ tests/types/tests/range3b (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +range<int_u8, bounded_u<10, 13>, saturate> u = 20; +return u != 13; Index: tests/types/tests/range3c --- tests/types/tests/range3c (revision 0) +++ tests/types/tests/range3c (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +range<int_u8, bounded_u<10, 13>, saturate> u = 11; +u += u; +return u != 13; Index: tests/types/tests/range3d --- tests/types/tests/range3d (revision 0) +++ tests/types/tests/range3d (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +range<int_u8, bounded_u<10, 13>, saturate> u = 2; +u += 10; +return u != 13; Index: tests/types/tests/int_s1 --- tests/types/tests/int_s1 (revision 0) +++ tests/types/tests/int_s1 (revision 0) @@ -0,0 +1,32 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_s8 s1 = 10; +int_s16 s2 = -20; +int_s8 s3 = s1 + s2; +return s3 != -10; Index: tests/types/tests/int_s2 --- tests/types/tests/int_s2 (revision 0) +++ tests/types/tests/int_s2 (revision 0) @@ -0,0 +1,32 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_s8 s1 = 10; +int_s16 s2 = -200; +int_s8 s3 = s1 + s2; // ABORT +(void) s3; Index: tests/types/tests/range1 --- tests/types/tests/range1 (revision 0) +++ tests/types/tests/range1 (revision 0) @@ -0,0 +1,65 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +typedef range<int_u8, bounded_u<10, 13>, strict> t1; +typedef range<int, bounded_u<5, 72>, strict> t2; +typedef range<float_s, bounded_s<-15, 28>, strict> t3; + +t1 u = 10; +t2 v = 32U; +t3 w = -5.8; + +u = 11; +u = 12; +u = 13; + +ntg_is_a_(t1, unsigned_integer)::ensure(); +mlc_is_a_(t1, uint_value)::ensure(); + +ntg_is_a_(t2, signed_integer)::ensure(); +mlc_is_a_(t2, sint_value)::ensure(); + +ntg_is_a_(t3, decimal)::ensure(); +mlc_is_a_(t3, float_value)::ensure(); + +u + u; +u + 5; +5 + u; +u + int_u16(5); +int_u16(5) + u; + +u * v; +v * 5U; +u / v; + +u + w + v; +u + w * v; + +w + 5; + +return (u + v * w) != -172.6f; Index: tests/types/tests/range2 --- tests/types/tests/range2 (revision 0) +++ tests/types/tests/range2 (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +range<int_u8, bounded_u<10, 13>, strict> u = 14; // ABORT +(void) u; Index: tests/types/tests/range3 --- tests/types/tests/range3 (revision 0) +++ tests/types/tests/range3 (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +range<int_u8, bounded_u<10, 13>, saturate> u = 9; +return u != 10; Index: tests/types/tests/range4 --- tests/types/tests/range4 (revision 0) +++ tests/types/tests/range4 (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +range<int_u8, bounded_u<2, 5> > r1 = 3; +range<int_u16, bounded_u<2, 5> > r2 = 4; +return (r1 + r2) != 7; Index: tests/types/tests/int4b --- tests/types/tests/int4b (revision 0) +++ tests/types/tests/int4b (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u<7> i = 130; // ABORT +(void) i; Index: tests/types/tests/bin1 --- tests/types/tests/bin1 (revision 0) +++ tests/types/tests/bin1 (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +bin b1 = 1; +return !(b1 == true); Index: tests/types/tests/bin2 --- tests/types/tests/bin2 (revision 0) +++ tests/types/tests/bin2 (revision 0) @@ -0,0 +1,37 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +bin b1 = 1; +bin b2 = 0; + +return (min(b1, b2) != bin(0)) + || (min(b1, b1) != bin(1)) + || (min(b2, b2) != bin(0)) + || (max(b1, b2) != bin(1)) + || (max(b1, b1) != bin(1)) + || (max(b2, b2) != bin(0)); Index: tests/types/tests/bin3 --- tests/types/tests/bin3 (revision 0) +++ tests/types/tests/bin3 (revision 0) @@ -0,0 +1,37 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +bin b1 = 1; +bin b2 = 0; + +return ((b1 | b2) != (b1 || b2)) + || ((b1 | b1) != (b1 || b1)) + || ((b2 | b2) != (b2 || b2)) + || ((b1 & b2) != (b1 && b2)) + || ((b1 & b1) != (b1 && b1)) + || ((b2 & b2) != (b1 && b2)); Index: tests/types/tests/sizes --- tests/types/tests/sizes (revision 0) +++ tests/types/tests/sizes (revision 0) @@ -0,0 +1,34 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +// FIXME: add more exhaustive tests based on C_for_* instead of hard coded +// types + +return (sizeof(int_u8) != sizeof(unsigned char)) + || (sizeof(int_u16) != sizeof(unsigned short)) + || (sizeof(range<int_u8, bounded_u<0, 5>, strict>) != sizeof(unsigned char)); Index: tests/types/tests/unsafe1 --- tests/types/tests/unsafe1 (revision 0) +++ tests/types/tests/unsafe1 (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u<8, unsafe> u = 200; +u += 56; +return u != 0; Index: tests/types/tests/unsafe2 --- tests/types/tests/unsafe2 (revision 0) +++ tests/types/tests/unsafe2 (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u<7, unsafe> u = 140; +(void) u; Index: tests/types/tests/int_u5c --- tests/types/tests/int_u5c (revision 0) +++ tests/types/tests/int_u5c (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u32s i(4294967295U); +i = i + int_u32s(1); +return i != 4294967295U; Index: tests/types/tests/float_r1 --- tests/types/tests/float_r1 (revision 0) +++ tests/types/tests/float_r1 (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +typedef range<float_s, bounded_s<10, 30>, strict> sr; +sr f = 23.0; +return f <= 22.999 || f >= 23.001; Index: tests/types/tests/float_r2 --- tests/types/tests/float_r2 (revision 0) +++ tests/types/tests/float_r2 (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +typedef range<float_s, bounded_s<10, 20>, strict> sr; +sr f = 23.0; // ABORT +(void) f; Index: tests/types/tests/int1b --- tests/types/tests/int1b (revision 0) +++ tests/types/tests/int1b (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u<7,saturate> i = 130; +return i != 127; Index: tests/types/tests/comp1 --- tests/types/tests/comp1 (revision 0) +++ tests/types/tests/comp1 (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_s8 s = -127; +int_u16 u = 65535; +return s >= u || !(s < u); Index: tests/types/tests/comp2 --- tests/types/tests/comp2 (revision 0) +++ tests/types/tests/comp2 (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_s16 s = -32768; +int_u32 u = 4294967295U; +return s >= u || !(s < u); Index: tests/types/tests/comp3 --- tests/types/tests/comp3 (revision 0) +++ tests/types/tests/comp3 (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_s32 s = -2147483647-1; +int_u32 u = 4294967295U; +return s >= u || !(s < u); Index: tests/types/tests/conv1 --- tests/types/tests/conv1 (revision 0) +++ tests/types/tests/conv1 (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +float_s s = 255.8; +int_u8 u = s; // XFAIL: need discussion about float to int conversion +return u != 255; Index: tests/types/tests/conv2 --- tests/types/tests/conv2 (revision 0) +++ tests/types/tests/conv2 (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +float_s s = -128.8; +int_s8 u = s; // XFAIL:need discussion about float to int conversion +return u != -128; Index: tests/types/tests/builtin1 --- tests/types/tests/builtin1 (revision 0) +++ tests/types/tests/builtin1 (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u8 i = 11; +unsigned long l = 12; +return l < i; Index: tests/types/tests/float_c1 --- tests/types/tests/float_c1 (revision 0) +++ tests/types/tests/float_c1 (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +typedef cycle< float_s, bounded_s< 0, 360 > > sc; +sc f = -400.0; // f == 320.0 +return f <= 319.999 || f >= 320.001; Index: tests/types/tests/vec1 --- tests/types/tests/vec1 (revision 0) +++ tests/types/tests/vec1 (revision 0) @@ -0,0 +1,33 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +vec<3, int> foo; +foo[0] = 5; +foo[1] = 7; +foo[2] = 13; +return foo[0] + foo[1] + foo[2] != 25; Index: tests/types/tests/char1 --- tests/types/tests/char1 (revision 0) +++ tests/types/tests/char1 (revision 0) @@ -0,0 +1,33 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int a = ntg_max_val(char); +a = ntg_max_val(signed char); +a = ntg_max_val(unsigned char); + +return !a; Index: tests/types/tests/vec2 --- tests/types/tests/vec2 (revision 0) +++ tests/types/tests/vec2 (revision 0) @@ -0,0 +1,34 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +vec<3, int> v1; +v1[0] = 5; +v1[1] = 7; +v1[2] = 13; +vec<3, int> v2 = v1; +return v2 != v1; Index: tests/types/tests/op1 --- tests/types/tests/op1 (revision 0) +++ tests/types/tests/op1 (revision 0) @@ -0,0 +1,40 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u8 a = 2; +int_u8 b = a * a * a * a * a * a * a; // 128 +int_u16 c = b * a; // 256 +int_u16 d = c * b; // 32768 +int_u32 e = d * a; // 65536 +int_u32 f = (e + 1U) * int_u32(e - 1); // 4294967295 +return a != 2 + || b != 128 + || c != 256 + || d != 32768 + || e != 65536 + || f != 4294967295U; Index: tests/types/tests/int_u1 --- tests/types/tests/int_u1 (revision 0) +++ tests/types/tests/int_u1 (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u32 u = 65537U * 65535U; +return u != 4294967295U; Index: tests/types/tests/vec3 --- tests/types/tests/vec3 (revision 0) +++ tests/types/tests/vec3 (revision 0) @@ -0,0 +1,36 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +vec<3, int> v1; +v1[0] = 5; +v1[1] = 7; +v1[2] = 13; +vec<3, int> v2 = v1; +v2 += v2; +v1 *= 2; +return v2 != v1; Index: tests/types/tests/int_s2b --- tests/types/tests/int_s2b (revision 0) +++ tests/types/tests/int_s2b (revision 0) @@ -0,0 +1,32 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_s8 s1 = 10; +int_s16 s2 = -200; +int_s8 s3 = s1 - s2; // ABORT +(void) s3; Index: tests/types/tests/op2 --- tests/types/tests/op2 (revision 0) +++ tests/types/tests/op2 (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u32 a = 65536; +int_u32 b = (a + 1U) * int_u32(a - 1); +return b != 4294967295U; Index: tests/types/tests/vec4 --- tests/types/tests/vec4 (revision 0) +++ tests/types/tests/vec4 (revision 0) @@ -0,0 +1,36 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +vec<3, int_u16> v1; +v1[0] = 5; +v1[1] = 7; +v1[2] = 13; +vec<3, int_u32> v2 = v1; +v2 = v2 + v2; +v1 = v1 * int_u8(2); +return v2 != v1; Index: tests/types/tests/int_u2a --- tests/types/tests/int_u2a (revision 0) +++ tests/types/tests/int_u2a (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u32 u = 4; +u -= 5; // ABORT Index: tests/types/tests/vec5 --- tests/types/tests/vec5 (revision 0) +++ tests/types/tests/vec5 (revision 0) @@ -0,0 +1,34 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +vec<1, int_u16> v1; +v1[0] = 20; +vec<1, int_u32> v2 = v1; +v2 = v2; +v1 = 2 * v1 / 2; +return v2 != v1; Index: tests/types/tests/int_u2b --- tests/types/tests/int_u2b (revision 0) +++ tests/types/tests/int_u2b (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u32 u = 4; +u += -5; // ABORT Index: tests/types/tests/int_u4 --- tests/types/tests/int_u4 (revision 0) +++ tests/types/tests/int_u4 (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u32 u = 65537U * 65535U; +u = u - 1; // ABORT Index: tests/types/tests/vec6 --- tests/types/tests/vec6 (revision 0) +++ tests/types/tests/vec6 (revision 0) @@ -0,0 +1,36 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +vec<2, int_s<9> > v1; +v1[0] = 5; +v1[1] = -7; +v1 %= int_u8(3); +vec<2, int_s<9> > v2; +v2[0] = 2; +v2[1] = -1; +return v2 != v1; Index: tests/types/tests/int_u2c --- tests/types/tests/int_u2c (revision 0) +++ tests/types/tests/int_u2c (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u32 u = 0; +--u; // ABORT Index: tests/types/tests/vec7 --- tests/types/tests/vec7 (revision 0) +++ tests/types/tests/vec7 (revision 0) @@ -0,0 +1,34 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +vec<3, int_u16> v1; +v1[0] = 5; +v1[1] = 7; +v1[2] = 13; +int_u16 v2 = v1 * v1; +return v2 != 5 * 5 + 7 * 7 + 13 * 13; Index: tests/types/tests/int_u2d --- tests/types/tests/int_u2d (revision 0) +++ tests/types/tests/int_u2d (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u32 u = 0; +u--; // ABORT +std::cout << u << std::endl; Index: tests/types/tests/int_u6 --- tests/types/tests/int_u6 (revision 0) +++ tests/types/tests/int_u6 (revision 0) @@ -0,0 +1,32 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u8 a = 5; +int_s8 b = -a; + +return a != -b; Index: tests/types/tests/optrait1a --- tests/types/tests/optrait1a (revision 0) +++ tests/types/tests/optrait1a (revision 0) @@ -0,0 +1,52 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u32 u1 = ntg_max_val(int_u32); +int_u16 u2 = ntg_max_val(int_u16); +int_u8 u3 = ntg_max_val(int_u8); +int_s32 s1 = ntg_max_val(int_s32); +int_s16 s2 = ntg_max_val(int_s16); +int_s8 s3 = ntg_max_val(int_s8); +int_u32 u4 = ntg_min_val(int_u32); +int_u16 u5 = ntg_min_val(int_u16); +int_u8 u6 = ntg_min_val(int_u8); +int_s32 s4 = ntg_min_val(int_s32); +int_s16 s5 = ntg_min_val(int_s16); +int_s8 s6 = ntg_min_val(int_s8); +return u1 != 4294967295U + || u2 != 65535U + || u3 != 255 + || s1 != 2147483647 + || s2 != 32767 + || s3 != 127 + || u4 != 0 + || u5 != 0 + || u6 != 0 + || s4 != -2147483647-1 + || s5 != -32768 + || s6 != -128; Index: tests/types/tests/int_u7 --- tests/types/tests/int_u7 (revision 0) +++ tests/types/tests/int_u7 (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u16 a = 12; +char c = 3; +return a < c; Index: tests/types/tests/int_u2e --- tests/types/tests/int_u2e (revision 0) +++ tests/types/tests/int_u2e (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u32 u = 65536; +u *= 65537; // ABORT +std::cout << u << std::endl; Index: tests/types/tests/optrait1b --- tests/types/tests/optrait1b (revision 0) +++ tests/types/tests/optrait1b (revision 0) @@ -0,0 +1,52 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u32 u1 = ntg_max_val(int_u32); +int_u16 u2 = ntg_max_val(int_u16); +int_u8 u3 = ntg_max_val(int_u8); +int_s32 s1 = ntg_max_val(int_s32); +int_s16 s2 = ntg_max_val(int_s16); +int_s8 s3 = ntg_max_val(int_s8); +int_u32 u4 = ntg_min_val(int_u32); +int_u16 u5 = ntg_min_val(int_u16); +int_u8 u6 = ntg_min_val(int_u8); +int_s32 s4 = ntg_min_val(int_s32); +int_s16 s5 = ntg_min_val(int_s16); +int_s8 s6 = ntg_min_val(int_s8); +return u1 != ntg_sup_val(int_u32) + || u2 != ntg_sup_val(int_u16) + || u3 != ntg_sup_val(int_u8) + || s1 != ntg_sup_val(int_s32) + || s2 != ntg_sup_val(int_s16) + || s3 != ntg_sup_val(int_s8) + || u4 != ntg_inf_val(int_u32) + || u5 != ntg_inf_val(int_u16) + || u6 != ntg_inf_val(int_u8) + || s4 != ntg_inf_val(int_s32) + || s5 != ntg_inf_val(int_s16) + || s6 != ntg_inf_val(int_s8); Index: tests/types/tests/int_u8 --- tests/types/tests/int_u8 (revision 0) +++ tests/types/tests/int_u8 (revision 0) @@ -0,0 +1,37 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u8 u1 = (unsigned char) 56; +int_u8 u2 = (unsigned char) 153; +int_u32 u = 0U; + +for (unsigned i = 0; i < 5000000; ++i) + for (unsigned j = 0; j < 10; ++j) + u = u1 * u2 + int_u8u(i % 50); + +return u != 8617; Index: tests/types/tests/int_u2f --- tests/types/tests/int_u2f (revision 0) +++ tests/types/tests/int_u2f (revision 0) @@ -0,0 +1,32 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u16s a = 65535; +a *= 65538U; +std::cout << a << std::endl; +return a != 65535; Index: tests/types/tests/int1 --- tests/types/tests/int1 (revision 0) +++ tests/types/tests/int1 (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u<7,saturate> i = 130; +int_u<7,saturate> j = 127; +return i != j; Index: tests/types/tests/int2 --- tests/types/tests/int2 (revision 0) +++ tests/types/tests/int2 (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u<7,saturate> i = 130; +i += 10; +return i != 127; Index: tests/types/tests/int3 --- tests/types/tests/int3 (revision 0) +++ tests/types/tests/int3 (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u<7,saturate> i = 130; +i -= 10; +return i != 117; Index: tests/types/tests/int4 --- tests/types/tests/int4 (revision 0) +++ tests/types/tests/int4 (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u<7, strict> i = 130; // ABORT +(void) i; Index: tests/types/tests/int5 --- tests/types/tests/int5 (revision 0) +++ tests/types/tests/int5 (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u<7, strict> i = 120; +i += 10; // ABORT Index: tests/types/tests/int6 --- tests/types/tests/int6 (revision 0) +++ tests/types/tests/int6 (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u8 u8 = 250; +int_u<7, strict> u7 = 6; +u8 += u7; // ABORT Index: tests/types/tests/range2b --- tests/types/tests/range2b (revision 0) +++ tests/types/tests/range2b (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +range<int_u8, bounded_u<10, 13> > u = 14; // ABORT +(void) u; Index: tests/types/tests/int7 --- tests/types/tests/int7 (revision 0) +++ tests/types/tests/int7 (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u32 u = 4294967295U; +return u != 4294967295U; Index: tests/types/tests/int6b --- tests/types/tests/int6b (revision 0) +++ tests/types/tests/int6b (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u8 u8 = 250; +u8 += 6; // ABORT Index: tests/types/tests/int6c --- tests/types/tests/int6c (revision 0) +++ tests/types/tests/int6c (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u8 u8 = 250; +int_u<9, strict> u9 = 6; +u8 += u9; // ABORT Index: tests/types/tests/int6d --- tests/types/tests/int6d (revision 0) +++ tests/types/tests/int6d (revision 0) @@ -0,0 +1,32 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u8 u8 = 250; +int_u<9, strict> u9 = 6; +u9 += u8; +return u9 != 256; Index: tests/types/tests/float1 --- tests/types/tests/float1 (revision 0) +++ tests/types/tests/float1 (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +float_s pi = M_PI; +return sin(pi) == 0.0; Index: tests/types/tests/cplx1 --- tests/types/tests/cplx1 (revision 0) +++ tests/types/tests/cplx1 (revision 0) @@ -0,0 +1,37 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +cplx<rect, int> rect1(42, 51); +cplx<polar, float> polar1(rect1); +vec<2, int_u8> v1(rect1); +cplx<rect, float_s> rect2(v1); + +polar1 = rect2; +rect1 += 69; + +std::cout << rect1 << " | " << polar1 << " | " << rect2 << std::endl; Index: tests/types/tests/float2 --- tests/types/tests/float2 (revision 0) +++ tests/types/tests/float2 (revision 0) @@ -0,0 +1,33 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +float_s f = 0.25; +int_u8 a = 2; +f *= a; // f == 0.5 +f += a; // f == 2.5 +return f != 2.5; Index: tests/types/tests/cplx2 --- tests/types/tests/cplx2 (revision 0) +++ tests/types/tests/cplx2 (revision 0) @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +cplx<rect, float_d> rect1(4, 5); +cplx<rect, float_d> rect2(rect1); +cplx<polar, int> polar1(rect1); +cplx<polar, int> polar2(polar1); + + +rect1 += rect1; +rect1 *= rect1; +rect1 -= rect2; +rect1 /= rect2; + +polar1 += polar1; +polar1 *= polar1; +polar1 -= polar2; +polar1 /= polar2; + +std::cout << rect1 << " | " << polar1.to_rect() << std::endl; Index: tests/types/tests/cplx3 --- tests/types/tests/cplx3 (revision 0) +++ tests/types/tests/cplx3 (revision 0) @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +cplx<rect, float> rect1(4, 5); +cplx<rect, float> rect2(rect1); +cplx<polar, float_s> polar1(rect1); +cplx<polar, float_s> polar2(polar1); + +rect1 += polar2; +rect1 *= polar2; +rect1 -= polar2; +rect1 /= polar2; + +polar1 += rect2; +polar1 *= rect2; +polar1 -= rect2; +polar1 /= rect2; + +std::cout << rect1 << " | " << polar1.to_rect() << std::endl; Index: tests/types/tests/cplx4 --- tests/types/tests/cplx4 (revision 0) +++ tests/types/tests/cplx4 (revision 0) @@ -0,0 +1,39 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +vec<2, int_u16> v; +v[0] = 51; +v[1] = 69; +cplx<rect, int_u16> rect1(v); +cplx<rect, float_s> rect2(rect1[0], rect1[1]); +cplx<polar, double> polar1(rect1); +cplx<polar, double> polar2(rect2); +rect1 = 3 + polar1 + 2; +polar1 = 2 * (rect1 + 3 * polar1 / rect2.conj()) / 3; + +std::cout << rect1 << " | " << polar1.to_rect() << std::endl; Index: tests/types/tests/cplx5 --- tests/types/tests/cplx5 (revision 0) +++ tests/types/tests/cplx5 (revision 0) @@ -0,0 +1,38 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +vec<2, int_s16> v; +v[0] = 51; +v[1] = 69; +vec<2, int_s16> v2; +v2[0] = 0; +v2[1] = 0; +cplx<rect, int_u16> rect1(42, 42); +void(rect1 + rect1); +return 0; // FIXME +//return ((rect1 + v) != (v + rect1)) || ((v - rect1) + (rect1 - v) == v2); Index: tests/types/tests/ntg_compare_nb_comp --- tests/types/tests/ntg_compare_nb_comp (revision 0) +++ tests/types/tests/ntg_compare_nb_comp (revision 0) @@ -0,0 +1,42 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +bool should_just_compile; +should_just_compile = ntg_if_vectorial_nb_comp_(int); + +bool fail = false; +fail = fail || ntg_if_vectorial_nb_comp_(ntg::rgb_8) != 3; +typedef ntg::vec<3, bool> vec3; +typedef ntg::vec<4, bool> vec4; +fail = fail || ntg_if_vectorial_nb_comp_(vec3) != 3; +fail = fail || ntg_if_vectorial_nb_comp_(vec4) != 4; +fail = fail || ntg_compare_nb_comp_(int, ntg::rgb_8)::ret != 0; +fail = fail || ntg_compare_nb_comp_(int, float)::ret != 1; +fail = fail || ntg_compare_nb_comp_(vec3, ntg::rgb_8)::ret != 1; +fail = fail || ntg_compare_nb_comp_(vec4, ntg::rgb_8)::ret != 0; +return fail; Index: tests/types/tests/cplx6 --- tests/types/tests/cplx6 (revision 0) +++ tests/types/tests/cplx6 (revision 0) @@ -0,0 +1,34 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +cplx<rect, float_d> rect1(42, 51); +cplx<rect, float_d> rect2(rect1); +cplx<polar, float_d> polar1(rect1); +cplx<polar, float_d> polar2(polar1); + +return !(rect1 == rect2 && polar1 == polar2); Index: tests/types/tests/int_sc1 --- tests/types/tests/int_sc1 (revision 0) +++ tests/types/tests/int_sc1 (revision 0) @@ -0,0 +1,35 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +typedef cycle<int_s8, bounded_s<-128, +128> > int_s8c; +int_s8c a = 300; // a == 44 +int_s8c b = 10; +b -= 20; // b == -10 +int_s8c c = b; +c -= 290; // c == -44 +return a != 44 || b != -10 || c != -a || c + a != 0; Index: tests/types/tests/int_sc2 --- tests/types/tests/int_sc2 (revision 0) +++ tests/types/tests/int_sc2 (revision 0) @@ -0,0 +1,33 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +typedef cycle<int_s8, bounded_s<-3, +12> > type; +type a = 14; // a = -1 +type b = a * 2; // b = -2 +type c = b * 2; // c = 11 +return a != -1 || b != -2 || c != 11; Index: tests/types/tests/int_u3a --- tests/types/tests/int_u3a (revision 0) +++ tests/types/tests/int_u3a (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u32 u = 65537U * 65535U; +u--; +return u != 4294967294U; Index: tests/types/tests/int_sc3 --- tests/types/tests/int_sc3 (revision 0) +++ tests/types/tests/int_sc3 (revision 0) @@ -0,0 +1,32 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +typedef cycle<int_s8, bounded_s<-128, +127> > int_s8c; +int_s8c a = 255; // a == 0 +int_s8c b = 256; // b == 1 +return a != 0 || b != 1; Index: tests/types/tests/int_u3b --- tests/types/tests/int_u3b (revision 0) +++ tests/types/tests/int_u3b (revision 0) @@ -0,0 +1,31 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +int_u32 u = 65537U * 65535U; +--u; +return u != 4294967294U; Index: tests/types/tests/int_sc4 --- tests/types/tests/int_sc4 (revision 0) +++ tests/types/tests/int_sc4 (revision 0) @@ -0,0 +1,33 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +typedef cycle<int_u32, bounded_u<0, 65536U * 65536U - 10> > int_u32c; +int_u32c a = 65536; // a == 65536 +a *= 65537; // a == 65446 // XFAIL: don't know how to calculate + // modulus when an overflow occurs +return a != 65546; Index: tests/types/tests/int_sc5 --- tests/types/tests/int_sc5 (revision 0) +++ tests/types/tests/int_sc5 (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +cycle<int_u8, bounded_u<0,5> > c1 = 1U; +return !c1; Index: tests/types/tests/optrait3 --- tests/types/tests/optrait3 (revision 0) +++ tests/types/tests/optrait3 (revision 0) @@ -0,0 +1,36 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +float_s s1 = ntg_sup_val(float_s); +float_d d1 = ntg_sup_val(float_d); +float_s s2 = ntg_inf_val(float_s); +float_d d2 = ntg_inf_val(float_d); +return s1 != NTG_FLOAT_INFINITY + || d1 != NTG_DOUBLE_INFINITY + || s2 != - NTG_FLOAT_INFINITY + || d2 != - NTG_DOUBLE_INFINITY; Index: tests/types/tests/optrait2a --- tests/types/tests/optrait2a (revision 0) +++ tests/types/tests/optrait2a (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +float_s s = ntg_max_val(float_s); // COMPFAIL +(void) s; Index: tests/types/tests/optrait2b --- tests/types/tests/optrait2b (revision 0) +++ tests/types/tests/optrait2b (revision 0) @@ -0,0 +1,30 @@ +// -*- c++ -*- +// Copyright (C) 2004 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. + +float_d s = ntg_min_val(float_d); // COMPFAIL +(void) s; Index: tests/types/runtests --- tests/types/runtests (revision 0) +++ tests/types/runtests (revision 0) @@ -0,0 +1,126 @@ +#!/bin/sh + +if test "x$VERBOSE" != x; then + verb='echo' + quiet='' +else + verb=':' + quiet='-q' +fi + +exec 6>&2 +. ../check/defs +exec 2>&6 + +failures=0 + +indir=${SRCDIR-.}/tests +rundir=runs +test -d $rundir || mkdir $rundir + +if test "$# = 0 -a ${TESTS+set}"; then + set $TESTS +fi + +# If no tests were given on the command line, get the list from $indir. +if test $# = 0; then + set dummy $indir/* + shift +fi + +for test; do + if test -d $test; then continue; fi + echo $test | grep '~$' && continue; + # We want only the basename of $test. + test=`basename "$test"` + fail=0 + dir=$rundir/$test + input=$indir/$test + test -f $input || { + echo "FAIL: $test (does not exist)" >&2 + failures=`expr $failures + 1` + continue; } + rm -rf $dir + mkdir $dir + # Build the source code to compile. + src=$dir/$test.cc + cat >$src <<'EOF' +#include <ntg/all.hh> +using namespace ntg; +int main() { +EOF + cat $input >>$src + echo '}' >>$src + # Build the compile script (using such a script make it easier + # to debug failures); + cat >$dir/try <<EOF +exec 6>&2 +if test "x\$1" = "x-q"; then + exec 2>$dir/cxx.errors +else + echo $CXX $CPPFLAGS $CXXFLAGS $LDFLAGS $dir/$test.cc +fi +$CXX $CPPFLAGS $CXXFLAGS $LDFLAGS "$dir/$test.cc" -o "$dir/test$EXEEXT" || exit 50 + +if test "x\$1" = "x-q"; then + exec 2>$dir/run.errors +else + echo $dir/test$EXEEXT +fi +$dir/test$EXEEXT +estatus=\$? + +exec 2>&6 +echo \$estatus > $dir/exit.status +exit \$estatus +EOF + chmod +x $dir/try + + # Do we expect a failure? + expected=ok + grep '//.*ABORT' $input >/dev/null && expected=abort + grep '//.*COMPFAIL' $input >/dev/null && expected=compfail + + # Do we know the test fails ? + xfail=no + grep '//.*XFAIL' $input >/dev/null && xfail=yes + + # Run the test. + $verb ========== Running $test... >&2 + ($SHELL $dir/try "$quiet" "$dir") + estatus=$? + + msg=""; + case $expected:$estatus in + ok:0 | compfail:50 | abort:134) + if test ! x"$KEEP_RUNS" = x"1"; then + rm -rf "$dir"; + fi + msg="(ok)" ;; + *:50) msg="(doesn't compile)" ;; + *:134) msg="(aborts at run-time)" ;; + compfail:*) msg="(compiles!)" ;; + abort:*) msg="(doesn't abort!)" ;; + ok:*) msg="(exits with \$?=$estatus)" ;; + *) ;; + esac + if test x"$msg" != x"(ok)"; then + if test "$xfail" = "no"; then + echo "FAIL: $test $msg" >&2 + failures=`expr $failures + 1` + else + echo "XFAIL: $test $msg" >&2 + fi + else + echo "PASS: $test" >&2 + fi +done + +echo ========================================>&2 +if test $failures = 0; then + echo No failures. >&2 + exit 0 +else + echo $failures failures. >&2 + exit 1 +fi Property changes on: tests/types/runtests ___________________________________________________________________ Name: svn:executable + * Index: tests/types/Makefile.am --- tests/types/Makefile.am (revision 0) +++ tests/types/Makefile.am (revision 0) @@ -0,0 +1,16 @@ +## Process this file with Automake to produce Makefile.in -*- Makefile -*- + +EXTRA_DIST = tests runtests + +CLEANFILES = test.core + +check-local: + TOP_SRCDIR=$(top_srcdir) SRCDIR=$(srcdir) \ + TOP_BUILDDIR=$(top_builddir) \ + LDFLAGS="$(LDFLAGS)" \ + CPPFLAGS="$(CPPFLAGS) $(DEFS) -I$(top_builddir)" \ + CXXFLAGS="$(CXXFLAGS) $(CXXFLAGS_OPTIMIZE) $(CXXFLAGS_STRICT_ERRORS)" \ + $(SHELL) $(srcdir)/runtests + +distclean-local: + rm -rf runs Index: ntg/real/builtin_properties.hh --- ntg/real/builtin_properties.hh (revision 0) +++ ntg/real/builtin_properties.hh (revision 0) @@ -0,0 +1,162 @@ +// Copyright (C) 2001, 2002, 2003 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_REAL_BUILTIN_PROPERTIES_HH +# define NTG_REAL_BUILTIN_PROPERTIES_HH + +# include <mlc/math.hh> + +# include <limits.h> +# include <float.h> + +namespace ntg +{ + + /*-------------------. + | C_for_ntg integers | + `-------------------*/ + + template<unsigned nbits> + struct C_for_int_u + { + enum { + mbits = mlc::pow2sup<nbits>::value + }; + typedef typename C_for_int_u<mbits>::type type; + static type max() { + return type((type(1) << nbits) - type(1)); + } + }; + + template<unsigned nbits> + struct C_for_int_s + { + enum { mbits = mlc::pow2sup<nbits>::value }; + typedef typename C_for_int_s<mbits>::type type; + static type min() { + return type(- max() - type(1)); + } + static type max() { + return type((type(1) << (nbits-1)) - type(1)); + } + }; + + template<> + struct C_for_int_u<8> + { + typedef unsigned char type; + static type max() { return UCHAR_MAX; } + }; + + + template<> + struct C_for_int_s<8> + { + typedef signed char type; + static type min() { return CHAR_MIN; } + static type max() { return CHAR_MAX; } + }; + + template<> + struct C_for_int_u<16> + { + typedef unsigned short type; + static type max() { return USHRT_MAX; } + }; + + template<> + struct C_for_int_s<16> + { + typedef signed short type; + static type min() { return SHRT_MIN; } + static type max() { return SHRT_MAX; } + }; + + template<> + struct C_for_int_u<32> + { + typedef unsigned int type; + static type max() { return UINT_MAX; } + }; + + template<> + struct C_for_int_s<32> + { + typedef signed int type; + static type min() { return INT_MIN; } + static type max() { return INT_MAX; } + }; + + // TODO: add 64 bits integers support is they are available. + + /*----------------. + | C_for_ntg float | + `----------------*/ + + // FIXME: this code is not used anywhere, maybe it should be + // removed. + + struct C_for_float_s + { + typedef float type; + static type min() { return FLT_MIN; } + static type max() { return FLT_MAX; } + }; + + struct C_for_float_d + { + typedef double type; + static type min() { return DBL_MIN; } + static type max() { return DBL_MAX; } + }; + + // IEEE : Take a look at epsilon for some conditional (FIXME) + + // FLT_RADIX 2 + // FLT_MANT_DIG 24 + // FLT_DIG 6 + // FLT_MIN_EXP -125 + // FLT_MIN_10_EXP -37 + // FLT_MAX_EXP 128 + // FLT_MAX_10_EXP +38 + // FLT_MIN 1.17549435E-38F + // FLT_MAX 3.40282347E+38F + // FLT_EPSILON 1.19209290E-07F + + // DBL_MANT_DIG 53 + // DBL_DIG 15 + // DBL_MIN_EXP -1021 + // DBL_MIN_10_EXP -307 + // DBL_MAX_EXP 1024 + // DBL_MAX_10_EXP 308 + // DBL_MAX 1.7976931348623157E+308 + // DBL_MIN 2.2250738585072014E-308 + // DBL_EPSILON 2.2204460492503131E-016 + +} // end of ntg. + +#endif // !NTG_REAL_BUILTIN_PROPERTIES_HH Index: ntg/real/builtin_float.hh --- ntg/real/builtin_float.hh (revision 0) +++ ntg/real/builtin_float.hh (revision 0) @@ -0,0 +1,427 @@ +// Copyright (C) 2002, 2003 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_REAL_BUILTIN_FLOAT_HH +# define NTG_REAL_BUILTIN_FLOAT_HH + +# include <ntg/config/system.hh> +# include <ntg/real/behavior.hh> +# include <ntg/core/internal/global_ops_traits.hh> +# include <ntg/core/internal/traits.hh> +# include <ntg/real/builtin_properties.hh> +# include <ntg/real/optraits_real.hh> +# include <ntg/core/predecls.hh> + +# include <mlc/cmp.hh> + +namespace ntg { + + namespace internal { + + /*------------------. + | typetraits<float> | + `------------------*/ + + template <> + struct typetraits<float> : public typetraits<float_value<float> > + { + typedef float self; + typedef decimal abstract_type; + typedef self ntg_type; + + ntg_build_value_type(float_value<E>); + + typedef optraits<self> optraits_type; + typedef unsafe::get<self> behavior_type; + typedef unsafe abstract_behavior_type; + + typedef self base_type; + typedef self storage_type; + typedef self signed_type; + typedef self unsigned_type; + typedef self cumul_type; + typedef self largest_type; + typedef self signed_largest_type; + typedef self signed_cumul_type; + typedef self unsigned_largest_type; + typedef self unsigned_cumul_type; + typedef self integer_type; + }; + + /*-------------------. + | typetraits<double> | + `-------------------*/ + + template <> + struct typetraits<double> : public typetraits<float_value<double> > + { + typedef double self; + typedef decimal abstract_type; + typedef self ntg_type; + + ntg_build_value_type(float_value<E>); + + typedef optraits<self> optraits_type; + typedef unsafe::get<self> behavior_type; + typedef unsafe abstract_behavior_type; + + typedef self base_type; + typedef self storage_type; + typedef self signed_type; + typedef self unsigned_type; + typedef self cumul_type; + typedef self largest_type; + typedef self signed_largest_type; + typedef self signed_cumul_type; + typedef self unsigned_largest_type; + typedef self unsigned_cumul_type; + typedef self integer_type; + }; + + /*----------------. + | optraits<float> | + `----------------*/ + + template <> + struct optraits<float> : public optraits<float_value<float> > + { + private: + typedef float self; + typedef typetraits<self>::storage_type storage_type_; + + public: + // Don't define min() and max() for float and double. + // This is error-prone because max()-1 == max(). + // Furthermore max()-min() can't be computed. + static storage_type_ sup() { return NTG_FLOAT_INFINITY; } + static storage_type_ inf() { return - sup (); } + static std::string name() { return "float"; } + }; + + /*--------------------------. + | operator traits for float | + `--------------------------*/ + + struct all_float_traits + { + enum { commutative = true }; + typedef float ret; + typedef float impl; + }; + + // + // plus + // + + template <unsigned nbits, class B> + struct operator_traits<operator_plus, float, int_u<nbits, B> > + : all_float_traits {}; + + template <unsigned nbits, class B> + struct operator_traits<operator_plus, float, int_s<nbits, B> > + : all_float_traits {}; + + // We need this because ntg_cast(float) gives float. + // So when using cycle<float,..> + float, it searches + // operator_traits<operator_plus, float,float> + template <> + struct operator_traits<operator_plus, float, float> + : all_float_traits {}; + + // + // minus + // + + template <unsigned nbits, class B> + struct operator_traits<operator_minus, float, int_u<nbits, B> > + : all_float_traits {}; + + template <unsigned nbits, class B> + struct operator_traits<operator_minus, float, int_s<nbits, B> > + : all_float_traits {}; + + template <> + struct operator_traits<operator_minus, float, float> + : all_float_traits {}; + + // + // times + // + + template <unsigned nbits, class B> + struct operator_traits<operator_times, float, int_u<nbits, B> > + : all_float_traits {}; + + template <unsigned nbits, class B> + struct operator_traits<operator_times, float, int_s<nbits, B> > + : all_float_traits {}; + + template <> + struct operator_traits<operator_times, float, float> + : all_float_traits {}; + + // + // div + // + + template <unsigned nbits, class B> + struct operator_traits<operator_div, float, int_u<nbits, B> > + : all_float_traits {}; + + template <unsigned nbits, class B> + struct operator_traits<operator_div, float, int_s<nbits, B> > + : all_float_traits {}; + + template <> + struct operator_traits<operator_div, float, float> + : all_float_traits {}; + + // + // min + // + + template <unsigned nbits, class B> + struct operator_traits<operator_min, float, int_u<nbits, B> > + : all_float_traits {}; + + template <unsigned nbits, class B> + struct operator_traits<operator_min, float, int_s<nbits, B> > + : all_float_traits {}; + + template <> + struct operator_traits<operator_min, float, float> + : all_float_traits {}; + + // + // max + // + + template <unsigned nbits, class B> + struct operator_traits<operator_max, float, int_u<nbits, B> > + : all_float_traits {}; + + template <unsigned nbits, class B> + struct operator_traits<operator_max, float, int_s<nbits, B> > + : all_float_traits {}; + + template <> + struct operator_traits<operator_max, float, float> + : all_float_traits {}; + + // + // Comparison + // + + template <unsigned nbits, class B> + struct operator_traits<operator_cmp, float, int_u<nbits, B> > + : all_float_traits {}; + + template <unsigned nbits, class B> + struct operator_traits<operator_cmp, float, int_s<nbits, B> > + : all_float_traits {}; + + template <> + struct operator_traits<operator_cmp, float, float> + : all_float_traits {}; + + /*-----------------. + | optraits<double> | + `-----------------*/ + + template <> + struct optraits<double> : public optraits<float_value<double> > + { + private: + // shortcuts + typedef double self; + typedef typetraits<self>::storage_type storage_type_; + + public: + // Don't define min() and max() for float and double. + // This is error-prone because max()-1 == max(). + // Furthermore max()-min() can't be computed. + static storage_type_ sup() { return NTG_DOUBLE_INFINITY; } + static storage_type_ inf() { return - sup (); } + static std::string name() { return "double"; } + }; + + /*---------------------------. + | operator traits for double | + `---------------------------*/ + + struct all_double_traits + { + enum { commutative = true }; + typedef double ret; + typedef double impl; + }; + + // + // plus + // + + template <unsigned nbits, class B> + struct operator_traits<operator_plus, double, int_u<nbits, B> > + : all_double_traits {}; + + template <unsigned nbits, class B> + struct operator_traits<operator_plus, double, int_s<nbits, B> > + : all_double_traits {}; + + template <> + struct operator_traits<operator_plus, double, double> + : all_double_traits {}; + + template <> + struct operator_traits<operator_plus, double, float> + : all_double_traits {}; + + // + // minus + // + + template <unsigned nbits, class B> + struct operator_traits<operator_minus, double, int_u<nbits, B> > + : all_double_traits {}; + + template <unsigned nbits, class B> + struct operator_traits<operator_minus, double, int_s<nbits, B> > + : all_double_traits {}; + + template <> + struct operator_traits<operator_minus, double, double> + : all_double_traits {}; + + template <> + struct operator_traits<operator_minus, double, float> + : all_double_traits {}; + + // + // times + // + + template <unsigned nbits, class B> + struct operator_traits<operator_times, double, int_u<nbits, B> > + : all_double_traits {}; + + template <unsigned nbits, class B> + struct operator_traits<operator_times, double, int_s<nbits, B> > + : all_double_traits {}; + + template <> + struct operator_traits<operator_times, double, double> + : all_double_traits {}; + + template <> + struct operator_traits<operator_times, double, float> + : all_double_traits {}; + + // + // div + // + + template <unsigned nbits, class B> + struct operator_traits<operator_div, double, int_u<nbits, B> > + : all_double_traits {}; + + template <unsigned nbits, class B> + struct operator_traits<operator_div, double, int_s<nbits, B> > + : all_double_traits {}; + + template <> + struct operator_traits<operator_div, double, double> + : all_double_traits {}; + + template <> + struct operator_traits<operator_div, double, float> + : all_double_traits {}; + + // + // min + // + + template <unsigned nbits, class B> + struct operator_traits<operator_min, double, int_u<nbits, B> > + : all_double_traits {}; + + template <unsigned nbits, class B> + struct operator_traits<operator_min, double, int_s<nbits, B> > + : all_double_traits {}; + + template <> + struct operator_traits<operator_min, double, double> + : all_double_traits {}; + + template <> + struct operator_traits<operator_min, double, float> + : all_double_traits {}; + + // + // max + // + + template <unsigned nbits, class B> + struct operator_traits<operator_max, double, int_u<nbits, B> > + : all_double_traits {}; + + template <unsigned nbits, class B> + struct operator_traits<operator_max, double, int_s<nbits, B> > + : all_double_traits {}; + + template <> + struct operator_traits<operator_max, double, double> + : all_double_traits {}; + + template <> + struct operator_traits<operator_max, double, float> + : all_double_traits {}; + + // + // Comparison + // + + template <unsigned nbits, class B> + struct operator_traits<operator_cmp, double, int_u<nbits, B> > + : all_double_traits {}; + + template <unsigned nbits, class B> + struct operator_traits<operator_cmp, double, int_s<nbits, B> > + : all_double_traits {}; + + template <> + struct operator_traits<operator_cmp, double, double> + : all_double_traits {}; + + template <> + struct operator_traits<operator_cmp, double, float> + : all_double_traits {}; + + } // end of internal. + +} // end of ntg. + +#endif // !NTG_REAL_BUILTIN_FLOAT_HH Index: ntg/real/range.hh --- ntg/real/range.hh (revision 0) +++ ntg/real/range.hh (revision 0) @@ -0,0 +1,197 @@ +// Copyright (C) 2001, 2002, 2003 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_REAL_RANGE_HH +# define NTG_REAL_RANGE_HH + +# include <mlc/is_a.hh> + +# include <ntg/basics.hh> +# include <ntg/core/internal/macros.hh> +# include <ntg/real/optraits_real.hh> + +# include <string> +# include <sstream> + +namespace ntg { + + namespace internal { + + /*------------------. + | typetraits<range> | + `------------------*/ + + template <class T, class interval, class behavior> + struct typetraits<range<T, interval, behavior> > : public typetraits<T> + { + typedef range<T, interval, behavior> self; + typedef ntgi_abstract_type(T) abstract_type; + typedef self ntg_type; + typedef optraits<self> optraits_type; + typedef typename behavior::template get<self> behavior_type; + typedef behavior abstract_behavior_type; + + typedef ntgi_base_type(T) base_type; + typedef T storage_type; + typedef ntgi_signed_type(T) signed_type; + typedef ntgi_unsigned_type(T) unsigned_type; + typedef ntgi_cumul_type(T) cumul_type; + typedef ntgi_largest_type(T) largest_type; + typedef ntgi_signed_largest_type(T) signed_largest_type; + typedef ntgi_signed_cumul_type(T) signed_cumul_type; + typedef ntgi_unsigned_largest_type(T) unsigned_largest_type; + typedef ntgi_unsigned_cumul_type(T) unsigned_cumul_type; + typedef ntgi_integer_type(T) integer_type; + }; + + } // end of internal. + + /*-----------------------------. + | range<T, Interval, Behavior> | + `-----------------------------*/ + + //! Restrict the interval of a type. + /* + Range is a decorator. Thanks to the build_value_type helper in + typetraits, it can insert into a precise place of the hierarchy, + depending on T. + */ + template <class T, class interval, class behavior> + class range : + public type_traits<T>::template build_value_type<range<T, interval, behavior> >::ret + { + public: + typedef range<T, interval, behavior> self; + + private: + typedef ntgi_optraits_type(self) optraits_type; + typedef ntg_base_type(self) base_type; + typedef ntg_storage_type(base_type) base_storage_type; + + public: + range () { this->val_ = 0; } + + template <class U> + range (const U& u) + { + ntg_is_a(U, real)::ensure(); + this->val_ = optraits_type::check(u); + } + template <class U> + self& + operator=(const U& u) + { + this->val_ = optraits_type::check(u); + return *this; + } + + template <class U> + operator U() const { return this->val_; } + }; + + template<class T, class interval, class behavior> + inline std::ostream& + operator<<(std::ostream& stream, const range<T, interval, behavior>& rhs) + { + // Cast useful for range<unsigned char, ...> + stream << (ntg_largest_type(T))(rhs.val()); + return stream; + } + + namespace internal { + + /*----------------. + | optraits<range> | + `----------------*/ + + template<class T, class interval, class behavior> + struct optraits<range<T, interval, behavior> > : public optraits<T> + { + public: + typedef range<T, interval, behavior> self; + + private: + typedef typename typetraits<self>::storage_type storage_type_; + typedef typename behavior::template get<self> behavior_type_; + typedef typename interval::storage_type interval_type_; + + public: + template <class P> + static storage_type_ check(const P& rhs) + { return behavior_type_::check(rhs); } + + static interval_type_ min() + { return interval::min(); } + + static interval_type_ max() + { return interval::max(); } + + static interval_type_ inf() + { return interval::inf(); } + + static interval_type_ sup() + { return interval::sup(); } + + static std::string + name() + { + std::ostringstream out; + out << "range<" << optraits<T>::name() << ", " << interval::name() + << ", " << behavior::name() << ">"<< std::ends; + return out.str(); + } + }; + + /*----------------. + | operator traits | + `----------------*/ + + // Inherit operator traits from the base type. + template <class Op, class T, class I, class B, class U> + struct operator_traits<Op, range<T, I, B>, U> + : public deduce_from_traits<Op, T, U>::deduced_traits + {}; + + // Inherit operator traits from the base type. + template <class Op, class T, class I, class B, class U> + struct operator_traits<Op, U, range<T, I, B> > + : public deduce_from_traits<Op, U, T>::deduced_traits + {}; + + // Inherit operator traits from the base type. + template <class Op, + class T1, class I1, class B1, + class T2, class I2, class B2> + struct operator_traits<Op, range<T1, I1, B1>, range<T2, I2, B2> > + : public deduce_from_traits<Op, T1, T2>::deduced_traits + {}; + + } // end of internal. + +} // end of ntg. + +#endif // !NTG_REAL_RANGE_HH Index: ntg/real/integer.hh --- ntg/real/integer.hh (revision 59) +++ ntg/real/integer.hh (working copy) @@ -1,94 +0,0 @@ -// 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 INTEGRE_REAL_INTEGER_HH -# define INTEGRE_REAL_INTEGER_HH - -# include <mlc/any.hh> -# include <mlc/types.hh> - -# include <ntg/core/cats.hh> -# include <ntg/core/props.hh> - -namespace ntg { - - template <typename E> struct integer; - - template <typename E> - struct category_type< integer<E> > { typedef cat::integer ret; }; - - template <> - struct default_props < cat::integer > - { - enum { max_val = 0 }; - typedef mlc::no_type io_type; - - protected: - default_props() {} - }; - - template <typename E> - struct integer : public mlc::any__best_memory<E> - { - typedef E exact_type; - - template <typename V> - exact_type& operator=(const V& rhs) - { - return this->exact().impl_assign(rhs); - } - - bool operator==(int rhs) const - { - return this->exact().impl_eq(rhs); - } - - template <typename I> - bool operator==(const integer<I>& rhs) const - { - return this->exact().impl_eq(rhs.exact()); - } - - template <typename V> - bool operator!=(const V& rhs) const - { - return ! this->operator==(rhs); - } - - template <typename V> - exact_type& operator+(const V& rhs) const - { - return this->exact().impl_add(rhs); - } - - protected : - integer() {} - }; - -} - -#endif // ! INTEGRE_REAL_INTEGER_HH Index: ntg/real/behavior.hh --- ntg/real/behavior.hh (revision 0) +++ ntg/real/behavior.hh (revision 0) @@ -0,0 +1,462 @@ +// Copyright (C) 2001, 2002, 2003, 2004 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_REAL_BEHAVIOUR_HH +# define NTG_REAL_BEHAVIOUR_HH + +/* + Behaviors for real datatypes int_u, int_s, etc ... + + <WARNING> Don't forget that behaviors are checked on assignements + and contruction of types, and use comparison, so create only vars + with unsafe behaviors in comparison operators implementation. +*/ + +# include <mlc/bool.hh> +# include <mlc/contract.hh> +# include <mlc/is_a.hh> + +# include <ntg/core/contract.hh> +# include <ntg/core/macros.hh> +# include <ntg/core/type_traits.hh> +# include <ntg/core/value.hh> +# include <ntg/core/internal/macros.hh> +# include <ntg/real/optraits_real.hh> +# include <ntg/real/real_value.hh> +# include <ntg/utils/debug.hh> +# include <ntg/utils/cast.hh> + +# include <string> +# include <sstream> + +// FIXME: there is maybe simpler a way to write that, but we want it +// to be compatible with icc, so the behaviors must stay classes, not +// meta classes. +// FIXME: are these considerations still accurate? + +namespace ntg +{ + + /* + Behaviors work by callbacks. When an operator has some side effect + to apply, it calls the corresponding behavior functions to wrap + the new value to be assigned. + + Example in the constructor of int_u taking an unsigned in parameter: + real_data_value = behavior_type<get<int_u> >::check(value_to_assign); + */ + + /*-------. + | unsafe | + `-------*/ + //! No check performed. + /*! + Same behavior as the underlying builtin type. + */ + struct unsafe + { + template <class T> + struct get + { + typedef ntgi_storage_type(T) storage_type; + + template <class T1, class T2> + static T + check_plus (T1 lhs, T2 rhs) + { return lhs + rhs; } + + template <class T1, class T2> + static T + check_minus (T1 lhs, T2 rhs) + { return lhs - rhs; } + + template <class T1, class T2> + static T + check_times (T1 lhs, T2 rhs) + { return lhs * rhs; } + + template <class T1, class T2> + static T + check_div (T1 lhs, T2 rhs) + { return lhs / rhs; } + + template <class P> + static storage_type + check (const P& p) + { return storage_type(p); } + }; + + static std::string + name() + { return "unsafe"; } + }; + + /*------. + | force | + `------*/ + //! Force the value to be assigned without checks. + /*! + Quite similar to unsafe, but even if the destination type has a + strict behavior, by using cast::force we ensure that no check will + be performed. + + Example: + + int_u<8, strict> a; + a = force::get<int_u<8, strict> >::check_plus(5, 6); + + => no check + + This construction is useful when we want to use code from a + particular behavior to a type defined with another behavior. + */ + struct force + { + template <class T> + struct get + { + typedef ntgi_storage_type(T) storage_type; + + template <class T1, class T2> + static T + check_plus (T1 lhs, T2 rhs) + { return cast::force<T>(lhs + rhs); } + + template <class T1, class T2> + static T + check_minus (T1 lhs, T2 rhs) + { return cast::force<T>(lhs - rhs); } + + template <class T1, class T2> + static T + check_times (T1 lhs, T2 rhs) + { return cast::force<T>(lhs * rhs); } + + template <class T1, class T2> + static T + check_div (T1 lhs, T2 rhs) + { return cast::force<T>(lhs / rhs); } + + template <class P> + static storage_type + check (const P& p) + { return cast::force<T>(p); } + }; + + static std::string + name() + { return "force"; } + }; + + /*-------. + | strict | + `-------*/ + //! Strict checking, abort in there is a problem. + struct strict + { + template <class T> + struct get + { + typedef ntgi_storage_type(T) storage_type; + + // FIXME: These checks are not always useful. We can determine + // in advance the types which can raise overflow + // (eg. int_u<32>), the tests should be performed only in those + // cases! + + // FIXME: check that conditions lead to empty code when + // -DNDEBUG is defined does not have any runtime cost. + + template <class T1, class T2> + static T + check_plus (T1 lhs, T2 rhs) + { + T ret = lhs + rhs; + if (rhs > 0) + ntg_assert(ntg_cast(ret) > lhs); + else + ntg_assert(ntg_cast(ret) <= lhs); + return ret; + } + + template <class T1, class T2> + static T + check_minus (T1 lhs, T2 rhs) + { + T ret = lhs - rhs; + if (rhs > 0) + ntg_assert(ntg_cast(ret) < lhs); + else + ntg_assert(ntg_cast(ret) >= lhs); + return ret; + } + + // FIXME: this check is very slow! Find another solution. + template <class T1, class T2> + static T + check_times (T1 lhs, T2 rhs) + { + T ret = lhs * rhs; + if (rhs != 0) + ntg_assert((ret / rhs) == lhs); + return ret; + } + + template <class T1, class T2> + static T + check_div (T1 lhs, T2 rhs) + { return lhs / rhs; } + + template <class P> + static storage_type + check (const P& p) + { + ntg_assert(ntg_cast(p) <= ntg_max_val(T)); + ntg_assert(ntg_cast(p) >= ntg_min_val(T)); + + return static_cast<storage_type>(p); + } + }; + + static std::string + name() + { return "strict"; } + }; + + /*---------. + | saturate | + `---------*/ + //! Bound values to the nearest limit when an overflow occurs. + struct saturate + { + template <class T> + struct get + { + typedef ntgi_storage_type(T) storage_type; + + template <class T1, class T2> + static T + check_plus (T1 lhs, T2 rhs) + { + T ret = lhs + rhs; + if (rhs > 0) + { + if (ntg_cast(ret) <= lhs) + ret = ntg_max_val(T); + } + else if (ntg_cast(ret) > lhs) + ret = ntg_min_val(T); + return ret; + } + + template <class T1, class T2> + static T + check_minus (T1 lhs, T2 rhs) + { + T ret = lhs - rhs; + if (rhs > 0) + { + if (ntg_cast(ret) > lhs) + ret = ntg_min_val(T); + } + else if (rhs != 0 && ntg_cast(ret) <= lhs) + ret = ntg_max_val(T); + return ret; + } + + // FIXME: this check is very slow ! find another solution ... + template <class T1, class T2> + static T + check_times (T1 lhs, T2 rhs) + { + T ret = lhs * rhs; + if ((ret / rhs) != lhs) + { + // if lhs and rhs signs are equal, we wanted to grow + if ((lhs > 0 && rhs > 0) || (-lhs > 0 && -rhs > 0)) + ret = ntg_max_val(T); + else + ret = ntg_min_val(T); + } + return ret; + } + + template <class T1, class T2> + static T + check_div (T1 lhs, T2 rhs) + { return lhs / rhs; } + + template <class P> + static storage_type + check (const P& p) + { + if (ntg_cast(p) > ntg_max_val(T)) + return ntg_max_val(T); + + if (ntg_cast(p) < ntg_min_val(T)) + return ntg_min_val(T); + + return static_cast<storage_type>(p); + } + }; + + static std::string + name() + { return "saturate"; } + }; + + /*---------------. + | cycle_behavior | + `---------------*/ + //! Apply a modulus when an overflow occurs. + /*! + This behavior is not really useful, but implement cycle<> + internal calculus. You should note that a range<int_u, ..., + cycle_behavior> is different than cycle<int_u, ...>. Refer to the + documentation for more details. + */ + struct cycle_behavior + { + template <class T> + struct get + { + typedef ntgi_storage_type(T) storage_type; + + // FIXME: calculate real values! + + template <class T1, class T2> + static T check_plus (T1 lhs, T2 rhs) + { return lhs + rhs; } + + template <class T1, class T2> + static T check_minus (T1 lhs, T2 rhs) + { return lhs - rhs; } + + template <class T1, class T2> + static T check_times (T1 lhs, T2 rhs) + { return lhs * rhs; } + + template <class T1, class T2> + static T check_div (T1 lhs, T2 rhs) + { return lhs / rhs; } + + // float modulus + struct cycle_fmod + { + static double + exec(double lhs, double rhs) + { return fmod(lhs, rhs); } + }; + + // integer modulus + struct cycle_mod + { + template <class T1, class T2> + static T1 + exec(const T1& lhs, const T2& rhs) + { return lhs % rhs; } + }; + + // FIXME: optimize! + template <class P> + static storage_type + check (const P& rhs) + { + typedef typename mlc::if_<ntg_is_a(P, decimal)::ret, + cycle_fmod, + cycle_mod>::ret cycle_op; + + ntg_type(P) tmp = cycle_op::exec(std::abs(ntg_signed_cast(rhs)), + ntg_max_val(T) - ntg_min_val(T)); + + if (to_ntg(rhs) < 0) + tmp = -tmp; + + if (tmp < ntg_min_val(T)) + return ntg_max_val(T) - ntg_min_val(T) + tmp; + else if (tmp >= ntg_max_val(T)) + return ntg_min_val(T) - ntg_max_val(T) + tmp; + + return tmp; + } + }; + + static std::string + name() { return "cycle_behavior"; } + }; + + namespace internal { + + /*-------------------. + | deduce_op_behavior | + `-------------------*/ + + //! Determine the resulting behavior of an operator return type. + /*! + The algorithm is quite simple and arbitrary, is the two + behaviors are identicals, then use it for the return type. Else + use a strict behavior. + */ + template <class B1, class B2> + struct deduce_op_behavior + { typedef strict ret; }; + + template <class B> + struct deduce_op_behavior<B, B> + { typedef B ret; }; + + /*----------------. + | ret_behavior_if | + `----------------*/ + + //! Determine the behavior to use depending on check requirements. + /*! + If need_check is true, the returned behavior will be the same as + the previously determined return type (generally safe). + + In some cases, no check is required, thus type used to perform + the calculus does not need to be safe. The force behavior is + returned in such cases. + */ + + template <bool need_check, class Ret> + struct ret_behavior_if + { + typedef typename typetraits<Ret>::abstract_behavior_type ret; + }; + + template <class Ret> + struct ret_behavior_if<false, Ret> + { + typedef ntg::force ret; + }; + + } // end of internal. + +} // end of ntg. + +#endif // !NTG_REAL_BEHAVIOUR_HH Index: ntg/real/cycle.hh --- ntg/real/cycle.hh (revision 0) +++ ntg/real/cycle.hh (revision 0) @@ -0,0 +1,187 @@ +// Copyright (C) 2001, 2002, 2003 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_REAL_CYCLE_HH +# define NTG_REAL_CYCLE_HH + +# include <ntg/basics.hh> +# include <ntg/core/internal/macros.hh> +# include <ntg/core/interval.hh> + +# include <mlc/is_a.hh> + +# include <string> +# include <sstream> + +namespace ntg { + + namespace internal { + + /*------------------. + | typetraits<cycle> | + `------------------*/ + + template <class T, class interval> + struct typetraits<cycle<T, interval> > : public typetraits<T> + { + typedef cycle<T, interval> self; + typedef typename typetraits<T>::abstract_type abstract_type; + typedef self ntg_type; + typedef optraits<self> optraits_type; + typedef cycle_behavior::get<self> behavior_type; + typedef cycle_behavior abstract_behavior_type; + + typedef typename typetraits<T>::base_type base_type; + typedef T storage_type; + typedef typename typetraits<T>::signed_type signed_type; + typedef typename typetraits<T>::unsigned_type unsigned_type; + typedef self cumul_type; + typedef self largest_type; + typedef self signed_largest_type; + typedef self signed_cumul_type; + typedef self unsigned_largest_type; + typedef self unsigned_cumul_type; + typedef typename typetraits<T>::integer_type integer_type; + }; + + } // end of internal. + + /*-------------------. + | cycle<T, interval> | + `-------------------*/ + + template <class T, + class interval> + class cycle : + public type_traits<T>::template build_value_type<cycle<T, interval> >::ret + { + public: + typedef cycle<T, interval> self; + + private: + typedef ntgi_optraits_type(self) optraits_type; + typedef ntg_base_type(self) base_type; + typedef ntgi_storage_type(base_type) base_storage_type; + + public: + cycle () { this->val_ = 0; } + + template <class U> + cycle (const U& u) + { + ntg_is_a(U, real)::ensure(); + this->val_ = optraits_type::check(u); + } + template <class U> + self& + operator=(const U& u) + { + this->val_ = optraits_type::check(u); + return *this; + } + + operator base_storage_type() const { return this->val_; } + }; + + template<class T, class interval> + inline std::ostream& + operator<<(std::ostream& stream, const cycle<T, interval>& rhs) + { + // FIXME: cast needed for cycle<unsigned char, ...>. + stream << (ntg_largest_type(T))(rhs.val()); + return stream; + } + + namespace internal { + + /*----------------. + | optraits<cycle> | + `----------------*/ + + template<class T, + class interval> + struct optraits<cycle<T, interval> > : public optraits<T> + { + public: + typedef cycle<T, interval> self; + + private: + typedef typename typetraits<self>::storage_type storage_type_; + typedef typename interval::storage_type interval_type_; + typedef typename typetraits<self>::behavior_type behavior_type_; + + public: + static interval_type_ min() + { return interval::min(); } + + static interval_type_ max() + { return interval::max(); } + + static interval_type_ inf() + { return interval::inf(); } + + static interval_type_ sup() + { return interval::sup(); } + + template <class P> + static storage_type_ + check(const P& rhs) + { return behavior_type_::check(rhs); } + + static std::string + name() + { + std::ostringstream out; + out << "cycle<" << optraits<T>::name() << ", " + << interval::name() << ">"<< std::ends; + return out.str(); + } + }; + + // Inherit operator traits from the base type. + template <class Op, class T, class I, class U> + struct operator_traits<Op, cycle<T, I>, U> + : public deduce_from_traits<Op, T, U>::deduced_traits + {}; + + // Inherit operator traits from the base type. + template <class Op, class T, class I, class U> + struct operator_traits<Op, U, cycle<T, I> > + : public deduce_from_traits<Op, U, T>::deduced_traits + {}; + + // Inherit operator traits from the base type. + template <class Op, class T1, class I1, class T2, class I2> + struct operator_traits<Op, cycle<T1, I1>, cycle<T2, I2> > + : public deduce_from_traits<Op, T1, T2>::deduced_traits + {}; + + } // end of internal. + +} // end of ntg. + +#endif // !NTG_REAL_CYCLE_HH Index: ntg/real/optraits_builtin_int.hh --- ntg/real/optraits_builtin_int.hh (revision 0) +++ ntg/real/optraits_builtin_int.hh (revision 0) @@ -0,0 +1,92 @@ +// Copyright (C) 2001, 2002, 2003, 2004 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_REAL_OPTRAITS_BUILTIN_INT_HH +# define NTG_REAL_OPTRAITS_BUILTIN_INT_HH + +/* + optraits for integer builtin types +*/ + +# include <ntg/config/system.hh> +# include <ntg/real/optraits_real.hh> +# include <ntg/real/typetraits_builtin_int.hh> + +// FIXME: this should be included by system.hh. +# include <limits.h> + +# include <string> + +/*-------. +| macros | +`-------*/ + +# define OPTRAITS_BUILTIN_INT_U(Name, Max) \ + template <> \ + struct optraits<Name > : public optraits<uint_value<Name > > \ + { \ + static Name max() { return Max; } \ + static std::string name() { return std::string(#Name); } \ + } + +# define OPTRAITS_BUILTIN_INT_S(Name, Min, Max) \ + template <> \ + struct optraits<Name > : public optraits<sint_value<Name > > \ + { \ + static Name min() { return Min; } \ + static Name max() { return Max; } \ + static std::string name() { return std::string(#Name); } \ + } + +namespace ntg { + + namespace internal { + + /* + dev note : optraits<builtins> arithmetic operators are only + called when there is an operator_xxx_traits defined, else + builtin are converted into oln type. + */ + + OPTRAITS_BUILTIN_INT_U(unsigned long, ULONG_MAX); + OPTRAITS_BUILTIN_INT_U(unsigned int, UINT_MAX); + OPTRAITS_BUILTIN_INT_U(unsigned short, USHRT_MAX); + OPTRAITS_BUILTIN_INT_U(unsigned char, UCHAR_MAX); + + OPTRAITS_BUILTIN_INT_S(signed long, LONG_MIN, LONG_MAX); + OPTRAITS_BUILTIN_INT_S(signed int, INT_MIN, INT_MAX); + OPTRAITS_BUILTIN_INT_S(signed short, SHRT_MIN, SHRT_MAX); + // char is not the same as signed char. + OPTRAITS_BUILTIN_INT_S(signed char, CHAR_MIN, CHAR_MAX); + // FIXME: whether char is signed or not is implementation defined. + OPTRAITS_BUILTIN_INT_S(char, CHAR_MIN, CHAR_MAX); + + } // end of internal. + +} // end of ntg. + +#endif // !NTG_REAL_OPTRAITS_BUILTIN_INT_HH Index: ntg/real/int_u8.hh --- ntg/real/int_u8.hh (revision 59) +++ ntg/real/int_u8.hh (working copy) @@ -1,131 +0,0 @@ -// 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 INTEGRE_REAL_INT_U8_HH -# define INTEGRE_REAL_INT_U8_HH - -# include <mlc/traits.hh> - -# include <ntg/core/cats.hh> -# include <ntg/core/props.hh> -# include <ntg/real/integer.hh> - -namespace ntg { - - struct int_u8; - - template <> - struct category_type< int_u8 > { typedef cat::integer ret; }; - - template <> - struct props<cat::integer, int_u8> : public default_props<cat::integer> - { - enum { max_val = 255 }; - typedef char io_type; - }; - - - struct int_u8: public integer<int_u8> - { - int_u8() : - value_(0) - { - } - - int_u8(unsigned char value) : - value_(value) - { - } - - int_u8(const int_u8& rhs) : - value_(rhs) - { - } - - int_u8& impl_assign(const int_u8& rhs) - { - this->value_ = rhs; - return *this; - } - - int_u8& impl_assign(const unsigned char& rhs) - { - this->value_ = rhs; - return *this; - } - - operator unsigned char() const - { - return value_; - } - -// template <typename V> -// bool impl_eq(const V& rhs) const -// { -// return this->value_ == rhs; -// } - - bool impl_eq(int rhs) const - { - return this->value_ == rhs; - } - - bool impl_eq(const int_u8& rhs) const - { - return this->value_ == (unsigned char)rhs; - } - - template <typename V> - int_u8 impl_add(const V& rhs) const - { - int_u8 tmp(this->value_ + rhs); - return tmp; - } - - private: - - unsigned char value_; - }; - - -} // end of namespace ntg - - - -namespace mlc { - - template <> - struct traits < ntg::int_u8 > - { - typedef unsigned char encoding_type; - }; - -} // end of namespace mlc - - - -#endif // ! INTEGRE_REAL_INT_U8_HH Index: ntg/real/optraits_real.hh --- ntg/real/optraits_real.hh (revision 0) +++ ntg/real/optraits_real.hh (revision 0) @@ -0,0 +1,148 @@ +// Copyright (C) 2001, 2002, 2003 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_OPTRAITS_REAL_HH_ +# define NTG_OPTRAITS_REAL_HH_ + +# include <cmath> + +# include <mlc/is_a.hh> + +# include <ntg/real/real_value.hh> +# include <ntg/core/type_traits.hh> +# include <ntg/core/abstract_hierarchy.hh> + +// -- + +# include <ntg/core/internal/global_ops_traits.hh> +# include <ntg/core/macros.hh> + +// macros definitions +# include <ntg/real/optraits_real_defs.hh> + +namespace ntg { + + namespace internal { + + /*---------------------. + | optraits<real_value> | + `---------------------*/ + + //! Implement common operators for scalars + template <class E> + class optraits<real_value<E> > : public optraits<value<E> > + { + private: + typedef typename typetraits<E>::storage_type storage_type_; + + public: + static storage_type_ zero () { return 0; } + static storage_type_ unit () { return 1; } + static storage_type_ default_val() { return zero(); } + + // + // dev note : the aim of these default operators is to check the kind + // of operands (value or not), and then call the good function. + // + // ASSIGN_SCALAR_OPERATOR includes default check_xxx_equal functions + // + + ASSIGN_SCALAR_OPERATOR(plus) + ASSIGN_SCALAR_OPERATOR(minus) + ASSIGN_SCALAR_OPERATOR(times) + ASSIGN_SCALAR_OPERATOR(div) + + ARITH_SCALAR_OPERATOR(plus) + ARITH_SCALAR_OPERATOR(minus) + ARITH_SCALAR_OPERATOR(times) + ARITH_SCALAR_OPERATOR(div) + + CMP_SCALAR_OPERATOR(cmp_eq, ==) + CMP_SCALAR_OPERATOR(cmp_lt, <) + }; + + /*----------------------. + | optraits<float_value> | + `----------------------*/ + + template <class E> + class optraits<float_value<E> > : public optraits<real_value<E> > + { + public: + // This is the standard size for float on std::ostream. + static unsigned max_print_width () { return 11U; } + }; + + /*--------------------. + | optraits<int_value> | + `--------------------*/ + + template <class E> + class optraits<int_value<E> > : public optraits<real_value<E> > + { + typedef typename typetraits<E>::storage_type storage_type_; + + public: + static storage_type_ inf () { return optraits<E>::min(); } + static storage_type_ sup () { return optraits<E>::max(); } + + static unsigned max_print_width () + { + return (unsigned) log10(double(optraits<E>::max())) + 1; + } + + ASSIGN_INT_OPERATOR(mod_equal, %) + ARITH_INT_OPERATOR(mod, %=) + }; + + /*---------------------. + | optraits<uint_value> | + `---------------------*/ + + template <class E> + class optraits<uint_value<E> > : public optraits<int_value<E> > + { + private: + typedef typename typetraits<E>::storage_type storage_type_; + + public: + static storage_type_ min () { return 0; } + }; + + /*---------------------. + | optraits<sint_value> | + `---------------------*/ + + template <class E> + class optraits<sint_value<E> > : public optraits<int_value<E> > + {}; + + } // end of internal + +} // end of ntg + +#endif // ndef NTG_OPTRAITS_REAL_HH_ Index: ntg/real/typetraits_builtin_int.hh --- ntg/real/typetraits_builtin_int.hh (revision 0) +++ ntg/real/typetraits_builtin_int.hh (revision 0) @@ -0,0 +1,173 @@ +// Copyright (C) 2002, 2003, 2004 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_REAL_TYPETRAITS_BUILTIN_INT_HH +# define NTG_REAL_TYPETRAITS_BUILTIN_INT_HH + +# include <ntg/real/behavior.hh> +# include <ntg/core/predecls.hh> +# include <ntg/core/type_traits.hh> + +/*-------. +| macros | +`-------*/ + +# define TYPETRAITS_BUILTIN_INT(Name, Value) \ + template<> \ + struct typetraits<Name> : public typetraits<Value<Name > > \ + { \ + typedef Name self; \ + typedef builtin::to_ntg<Name >::ret ntg_type; \ + typedef builtin::abstract_trait<Name >::ret abstract_type; \ + template <class E> \ + struct build_value_type \ + { \ + typedef typename builtin::value_type<Name, E >::ret ret; \ + }; \ + \ + typedef optraits<self> optraits; \ + typedef unsafe::get<self> behavior_type; \ + typedef unsafe abstract_behavior_type; \ + \ + typedef self base_type; \ + typedef self storage_type; \ + typedef builtin::signed_trait<Name >::ret signed_type; \ + typedef builtin::unsigned_trait<Name >::ret unsigned_type; \ + typedef builtin::cumul_trait<Name >::ret cumul_type; \ + typedef builtin::largest_trait<Name >::ret largest_type; \ + typedef builtin::signed_largest_trait<Name >::ret signed_largest_type; \ + typedef builtin::signed_cumul_trait<Name >::ret signed_cumul_type; \ + typedef builtin::unsigned_largest_trait<Name >::ret unsigned_largest_type; \ + typedef builtin::unsigned_cumul_trait<Name >::ret unsigned_cumul_type; \ + typedef self integer_type; \ + }; + +namespace ntg { + + namespace builtin { + + template <class T> + struct abstract_trait { typedef unsigned_integer ret; }; + template <> struct abstract_trait<signed long> { typedef signed_integer ret; }; + template <> struct abstract_trait<signed int> { typedef signed_integer ret; }; + template <> struct abstract_trait<signed short> { typedef signed_integer ret; }; + template <> struct abstract_trait<signed char> { typedef signed_integer ret; }; + template <> struct abstract_trait< char> { typedef signed_integer ret; }; + + template <class T> + struct signed_trait { typedef T ret; }; + template <> struct signed_trait<unsigned long> { typedef signed long ret; }; + template <> struct signed_trait<unsigned int> { typedef signed int ret; }; + template <> struct signed_trait<unsigned short> { typedef signed int ret; }; + template <> struct signed_trait<unsigned char> { typedef signed short ret; }; + + template <class T> + struct unsigned_trait { typedef T ret; }; + template <> struct unsigned_trait<signed long> { typedef unsigned long ret; }; + template <> struct unsigned_trait<signed int> { typedef unsigned int ret; }; + template <> struct unsigned_trait<signed short> { typedef unsigned short ret; }; + template <> struct unsigned_trait<signed char> { typedef unsigned char ret; }; + template <> struct unsigned_trait< char> { typedef unsigned char ret; }; + + template <class T> + struct cumul_trait { typedef T ret; }; + template <> struct cumul_trait<unsigned short> { typedef unsigned int ret; }; + template <> struct cumul_trait< signed short> { typedef signed int ret; }; + template <> struct cumul_trait<unsigned char> { typedef unsigned short ret; }; + template <> struct cumul_trait< signed char> { typedef signed short ret; }; + template <> struct cumul_trait< char> { typedef signed short ret; }; + + template <class T> + struct largest_trait { typedef T ret; }; + template <> struct largest_trait<unsigned short> { typedef unsigned int ret; }; + template <> struct largest_trait< signed short> { typedef signed int ret; }; + template <> struct largest_trait<unsigned char> { typedef unsigned int ret; }; + template <> struct largest_trait< signed char> { typedef signed int ret; }; + template <> struct largest_trait< char> { typedef signed int ret; }; + + template <class T> + struct signed_largest_trait { typedef signed int ret; }; + template <> struct signed_largest_trait<unsigned long> { typedef signed long ret; }; + + template <class T> + struct signed_cumul_trait { typedef signed int ret; }; + template <> struct signed_cumul_trait<unsigned long> { typedef signed long ret; }; + template <> struct signed_cumul_trait<unsigned char> { typedef signed short ret; }; + template <> struct signed_cumul_trait< signed char> { typedef signed short ret; }; + template <> struct signed_cumul_trait< char> { typedef signed short ret; }; + + template <class T> + struct unsigned_largest_trait { typedef unsigned int ret; }; + template <> struct unsigned_largest_trait< signed long> { typedef unsigned long ret; }; + + template <class T> + struct unsigned_cumul_trait { typedef unsigned int ret; }; + template <> struct unsigned_cumul_trait<signed long> { typedef unsigned long ret; }; + template <> struct unsigned_cumul_trait<unsigned char> { typedef unsigned short ret; }; + template <> struct unsigned_cumul_trait< signed char> { typedef unsigned short ret; }; + template <> struct unsigned_cumul_trait< char> { typedef unsigned short ret; }; + + template<class T> struct to_ntg { typedef T ret; }; + template<> struct to_ntg<unsigned char> { typedef int_u8u ret; }; + template<> struct to_ntg< signed char> { typedef int_s8u ret; }; + template<> struct to_ntg< char> { typedef int_s8u ret; }; + template<> struct to_ntg<unsigned short> { typedef int_u16u ret; }; + template<> struct to_ntg< signed short> { typedef int_s16u ret; }; + template<> struct to_ntg<unsigned int> { typedef int_u32u ret; }; + template<> struct to_ntg< signed int> { typedef int_s32u ret; }; + template<> struct to_ntg<unsigned long> { typedef int_u32u ret; }; + template<> struct to_ntg< signed long> { typedef int_s32u ret; }; + + template <class T, class E> struct value_type { typedef uint_value<E> ret; }; + template <class E> struct value_type<signed long, E> { typedef sint_value<E> ret; }; + template <class E> struct value_type<signed int, E> { typedef sint_value<E> ret; }; + template <class E> struct value_type<signed short, E> { typedef sint_value<E> ret; }; + template <class E> struct value_type<signed char, E> { typedef sint_value<E> ret; }; + template <class E> struct value_type< char, E> { typedef sint_value<E> ret; }; + + } // end of builtin. + + namespace internal { + + TYPETRAITS_BUILTIN_INT(unsigned long, uint_value) + TYPETRAITS_BUILTIN_INT(signed long, sint_value) + + TYPETRAITS_BUILTIN_INT(unsigned int, uint_value) + TYPETRAITS_BUILTIN_INT(signed int, sint_value) + + TYPETRAITS_BUILTIN_INT(unsigned short, uint_value) + TYPETRAITS_BUILTIN_INT(signed short, sint_value) + + TYPETRAITS_BUILTIN_INT(unsigned char, uint_value) + TYPETRAITS_BUILTIN_INT(signed char, sint_value) + TYPETRAITS_BUILTIN_INT(char, sint_value) + + } // end of internal. + +} // end of ntg. + +#endif // !NTG_REAL_TYPETRAITS_BUILTIN_INT_HH Index: ntg/real/optraits_real_defs.hh --- ntg/real/optraits_real_defs.hh (revision 0) +++ ntg/real/optraits_real_defs.hh (revision 0) @@ -0,0 +1,213 @@ +// Copyright (C) 2001, 2002, 2003, 2004 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_OPTRAITS_REAL_DEFS_HH +# define NTG_OPTRAITS_REAL_DEFS_HH + +// +// macros used in optraits_real definition +// +///////////////////////////////////////////// + +# define ASSIGN_SCALAR_OPERATOR(Name) \ + template <class T1, class T2> inline \ + static T1& Name##_equal(T1& lhs, const T2& rhs) \ + { \ + ntg_is_a(T1, ntg::real)::ensure(); \ + ntg_is_a(T2, ntg::real)::ensure(); \ + \ + return Name##_equal_impl<T1,T2>(lhs, rhs); \ + } \ + \ + template <class T1, class T2> inline \ + static T1& \ + Name##_equal_impl(ntg::real_value<T1>& lhs, \ + const ntg::real_value<T2>& rhs) \ + { \ + typedef typename typetraits<T1>::behavior_type behavior_type; \ + lhs.exact() = behavior_type::check_##Name(lhs.exact().val(), \ + rhs.exact().val()); \ + return lhs.exact(); \ + } \ + \ + template <class T1, class T2> inline \ + static T1& \ + Name##_equal_impl(ntg::real_value<T1>& lhs, \ + const ntg::any_const_class<T2> rhs) \ + { \ + typedef typename typetraits<T1>::behavior_type behavior_type; \ + lhs.exact() = behavior_type::check_##Name(lhs.exact().val(), \ + rhs.exact()); \ + return lhs.exact(); \ + } \ + \ + template <class T1, class T2> inline \ + static T1& \ + Name##_equal_impl(ntg::any_class<T1> lhs, \ + const ntg::real_value<T2>& rhs) \ + { \ + typedef typename typetraits<T1>::behavior_type behavior_type; \ + lhs.exact() = behavior_type::check_##Name(lhs.exact(), \ + rhs.exact().val()); \ + return lhs.exact(); \ + } + +# define ARITH_SCALAR_OPERATOR(Name) \ + template <class T1, class T2> inline \ + static ntg_return_type(Name, T1, T2) \ + Name(const T1& lhs, const T2& rhs) \ + { \ + ntg_is_a(T1, ntg::real)::ensure(); \ + ntg_is_a(T2, ntg::real)::ensure(); \ + \ + return Name##_impl<T1,T2>(lhs, rhs); \ + } \ + \ + template <class T1, class T2> inline \ + static ntg_return_type(Name, T1, T2) \ + Name##_impl(const ntg::real_value<T1>& lhs, \ + const ntg::real_value<T2>& rhs) \ + { \ + typedef ntg_return_type(Name, T1, T2) return_type; \ + typedef typename \ + typetraits<E>::abstract_behavior_type::template get<return_type> \ + behavior_type; \ + return_type tmp; \ + tmp = behavior_type::check_##Name(lhs.exact().val(), \ + rhs.exact().val()); \ + return tmp; \ + } \ + \ + template <class T1, class T2> inline \ + static ntg_return_type(Name, T1, T2) \ + Name##_impl(const ntg::real_value<T1>& lhs, \ + const ntg::any_const_class<T2>& rhs) \ + { \ + typedef ntg_return_type(Name, T1, T2) return_type; \ + typedef typename \ + typetraits<E>::abstract_behavior_type::template get<return_type> \ + behavior_type; \ + return_type tmp; \ + tmp = behavior_type::check_##Name(lhs.exact().val(), \ + rhs.exact()); \ + return tmp; \ + } \ + \ + template <class T1, class T2> inline \ + static ntg_return_type(Name, T1, T2) \ + Name##_impl(const ntg::any_const_class<T1>& lhs, \ + const ntg::real_value<T2>& rhs) \ + { \ + typedef ntg_return_type(Name, T1, T2) return_type; \ + typedef typename \ + typetraits<E>::abstract_behavior_type::template get<return_type> \ + behavior_type; \ + return_type tmp; \ + tmp = behavior_type::check_##Name(lhs.exact(), \ + rhs.exact().val()); \ + return tmp; \ + } + +# define CMP_SCALAR_OPERATOR(Name, Op) \ + template <class T1, class T2> inline \ + static bool Name (const T1& lhs, const T2& rhs) \ + { \ + ntg_is_a(T1, ntg::real)::ensure(); \ + ntg_is_a(T2, ntg::real)::ensure(); \ + \ + typedef ntg_return_type(cmp, T1, T2) tmp_type; \ + \ + return Name##_impl<tmp_type>(static_cast<tmp_type>(lhs), \ + static_cast<tmp_type>(rhs)); \ + } \ + \ + template <class T> inline \ + static bool \ + Name##_impl(const ntg::real_value<T>& lhs, \ + const ntg::real_value<T>& rhs) \ + { return lhs.exact().val() Op rhs.exact().val(); } \ + \ + template <class T> inline \ + static bool \ + Name##_impl(const ntg::any_const_class<T> lhs, \ + const ntg::any_const_class<T> rhs) \ + { return lhs.exact() Op rhs.exact(); } + + +// +// Macros for optraits_int +// +//////////////////////////// + +# define ASSIGN_INT_OPERATOR(Name, Op) \ + template <class T1, class T2> inline \ + static T1& Name(T1& lhs, const T2& rhs) \ + { \ + ntg_is_a(T1, ntg::integer)::ensure(); \ + ntg_is_a(T2, ntg::integer)::ensure(); \ + \ + return Name##_impl<T1,T2>(lhs, rhs); \ + } \ + \ + template <class T1, class T2> inline \ + static T1& Name##_impl(int_value<T1>& lhs, const int_value<T2>& rhs) \ + { \ + lhs.exact() = lhs.exact().val() Op rhs.exact().val(); \ + return lhs.exact(); \ + } \ + \ + template <class T1, class T2> inline \ + static T1& Name##_impl(int_value<T1>& lhs, \ + const ntg::any_const_class<T2>& rhs) \ + { \ + lhs.exact() = lhs.exact().val() Op rhs.exact(); \ + return lhs.exact(); \ + } \ + \ + template <class T1, class T2> inline \ + static T1& Name##_impl(ntg::any_class<T1>& lhs, \ + const int_value<T2>& rhs) \ + { \ + lhs.exact() = lhs.exact() Op rhs.exact().val(); \ + return lhs.exact(); \ + } + +# define ARITH_INT_OPERATOR(Name, Op) \ + template <class T1, class T2> inline \ + static ntg_return_type(Name, T1, T2) \ + Name(const T1& lhs, const T2& rhs) \ + { \ + ntg_is_a(T1, integer)::ensure(); \ + ntg_is_a(T2, integer)::ensure(); \ + \ + typedef ntg_return_type(Name, T1, T2) return_type; \ + return_type result(lhs); \ + result Op rhs; \ + return result; \ + } + +#endif // ndef NTG_OPTRAITS_REAL_DEFS_HH Index: ntg/real/int_s.hh --- ntg/real/int_s.hh (revision 0) +++ ntg/real/int_s.hh (revision 0) @@ -0,0 +1,580 @@ +// Copyright (C) 2001, 2002, 2003, 2004 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_CORE_INT_S_HH +# define NTG_CORE_INT_S_HH + +# include <ntg/basics.hh> +# include <ntg/real/optraits_real.hh> +# include <ntg/real/real_value.hh> +# include <ntg/bin.hh> +# include <ntg/real/int_u.hh> + +# include <mlc/bool.hh> +# include <mlc/cmp.hh> +# include <mlc/is_a.hh> + +# include <string> +# include <sstream> + +/*-------. +| macros | +`-------*/ + +// FIXME: add bits number comparison to avoid useless checks. + +# define INT_S_CTOR_FROM_UNSIGNED_BUILTIN(Builtin) \ +int_s (const Builtin rhs) \ +{ \ + if ((unsigned) internal::typetraits<ntg_type(Builtin)>::size < nbits) \ + this->val_ = rhs; \ + else \ + this->val_ = optraits_type::check(rhs); \ +} \ +self& operator=(const Builtin rhs) \ +{ \ + if ((unsigned) internal::typetraits<ntg_type(Builtin)>::size < nbits) \ + this->val_ = rhs; \ + else \ + this->val_ = optraits_type::check(rhs); \ + return *this; \ +} + +# define INT_S_CTOR_FROM_SIGNED_BUILTIN(Builtin) \ +int_s (const Builtin rhs) \ +{ \ + if ((unsigned)internal::typetraits<ntg_type(Builtin)>::size <= nbits) \ + this->val_ = rhs; \ + else \ + this->val_ = optraits_type::check(rhs); \ +} \ +self& operator=(const Builtin rhs) \ +{ \ + if ((unsigned)internal::typetraits<ntg_type(Builtin)>::size <= nbits) \ + this->val_ = rhs; \ + else \ + this->val_ = optraits_type::check(rhs); \ + return *this; \ +} + + +namespace ntg { + + namespace internal { + + /*------------------. + | typetraits<int_s> | + `------------------*/ + + template <unsigned nbits, typename behavior> + struct typetraits<int_s<nbits, behavior> > + : public typetraits<sint_value<int_s<nbits, behavior> > > + { + typedef int_s<nbits, behavior> self; + typedef signed_integer abstract_type; + typedef self ntg_type; + + ntg_build_value_type(sint_value<E>); + + typedef optraits<self> optraits_type; + typedef behavior abstract_behavior_type; + typedef typename behavior::template get<self> behavior_type; + + typedef self base_type; + typedef typename C_for_int_s<nbits>::type storage_type; + typedef self signed_type; + typedef int_u<nbits-1, behavior> unsigned_type; + // FIXME: calculate it more precisely + typedef int_s<32, behavior> cumul_type; + typedef int_s<32, behavior> largest_type; + typedef int_s<32, behavior> signed_largest_type; + typedef int_s<32, behavior> signed_cumul_type; + typedef int_u<32, behavior> unsigned_largest_type; + typedef int_u<32, behavior> unsigned_cumul_type; + typedef signed int integer_type; + + // Particular properties + enum { size = nbits }; + }; + + } // end of internal. + + /*-----------------------. + | int_s<nbits, behavior> | + `-----------------------*/ + + template <unsigned nbits, class behavior> + class int_s : public sint_value<int_s<nbits, behavior> > + { + typedef int_s<nbits, behavior> self; + typedef ntgi_storage_type(self) storage_type; + typedef ntgi_optraits_type(self) optraits_type; + + public: + + int_s () { this->val_ = 0; } + + // We define ctor for each builtin to avoid implicit builtin + // promotion. + + INT_S_CTOR_FROM_UNSIGNED_BUILTIN(unsigned long); + INT_S_CTOR_FROM_SIGNED_BUILTIN(signed long); + + INT_S_CTOR_FROM_UNSIGNED_BUILTIN(unsigned int); + INT_S_CTOR_FROM_SIGNED_BUILTIN(signed int); + + INT_S_CTOR_FROM_UNSIGNED_BUILTIN(unsigned short); + INT_S_CTOR_FROM_SIGNED_BUILTIN(signed short); + + INT_S_CTOR_FROM_UNSIGNED_BUILTIN(unsigned char); + INT_S_CTOR_FROM_SIGNED_BUILTIN(signed char); + INT_S_CTOR_FROM_SIGNED_BUILTIN(char); + + template <unsigned mbits, class B2> + int_s (const int_s<mbits, B2>& rhs) + { + if (mbits <= nbits) + this->val_ = rhs.val(); + else + this->val_ = optraits_type::check(rhs.val()); + } + template <unsigned mbits, class B2> + self& + operator=(const int_s<mbits, B2>& rhs) + { + if (mbits <= nbits) + this->val_ = rhs.val(); + else + this->val_ = optraits_type::check(rhs.val()); + return *this; + } + + template <class T> + int_s (const real_value<T>& rhs) + { + this->val_ = optraits_type::check(rhs.val()); + } + template <class T> + self& + operator=(const real_value<T>& rhs) + { + this->val_ = optraits_type::check(rhs.val()); + return *this; + } + + // FIXME: do we really want float to int conversions ? + + int_s (const float_s rhs) + { + this->val_ = optraits_type::check(roundf(rhs)); + } + self& operator=(const float_s rhs) + { + this->val_ = optraits_type::check(roundf(rhs)); + return *this; + } + + int_s (const float_d rhs) + { + this->val_ = optraits_type::check(round(rhs)); + } + self& operator=(const float_d rhs) + { + this->val_ = optraits_type::check(round(rhs)); + return *this; + } + + // bin is allowed since it has defined values 0 or 1. + int_s (bin b) + { + this->val_ = b.val(); + } + self& operator=(bin b) + { + this->val_ = b.val(); + return *this; + } + + operator storage_type () const { return this->val_; } + + private: + // We want to prevent this + int_s(bool); + }; + + template<unsigned nbits, class behavior> + inline std::ostream& + operator<<(std::ostream& stream, const int_s<nbits, behavior>& rhs) + { + stream << signed(rhs.val()); + return stream; + } + + namespace internal + { + + /*----------------. + | optraits<int_s> | + `----------------*/ + + template <unsigned nbits, class behavior> + struct optraits<int_s<nbits, behavior> > : + public optraits<sint_value<int_s<nbits, behavior> > > + { + public: + typedef int_s<nbits, behavior> self; + typedef optraits<sint_value<int_s<nbits, behavior> > > super; + + private: + typedef typename typetraits<self>::base_type base_type_; + typedef typename typetraits<self>::storage_type storage_type_; + typedef typename behavior::template get<self> behavior_type_; + + public: + template <class P> + static storage_type_ + check(const P& rhs) + { return behavior_type_::check(rhs); } + + static storage_type_ max() + { return C_for_int_s<nbits>::max(); } + + static storage_type_ min() + { return C_for_int_s<nbits>::min(); } + + // + // Comparison operators + // + ///////////////////////// + + // As int_x32 cannot grow, there is a problem with comparisons when a + // int_u32 is present, as we cannot convert it to a signed type safely. + // + + // + // cmp_eq + // + + // int_sN == int_u32; int_u32 == int_sN + + template <unsigned mbits, class B1, class B2> + static bool + cmp_eq(const int_s<mbits, B1>& lhs, const int_u<32, B2>& rhs) + { + if (lhs.val() < 0) + return false; + + return static_cast<int_u<32, B2> >(lhs).val() == rhs.val(); + } + template <unsigned mbits, class B1, class B2> + static bool cmp_eq(const int_u<32, B1>& lhs, const int_s<mbits, B2>& rhs) + { return cmp_eq(rhs, lhs); } + + // <T1> == <T2> + + template <class T1, class T2> + static bool + cmp_eq(const T1& lhs, const T2& rhs) + { return super::cmp_eq(lhs, rhs); } + + // + // cmp_lt + // + + // int_sN < int_u32; int_u32 < int_sN + + template <unsigned mbits, class B1, class B2> + static bool + cmp_lt(const int_s<mbits, B1>& lhs, const int_u<32, B2>& rhs) + { + if (lhs.val() < 0) + return true; + + return static_cast<int_u<32, B2> >(lhs).val() < rhs.val(); + } + template <unsigned mbits, class B1, class B2> + static bool cmp_lt(const int_u<32, B1>& lhs, const int_s<mbits, B2>& rhs) + { + if (rhs.val() < 0) + return false; + + return lhs.val() < static_cast<int_u<32, B1> >(rhs.val()); + } + + // <T1> < <T2> + + template <class T1, class T2> + static bool + cmp_lt(const T1& lhs, const T2& rhs) + { return super::cmp_lt(lhs, rhs); } + + // debug + static std::string name() { + std::ostringstream out; + out << "int_s<" << int(nbits) << ", " << behavior::name() << ">" + << std::ends; + return out.str(); + } + }; + + + /*----------------. + | operator traits | + `----------------*/ + + // + // plus + // + + // int_s + int_s + + template<unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_plus, int_s<nbits, B1>, int_s<mbits, B2> > + { + enum { commutative = true, + need_check = ((unsigned) mlc::max<nbits, mbits>::ret >= 32) }; + typedef int_s<(unsigned)mlc::maxN<nbits + 1,mbits + 1, 32>::ret, + typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_s<nbits, + typename ret_behavior_if<need_check, ret>::ret> impl; + }; + + + // int_s + int_u ; int_u + int_s + + template <unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_plus, int_s<nbits, B1>, int_u<mbits, B2> > + { + enum { commutative = true, + need_check = ((mbits >= 31) || (nbits >= 32)) }; + typedef int_s<(unsigned)mlc::maxN<nbits + 1,mbits + 2, 32>::ret, + typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_s<nbits, + typename ret_behavior_if<need_check, ret>::ret> impl; + }; + + + // + // minus + // + + // int_s - int_s + + template<unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_minus, int_s<nbits, B1>, int_s<mbits, B2> > + { + enum { commutative = true, + need_check = ((mbits >= 31) || (nbits >= 31)) }; + typedef int_s<(unsigned)mlc::maxN<nbits + 1, mbits + 1, 32>::ret, + typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_s<nbits, + typename ret_behavior_if<need_check, ret>::ret> impl; + }; + + // int_s - int_u ; int_u - int_s + + template <unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_minus, int_s<nbits, B1>, int_u<mbits, B2> > + { + enum { commutative = true, + need_check = ((mbits >= 31) || (nbits >= 32)) }; + typedef int_s<(unsigned)mlc::maxN<nbits + 1, mbits + 2, 32>::ret, + typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_s<nbits, + typename ret_behavior_if<need_check, ret>::ret> impl; + }; + + + // + // times + // + + // int_s * int_s + + template<unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_times, int_s<nbits, B1>, int_s<mbits, B2> > + { + enum { commutative = true, + need_check = (mbits + nbits > 32) }; + typedef int_s<(unsigned)mlc::saturateN<nbits + mbits, 32>::ret, + typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_s<nbits, + typename ret_behavior_if<need_check, ret>::ret> impl; + }; + + + // int_s * int_u ; int_u * int_s + + template <unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_times, int_s<nbits, B1>, int_u<mbits, B2> > + { + enum { commutative = true, + need_check = (nbits + mbits + 1 > 32)}; + typedef int_s<(unsigned)mlc::saturateN<nbits + mbits+1, 32>::ret, + typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_s<nbits, + typename ret_behavior_if<need_check, ret>::ret> impl; + }; + + // + // div + // + + // int_s / int_s + + template<unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_div, int_s<nbits, B1>, int_s<mbits, B2> > + { + enum { commutative = true }; + typedef int_s<nbits, typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_s<nbits, force> impl; + }; + + // int_s / int_u ; int_u / int_s + + template <unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_div, int_s<nbits, B1>, int_u<mbits, B2> > + { + enum { commutative = false, + need_check = (mbits >= 32) }; + typedef int_s<nbits, typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_s<nbits, + typename ret_behavior_if<need_check, ret>::ret> impl; + }; + + template <unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_div, int_u<mbits, B2>, int_s<nbits, B1> > + { + enum { commutative = false, + need_check = (mbits >= 32) }; + typedef int_s<mlc::saturateN<mbits + 1, 32>::ret, + typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_s<nbits, + typename ret_behavior_if<need_check, ret>::ret> impl; + }; + + // + // mod + // + + // int_s % int_s + + template<unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_mod, int_s<nbits, B1>, int_s<mbits, B2> > + { + enum { commutative = false }; + typedef int_s<mbits, typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_s<nbits, force> impl; + }; + + // int_s % int_u ; int_u % int_s + + template <unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_mod, int_s<nbits, B1>, int_u<mbits, B2> > + { + enum { commutative = false, + need_check = (mbits >= 32) }; + typedef int_s<(unsigned)mlc::saturateN<mbits + 1, 32>::ret, + typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_s<nbits, + typename ret_behavior_if<need_check, ret>::ret> impl; + }; + + // FIXME: don't know what to do with this operator, so the + // implementation is disabled. In classical C++, (a % b) with b < 0 + // returns a whatever b is. + +#if 0 + template <unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_mod, int_u<nbits, B1>, int_s<mbits, B2> > + { + enum { commutative = false }; + typedef int_u<mbits, typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_s<nbits, B1> impl; + }; +#endif + + // + // Min + // + + // min(int_s, int_s) + + template<unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_min, int_s<nbits, B1>, int_s<mbits, B2> > + { + enum { commutative = true }; + typedef int_s<(unsigned) mlc::min<nbits, mbits>::ret, + typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_s<nbits, force> impl; + }; + + // + // Max + // + + // max(int_s, int_s) + + template<unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_max, int_s<nbits, B1>, int_s<mbits, B2> > + { + enum { commutative = true }; + typedef int_s<(unsigned) mlc::max<nbits, mbits>::ret, + typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_s<nbits, force> impl; + }; + + // + // Comparison operator + // + + // int_s compared with int_s + + template<unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_cmp, int_s<nbits, B1>, int_s<mbits, B2> > + { + enum { commutative = true }; + typedef int_s<(unsigned)mlc::maxN<nbits,mbits,32>::ret, unsafe> ret; + typedef int_s<nbits, force> impl; + }; + + + // int_s CMP int_u ; int_u CMP int_s + + template <unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_cmp, int_s<nbits, B1>, int_u<mbits, B2> > + { + enum { commutative = true }; + typedef int_s<(unsigned)mlc::maxN<nbits,mbits+1, 32>::ret, unsafe> ret; + typedef int_s<nbits, force> impl; + }; + + } // end of internal. + +} // end of ntg. + +#endif // !NTG_CORE_INT_S_HH Index: ntg/real/int_u.hh --- ntg/real/int_u.hh (revision 0) +++ ntg/real/int_u.hh (revision 0) @@ -0,0 +1,412 @@ +// Copyright (C) 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 NTG_REAL_INT_U_HH +# define NTG_REAL_INT_U_HH + +# include <ntg/basics.hh> +# include <ntg/real/optraits_real.hh> +# include <ntg/real/real_value.hh> +# include <ntg/bin.hh> + +# include <mlc/bool.hh> +# include <mlc/cmp.hh> +# include <mlc/is_a.hh> + +# include <string> +# include <sstream> + +/*-------. +| macros | +`-------*/ + +# define INT_U_CTOR_FROM_UNSIGNED_BUILTIN_INT(Builtin) \ +int_u (const Builtin rhs) \ +{ \ + if ((unsigned) internal::typetraits<ntg_type(Builtin)>::size <= nbits) \ + this->val_ = rhs; \ + else \ + this->val_ = optraits_type::check(rhs); \ +} \ +self& operator=(const Builtin rhs) \ +{ \ + if ((unsigned) internal::typetraits<ntg_type(Builtin)>::size <= nbits) \ + this->val_ = rhs; \ + else \ + this->val_ = optraits_type::check(rhs); \ + return *this; \ +} + +# define INT_U_CTOR_FROM_BUILTIN_INT(Builtin) \ +int_u (const Builtin rhs) \ +{ \ + this->val_ = optraits_type::check(rhs); \ +} \ +self& operator=(const Builtin rhs) \ +{ \ + this->val_ = optraits_type::check(rhs); \ + return *this; \ +} + + +namespace ntg { + + namespace internal { + + /*------------------. + | typetraits<int_u> | + `------------------*/ + + template <unsigned nbits, typename behavior> + struct typetraits<int_u<nbits, behavior> > + : public typetraits<uint_value<int_u<nbits, behavior> > > + { + typedef int_u<nbits, behavior> self; + typedef unsigned_integer abstract_type; + typedef self ntg_type; + + ntg_build_value_type(uint_value<E>); + + typedef optraits<self> optraits_type; + typedef behavior abstract_behavior_type; + typedef typename behavior::template get<self> behavior_type; + + typedef self base_type; + typedef typename C_for_int_u<nbits>::type storage_type; + typedef int_s<mlc::saturateN<nbits+1, 32>::ret, + behavior> signed_type; + typedef self unsigned_type; + // FIXME: calculate it more precisely + typedef int_u<32, behavior> cumul_type; + typedef int_u<32, behavior> largest_type; + typedef int_s<32, behavior> signed_largest_type; + typedef int_s<32, behavior> signed_cumul_type; + typedef int_u<32, behavior> unsigned_largest_type; + typedef int_u<32, behavior> unsigned_cumul_type; + typedef unsigned int integer_type; + typedef int_u<nbits, unsafe> unsafe_type; + + // Particular properties + enum { size = nbits }; + }; + + } // end of internal. + + /*-----------------------. + | int_u<nbits, behavior> | + `-----------------------*/ + + template <unsigned nbits, class behavior> + class int_u : public uint_value<int_u<nbits, behavior> > + { + typedef int_u<nbits, behavior> self; + typedef ntgi_storage_type(self) storage_type; + // dev note : should be directly optraits<self_t>, but with g++ this + // breaks inheritance in optraits herarchy ... + typedef ntgi_optraits_type(self) optraits_type; + + public: + int_u () { this->val_ = 0; } + + // We define ctor for each builtin to avoid implicit builtin + // promotion. + + // FIXME: dynamic checks are not necessary for all builtin types! + + INT_U_CTOR_FROM_UNSIGNED_BUILTIN_INT(unsigned long); + INT_U_CTOR_FROM_BUILTIN_INT(signed long); + + INT_U_CTOR_FROM_UNSIGNED_BUILTIN_INT(unsigned int); + INT_U_CTOR_FROM_BUILTIN_INT(signed int); + + INT_U_CTOR_FROM_UNSIGNED_BUILTIN_INT(unsigned short); + INT_U_CTOR_FROM_BUILTIN_INT(signed short); + + INT_U_CTOR_FROM_UNSIGNED_BUILTIN_INT(unsigned char); + INT_U_CTOR_FROM_BUILTIN_INT(signed char); + INT_U_CTOR_FROM_BUILTIN_INT(char); + + int_u (const float_s rhs) + { + this->val_ = optraits_type::check(roundf(rhs)); + } + self& + operator=(const float rhs) + { + this->val_ = optraits_type::check(roundf(rhs)); + return *this; + } + + int_u (const float_d rhs) + { + this->val_ = optraits_type::check(round(rhs)); + } + self& + operator=(const double rhs) + { + this->val_ = optraits_type::check(round(rhs)); + return *this; + } + + template <unsigned mbits, class B2> + int_u (const int_u<mbits, B2>& rhs) + { + if (mbits <= nbits) + this->val_ = rhs.val(); + else + this->val_ = optraits_type::check(rhs.val()); + } + template <unsigned mbits, class B2> + self& + operator=(const int_u<mbits, B2>& rhs) + { + if (mbits <= nbits) + this->val_ = rhs.val(); + else + this->val_ = optraits_type::check(rhs.val()); + return *this; + } + + template <class T> + int_u (const real_value<T>& rhs) + { + this->val_ = optraits_type::check(rhs.val()); + } + template <class T> + self& + operator=(const real_value<T>& rhs) + { + this->val_ = optraits_type::check(rhs.val()); + return *this; + } + + // bin is allowed since it has defined values 0 or 1. + int_u (bin b) + { + this->val_ = b.val(); + } + self& + operator=(bin b) + { + this->val_ = b.val(); + return *this; + } + + operator storage_type () const { return this->val_; } + + private: + // We want to prevent this + int_u(bool); + }; + + template<unsigned nbits, class behavior> + inline std::ostream& + operator<<(std::ostream& stream, const int_u<nbits, behavior>& rhs) + { + stream << unsigned(rhs.val()); + return stream; + } + + namespace internal + { + + /*----------------. + | optraits<int_u> | + `----------------*/ + + template <unsigned nbits, class behavior> + struct optraits<int_u<nbits, behavior> > : + public optraits<uint_value<int_u<nbits, behavior> > > + { + private: + typedef int_u<nbits, behavior> self; + typedef typename typetraits<self>::storage_type storage_type_; + typedef typename behavior::template get<self> behavior_type_; + + public: + template <class P> + static storage_type_ check(const P& rhs) + { return behavior_type_::check(rhs); } + + static storage_type_ max() + { return C_for_int_u<nbits>::max(); } + + static std::string + name() + { + std::ostringstream out; + out << "int_u<" << int(nbits) << ", " << behavior::name() << ">" + << std::ends; + return out.str(); + } + }; + + /*----------------. + | operator traits | + `----------------*/ + + // + // plus + // + + // int_u + int_u + + template<unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_plus, int_u<nbits, B1>, int_u<mbits, B2> > + { + enum { commutative = true, + need_check = ((unsigned) mlc::max<nbits, mbits>::ret >= 32) }; + typedef int_u<(unsigned) mlc::maxN<nbits + 1, mbits + 1, 32>::ret, + typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_u<nbits, + typename ret_behavior_if<need_check, ret>::ret> impl; + }; + + // + // minus + // + + // int_u - int_u + + template<unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_minus, int_u<nbits, B1>, int_u<mbits, B2> > + { + enum { commutative = true, + need_check = ((unsigned) mlc::max<nbits, mbits>::ret >= 32) }; + typedef int_s<(unsigned) mlc::maxN<nbits+1, mbits+1, 32>::ret, + typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_u<nbits, + typename ret_behavior_if<need_check, ret>::ret> impl; + }; + + // int_u32 - int_u : we do not convert result to int_s because we + // want to access (UINT_MAX - 1). + + template<class B1, unsigned mbits, class B2> + struct operator_traits<operator_minus, int_u<32, B1>, int_u<mbits, B2> > + { + enum { commutative = true }; + typedef int_u<32, typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_u<32, force> impl; + }; + + // + // times + // + + // int_u * int_u + + template<unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_times, int_u<nbits, B1>, int_u<mbits, B2> > + { + enum { commutative = true, need_check = (nbits + mbits > 32) }; + typedef int_u<(unsigned) mlc::saturateN<nbits + mbits, 32>::ret, + typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_u<nbits, + typename ret_behavior_if<need_check, ret>::ret> impl; + }; + + // + // div + // + + // int_u / int_u + + template<unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_div, int_u<nbits, B1>, int_u<mbits, B2> > + { + enum { commutative = true }; + typedef int_u<nbits, typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_u<nbits, force> impl; + }; + + // + // modulo + // + + // int_u % int_u + + template<unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_mod, int_u<nbits, B1>, int_u<mbits, B2> > + { + enum { commutative = false }; + typedef int_u<mbits, typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_u<nbits, force> impl; + }; + + // + // Min + // + + // min(int_u, int_u) + + template<unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_min, int_u<nbits, B1>, int_u<mbits, B2> > + { + enum { commutative = true }; + typedef int_u<(unsigned) mlc::min<nbits, mbits>::ret, + typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_u<nbits, force> impl; + }; + + + // + // Max + // + + // max(int_u, int_u) + + template<unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_max, int_u<nbits, B1>, int_u<mbits, B2> > + { + enum { commutative = true }; + typedef int_u<(unsigned) mlc::max<nbits, mbits>::ret, + typename deduce_op_behavior<B1, B2>::ret> ret; + typedef int_u<nbits, force> impl; + }; + + + // + // Comparison + // + + // int_u CMP int_u + + template<unsigned nbits, class B1, unsigned mbits, class B2> + struct operator_traits<operator_cmp, int_u<nbits, B1>, int_u<mbits, B2> > + { + enum { commutative = true }; + // FIXME: why unsafe? I think there is a reason. + typedef int_u<(unsigned) mlc::maxN<nbits, mbits, 32>::ret, unsafe> ret; + typedef int_u<nbits, force> impl; + }; + + } // end of internal. + +} // end of ntg. + +#endif // !NTG_REAL_INT_U_HH Index: ntg/real/real_value.hh --- ntg/real/real_value.hh (revision 0) +++ ntg/real/real_value.hh (revision 0) @@ -0,0 +1,58 @@ +// Copyright (C) 2001, 2002, 2003, 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_REAL_REAL_VALUE_HH +# define NTG_REAL_REAL_VALUE_HH + +# include <ntg/core/type_traits.hh> +# include <ntg/core/value.hh> + +# define declare_real_value_type__(Type, Parent) \ + template <class E> \ + class Type : public Parent<E> \ + {}; \ + \ + namespace internal { \ + \ + template <class E> \ + struct typetraits<Type<E> > : public typetraits<Parent<E> > \ + {}; \ + \ + } + +namespace ntg +{ + + declare_real_value_type__(real_value, value) + declare_real_value_type__(float_value, real_value) + declare_real_value_type__(int_value, real_value) + declare_real_value_type__(uint_value, int_value) + declare_real_value_type__(sint_value, int_value) + +} // end of ntg. + +#endif // !NTG_REAL_REAL_VALUE_HH Index: ntg/real/builtin_int.hh --- ntg/real/builtin_int.hh (revision 0) +++ ntg/real/builtin_int.hh (revision 0) @@ -0,0 +1,38 @@ +// Copyright (C) 2002, 2003 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_CORE_BUILTIN_INT_HH +# define NTG_CORE_BUILTIN_INT_HH + +/* + Proxy header for integer builtin types. +*/ + +# include <ntg/real/typetraits_builtin_int.hh> +# include <ntg/real/optraits_builtin_int.hh> + +#endif // !NTG_CORE_BUILTIN_INT_HH Index: ntg/core/abstract_hierarchy.hh --- ntg/core/abstract_hierarchy.hh (revision 0) +++ ntg/core/abstract_hierarchy.hh (revision 0) @@ -0,0 +1,84 @@ +// Copyright (C) 2001, 2002, 2003 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_CORE_ABSTRACT_HIERARCHY_HH +# define NTG_CORE_ABSTRACT_HIERARCHY_HH + +namespace ntg +{ + + /* + Abstract hierarchy is useful to easily check the properties of + each types. type_traits<T>::abstract_type gives the abstract type + associated to T. The macro ntg_is_a(T, abstract_type) is a simple + way to ensure a given type has good properties. + + Examples: + + ntg_is_a(int, integer)::ensure(); + mlc_is_a(type_traits<int_u8>::abstract_type, unsigned_integer)::ensure(); + */ + + //! Top of the hierarchy. + class data_type {}; + + // Single valued data types + class non_vectorial {}; + + /*------. + | reals | + `------*/ + + class real : public non_vectorial {}; + + // int, unsigned, int_u, int_s, etc. + class integer : public real {}; + class unsigned_integer : public integer {}; + class signed_integer : public integer {}; + + // float_s, float_d, etc. + class decimal : public real {}; + + /*-----------. + | enumerated | + `-----------*/ + + class enumerated : public non_vectorial {}; + + // bin, bool, etc. + class binary : public enumerated {}; + + /*----------. + | vectorial | + `----------*/ + + // vec, cplx, etc. + class vectorial : public data_type {}; + +} // end of ntg. + +#endif // !NTG_CORE_ABSTRACT_HIERARCHY_HH Index: ntg/core/predecls.hh --- ntg/core/predecls.hh (revision 0) +++ ntg/core/predecls.hh (revision 0) @@ -0,0 +1,134 @@ +// Copyright (C) 2001, 2002, 2003, 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_CORE_PREDECLS_HH +# define NTG_CORE_PREDECLS_HH + +# include <ntg/core/type.hh> +# include <ntg/vect/cplx_representation.hh> + +/* + Forward declarations of every available types. +*/ + +namespace ntg +{ + + /*----------. + | behaviors | + `----------*/ + + class unsafe; + class strict; + class saturate; + + /*----------. + | intervals | + `----------*/ + + template <class T, T i_min, T i_max> class bounded; + template <unsigned i_min, unsigned i_max> class bounded_u; + template <signed i_min, signed i_max> class bounded_s; + + /*------. + | reals | + `------*/ + + template <unsigned nbits, class behavior = strict> class int_u; + template <unsigned nbits, class behavior = strict> class int_s; + template <class T, class interval, class behavior = strict> class range; + template <class T, class interval> class cycle; + + typedef float float_s; + typedef double float_d; + + /*-----------. + | enumerated | + `-----------*/ + + class bin; + + /*----------. + | vectorial | + `----------*/ + + template <unsigned N, class T, class Self = ntg::final> class vec; + + template <cplx_representation R, class T> class cplx; + + /*-------. + | colors | + `-------*/ + + // This helps swig to parse to file. +#ifndef SWIG + template <unsigned ncomps, + unsigned qbits, + template <unsigned> class color_system> + struct color; +#else + struct color; +#endif + + template<int lval, int uval> + struct interval; + + /*--------------------. + | shortcuts for int_u | + `--------------------*/ + + typedef int_u<8, strict> int_u8; + typedef int_u<8, unsafe> int_u8u; + typedef int_u<8, saturate> int_u8s; + + typedef int_u<16, strict> int_u16; + typedef int_u<16, unsafe> int_u16u; + typedef int_u<16, saturate> int_u16s; + + typedef int_u<32, strict> int_u32; + typedef int_u<32, unsafe> int_u32u; + typedef int_u<32, saturate> int_u32s; + + /*--------------------. + | shortcuts for int_s | + `--------------------*/ + + typedef int_s<8, strict> int_s8; + typedef int_s<8, unsafe> int_s8u; + typedef int_s<8, saturate> int_s8s; + + typedef int_s<16, strict> int_s16; + typedef int_s<16, unsafe> int_s16u; + typedef int_s<16, saturate> int_s16s; + + typedef int_s<32, strict> int_s32; + typedef int_s<32, unsafe> int_s32u; + typedef int_s<32, saturate> int_s32s; + +} // end of ntg. + +#endif // !NTG_CORE_PREDECLS_HH Index: ntg/core/type.hh --- ntg/core/type.hh (revision 0) +++ ntg/core/type.hh (revision 0) @@ -0,0 +1,139 @@ +// Copyright (C) 2001, 2002, 2003, 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_CORE_TYPE_HH +# define NTG_CORE_TYPE_HH + +# include <string> + +/* + Utility classes. +*/ + +namespace ntg +{ + + // FIXME: see comments in ntg/core/value.hh about this duplicate of + // metalic's code. + + /*-------. + | any<E> | + `-------*/ + + //! Top of static hierarchy. + template <class E> + class any + { + public: + typedef E exact_type; + + E& exact() { return static_cast<E&>(*this); } + const E& exact() const { return static_cast<const E&>(*this); } + }; + + /*------------------. + | any_(const_)class | + `------------------*/ + + /* + Classes used to disambiguate overloading. They can store an + instance of any object and restore it later. + */ + + template <class T> + class any_class + { + public: + any_class(T& t) : _target(t) {} + + T& exact() { return _target; } + + private: + T& _target; + }; + + template <class T> + class any_const_class + { + public: + any_const_class(const T& t) : _target(t) {} + + const T& exact() const { return _target; } + + private: + const T& _target; + }; + + /*-------------. + | Useful types | + `-------------*/ + + struct undefined {}; + + class final + { + public: + static std::string name() { return "final"; } + protected: + final() {} + }; + + class top + { + public: + static std::string name() { return ""; } + protected: + top() {} + }; + + + /*---------. + | exact_vt | + `---------*/ + + // + // exact virtual type traits + // (inheritance determination) + // + // If Exact is mlc::final return T else return Exact + + template<class T, class Exact> + struct exact_vt + { + typedef Exact ret; + }; + + template<class Exact> + struct exact_vt<Exact,final> + { + typedef Exact ret; + }; + + +} // end of ntg. + +#endif // !NTG_CORE_TYPE_HH Index: ntg/core/props.hh --- ntg/core/props.hh (revision 59) +++ ntg/core/props.hh (working copy) @@ -1,77 +0,0 @@ -// 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 INTEGRE_CORE_PROPS_HH -# define INTEGRE_CORE_PROPS_HH - -# include <mlc/types.hh> - -# include <ntg/core/cats.hh> - -/*! \namespace ntg -** \brief ntg namespace. -*/ -namespace ntg { - - - /*! \class default_props - ** - ** \brief Class that defines properties by default, so properties are - ** undefined. // FIXME: this doc should be modified... - ** - ** Practically all typedefs of default_props are thus set to - ** mlc::undefined_type. - ** - ** When props<E> is specialized, the programmer should derive that - ** specialization from another props<E'> or from default_props. - ** That ensures that an undefined property is set to mlc::undefined_type. - ** - ** \see props<E> - */ - template < typename category > - struct default_props; - - - /*! \class props<E> - ** - ** Declaration of the trait class for properties. - ** Parameter E is the targeted type. FIXME: rewrite doc. - */ - template <typename category, typename type> - struct props : public default_props <category> - {}; - - template <typename category, typename type> - struct props <category, const type> : public props <category, type> - {}; - - - -} // end of namespace ntg - - -#endif // ndef INTEGRE_CORE_PROPS_HH Index: ntg/core/macros.hh --- ntg/core/macros.hh (revision 59) +++ ntg/core/macros.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2005 EPITA Research and Development Laboratory +// Copyright (C) 2001, 2002, 2003, 2004 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 @@ -25,15 +25,188 @@ // reasons why the executable file might be covered by the GNU General // Public License. -#ifndef INTEGRE_CORE_MACROS_HH -# define INTEGRE_CORE_MACROS_HH +#ifndef NTG_CORE_MACROS_HH +# define NTG_CORE_MACROS_HH -# define ntg_max_val(T) ntg::props<ntg_category_type(T),T>::max_val +/*------. +| casts | +`------*/ -# define ntg_depth(T) ntg::props<ntg_category_type(T),T>::depth +# define ntg_type(T) typename ntg::type_traits< T >::ntg_type +# define ntg_type_(T) typename ntg::type_traits< T >::ntg_type -# define ntg_comp_type(T) typename ntg::props<ntg_category_type(T),T>::comp_type +# define ntg_cast(Val) ntg::to_ntg(Val) +# define ntg_signed_cast(Val) ntg::to_signed_ntg(Val) -# define ntg_io_type(T) typename ntg::props<ntg_category_type(T),T>::io_type +/*--------------. +| type checking | +`--------------*/ -#endif // ! INTEGRE_CORE_MACROS_HH +# define ntg_is_a(T, U) mlc_is_a(typename ntg::type_traits< T >::abstract_type, U) +# define ntg_is_a_(T, U) mlc_is_a_(ntg::type_traits< T >::abstract_type, U) + +/*----------------. +| types accessors | +`----------------*/ + +# define ntg_abstract_type(T) typename ntg::type_traits< T >::abstract_type +# define ntg_abstract_type_(T) ntg::type_traits< T >::abstract_type + +# define ntg_storage_type(T) typename ntg::type_traits< T >::storage_type +# define ntg_storage_type_(T) ntg::type_traits< T >::storage_type + +# define ntg_base_type(T) typename ntg::type_traits< T >::base_type +# define ntg_base_type_(T) ntg::type_traits< T >::base_type + +# define ntg_signed_type(T) typename ntg::type_traits< T >::signed_type +# define ntg_signed_type_(T) ntg::type_traits< T >::signed_type + +# define ntg_unsigned_type(T) typename ntg::type_traits< T >::unsigned_type +# define ntg_unsigned_type_(T) ntg::type_traits< T >::unsigned_type + +# define ntg_integer_type(T) typename ntg::type_traits< T >::integer_type +# define ntg_integer_type_(T) ntg::type_traits< T >::integer_type + +# define ntg_cumul_type(T) typename ntg::type_traits< T >::cumul_type +# define ntg_cumul_type_(T) ntg::type_traits< T >::cumul_type + +# define ntg_signed_cumul_type(T) \ + typename ntg::type_traits< T >::signed_cumul_type +# define ntg_signed_cumul_type_(T) ntg::type_traits< T >::signed_cumul_type + +# define ntg_unsigned_cumul_type(T) \ + typename ntg::type_traits< T >::unsigned_cumul_type +# define ntg_unsigned_cumul_type_(T) ntg::type_traits< T >::unsigned_cumul_type + +# define ntg_largest_type(T) typename ntg::type_traits< T >::largest_type +# define ntg_largest_type_(T) ntg::type_traits< T >::largest_type + +# define ntg_signed_largest_type(T) \ + typename ntg::type_traits< T >::signed_largest_type +# define ntg_signed_largest_type_(T) ntg::type_traits< T >::signed_largest_type + +# define ntg_unsigned_largest_type(T) \ + typename ntg::type_traits< T >::unsigned_largest_type +# define ntg_unsigned_largest_type_(T) \ + ntg::type_traits< T >::unsigned_largest_type + +# define ntg_comp_type(T) \ + typename ntg::type_traits< T >::comp_type +# define ntg_comp_type_(T) \ + ntg::type_traits< T >::comp_type + +# define ntg_unsafe_type(T) typename ntg::type_traits< T >::unsafe_type +# define ntg_unsafe_type_(T) ntg::type_traits< T >::unsafe_type + +/*-----------------. +| values accessors | +`-----------------*/ + +# define ntg_zero_val(T) ntg::type_traits< T >::zero() + +# define ntg_unit_val(T) ntg::type_traits< T >::unit() + +# define ntg_max_val(T) ntg::type_traits< T >::max() + +# define ntg_min_val(T) ntg::type_traits< T >::min() + +# define ntg_sup_val(T) ntg::type_traits< T >::sup() + +# define ntg_inf_val(T) ntg::type_traits< T >::inf() + +# define ntg_inf_val(T) ntg::type_traits< T >::inf() + +# define ntg_sup_val(T) ntg::type_traits< T >::sup() + +# define ntg_max_print_width(T) ntg::type_traits< T >::max_print_width() + +# define ntg_nb_comp(T) ntg::type_traits< T >::nb_comp + +/*--------------------------. +| operator traits accessors | +`--------------------------*/ + +# define ntg_return_type(Op, T1, T2) \ + typename ntg::internal::deduce_from_traits<ntg::internal::operator_##Op , T1, T2 >::ret +# define ntg_return_type_(Op, T1, T2) \ + ntg::internal::deduce_from_traits<ntg::internal::operator_##Op, T1, T2 >::ret + +# define ntg_deduced_traits_type(Op, T1, T2) \ + typename ntg::internal::deduce_from_traits<ntg::internal::operator_##Op, T1, T2 > +# define ntg_deduced_traits_type_(Op, T1, T2) \ + ntg::internal::deduce_from_traits<ntg::internal::operator_##Op, T1, T2 > + +# define ntg_impl_type(Op, T1, T2) \ + typename ntg::internal::deduce_from_traits<ntg::internal::operator_##Op, T1, T2 >::impl +# define ntg_impl_type_(Op, T1, T2) \ + ntg::internal::deduce_from_traits<ntg::internal::operator_##Op, T1, T2 >::impl + +/*----------. +| utilities | +`----------*/ + +# define ntg_name(T) ntg::type_traits< T >::name() + +// FIXME: reimplement when variadic macros will be allowed. +# define ntg_build_value_type(Type) \ + template <class E> \ + struct build_value_type \ + { \ + typedef Type ret; \ + } + +// FIXME: reimplement when variadic macros will be allowed. +# define ntg_get_value_type(T, E) ntg::type_traits< T >::build_value_type<E > + + +/* ----. +| Misc | +`-----*/ +#define ntg_nbits(T) ntg::internal::typetraits< T >::size + + +/*! Return the number of components of T if T is vectorial. +** +** If T is non vectorial, the value returned should not be considered. +*/ +#define ntg_if_vectorial_nb_comp(T) \ + ntg::type_traits<typename mlc::if_<ntg_is_a(T, ntg::vectorial)::ret, \ + T, \ + ntg::vec<42, bool> >::ret>::nb_comp + +/*! Same as \a ntg_if_vectorial_nb_comp but without 'typename' +** +** \see ntg_if_vectorial_nb_comp +*/ +#define ntg_if_vectorial_nb_comp_(T) \ + ntg::type_traits<mlc::if_<ntg_is_a_(T, ntg::vectorial)::ret, \ + T, \ + ntg::vec<42, bool> >::ret>::nb_comp + +/*! Compare the number of components. +** +** - If \a A and \a B are non_vectorial, then +** \a {ntg_compare_nb_comp(A, B)::ret = true} +** - If \a A and \a B are vectorial, then +** \a {ntg_compare_nb_comp(A, B)::ret = (ntg_nb_comp(A) = ntg_nb_comp(B))} +** - Otherwise, it returns false +*/ +#define ntg_compare_nb_comp(A, B) \ + mlc::if_< \ + ntg_is_a(A, ntg::non_vectorial)::ret, \ + ntg_is_a(B, ntg::non_vectorial), \ + mlc::eq<ntg_if_vectorial_nb_comp(A), \ + ntg_if_vectorial_nb_comp(B) > >::ret + +/*! Same as \a ntg_compare_nb_comp but without 'typename' +** +** \see ntg_compare_nb_comp +*/ +#define ntg_compare_nb_comp_(A, B) \ + mlc::if_< \ + ntg_is_a_(A, ntg::non_vectorial)::ret, \ + ntg_is_a_(B, ntg::non_vectorial), \ + mlc::eq<ntg_if_vectorial_nb_comp_(A), \ + ntg_if_vectorial_nb_comp_(B) > >::ret + +#endif // !NTG_CORE_MACROS_HH Index: ntg/core/interval.hh --- ntg/core/interval.hh (revision 0) +++ ntg/core/interval.hh (revision 0) @@ -0,0 +1,118 @@ +// Copyright (C) 2001, 2002, 2003 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_CORE_INTERVAL_HH +# define NTG_CORE_INTERVAL_HH + +# include <ntg/config/system.hh> +# include <ntg/core/macros.hh> +# include <ntg/core/type_traits.hh> + +# include <string> +# include <sstream> + +/* + Classes to define intervals. The problem with static intervals is + that you cannot specify it easily: + + template <T lower, T upper> + struct foo {} + + What do you specify for T ? If you use unsigned, you cannot handle + negative values, if you use signed, you won't be able to use the max + of an unsigned. That's why you have to specify the type of the + bounds. Interval is an handy way to do this. + + Note: it is not possible to define float intervals, as floats cannot + be template parameters. +*/ + +namespace ntg +{ + + /*-------------------------. + | bounded<T, i_min, i_max> | + `-------------------------*/ + + template <class T, T i_min, T i_max> + class bounded + { + public: + typedef T storage_type; + + static T min() { return i_min; } + static T max() { return i_max; } + static T inf() { return i_min; } + static T sup() { return i_max; } + + static std::string + name() + { + std::ostringstream out; + out << "bounded<" << ntg_name(T) << ", " << i_min + << ", " << i_max << ">"<< std::ends; + return out.str(); + } + }; + + /*------------------------. + | bounded_u<i_min, i_max> | + `------------------------*/ + + template <unsigned i_min, unsigned i_max> + class bounded_u : public bounded<unsigned, i_min, i_max> + { + public: + static std::string + name() + { + std::ostringstream out; + out << "bounded_u<" << i_min << ", " << i_max << ">"<< std::ends; + return out.str(); + } + }; + + /*------------------------. + | bounded_s<i_min, i_max> | + `------------------------*/ + + template <signed i_min, signed i_max> + class bounded_s : public bounded<signed, i_min, i_max> + { + public: + static std::string + name() + { + std::ostringstream out; + out << "bounded_s<" << i_min << ", " << i_max << ">"<< std::ends; + return out.str(); + } + }; + +} // end of ntg. + +#endif // !NTG_CORE_INTERVAL_HH Index: ntg/core/pred_succ.hh --- ntg/core/pred_succ.hh (revision 0) +++ ntg/core/pred_succ.hh (revision 0) @@ -0,0 +1,95 @@ +// Copyright (C) 2004 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_CORE_PRED_SUCC_HH +# define NTG_CORE_PRED_SUCC_HH + + +#include <mlc/is_a.hh> +#include <ntg/real/int_u.hh> +#include <ntg/core/macros.hh> + +namespace ntg { + + namespace internal { + //! Return a type which supports inc and dec. + template <typename T> + struct with_arith + { + typedef typename ntg_is_a(T, non_vectorial)::ensure_type non_v; + + typedef int_u<1> bool_with_arith; + typedef T non_vectorial_with_arith; + + typedef typename mlc::if_<ntg_is_a(T, ntg::binary)::ret, + id_<bool_with_arith>, + id_<non_vectorial_with_arith> >::ret::ret ret; + }; + } + + /*! Return the successor of \a t. + ** + ** \note The goal is to iterate on types such as ntg::bin. + */ + template <typename T> + T + succ(const T &t) + { + return T(typename internal::with_arith<T>::ret(t) + 1); + } + + /*! Return the predecessor of \a t. + ** + ** \note The goal is to iterate on types such as ntg::bin. + */ + template <typename T> + T + pred(const T&t) + { + return T(typename internal::with_arith<T>::ret(t) - 1); + } + + namespace internal { + /*! Default less. + ** + ** Specialization of this class provides a less functor even for + ** types that do not support the operator "<". + */ + template <typename T> + struct default_less + { + typedef T arg_type; + bool operator()(const T& l, + const T& r) const + { + return l < r; + } + }; + } +} + +#endif Index: ntg/core/type_traits.hh --- ntg/core/type_traits.hh (revision 0) +++ ntg/core/type_traits.hh (revision 0) @@ -0,0 +1,66 @@ +// Copyright (C) 2001, 2002, 2003, 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_CORE_TYPE_TRAITS_HH +# define NTG_CORE_TYPE_TRAITS_HH + +# include <ntg/core/internal/traits.hh> + +namespace ntg +{ + + /*------------. + | type_traits | + `------------*/ + + //! Associates properties and methods to types. + /*! + type_traits gives a variable set of properties, depending on + the type considered. For example, type_traits<int_u8> can give + larger_type, max(), ... + + It refers to the exact type, this means type_traits<any<int_u8> > + will give the same results than type_traits<int_u8>. + + Traits can be defined for builtin values, so that type_traits<int> + works, this is the main advantage on T::xxx approach to define + properties. + */ + + // FIXME: should inherit from *traits<mlc_exact_type(T)> instead of + // optraits<T> directly. This makes things like + // type_traits<int_value<int_u<..> > >::max() possible. + + template <class T> + class type_traits : + public internal::optraits<T>, + public internal::typetraits<T> + {}; + +} // end of ntg. + +#endif // ndef NTG_CORE_TYPE_TRAITS_HH Index: ntg/core/math.hh --- ntg/core/math.hh (revision 0) +++ ntg/core/math.hh (revision 0) @@ -0,0 +1,82 @@ +// Copyright (C) 2001, 2002, 2003, 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_CORE_MATH_HH +# define NTG_CORE_MATH_HH + +# include <mlc/bool.hh> + +namespace mlc +{ + + namespace internal + { + + // Helper structs for pow2sup below. + + template<unsigned N> struct is_pow2 { typedef false_type ret; }; + template<> struct is_pow2<8> { typedef true_type ret; }; + template<> struct is_pow2<16> { typedef true_type ret; }; + template<> struct is_pow2<32> { typedef true_type ret; }; + template<> struct is_pow2<64> { typedef true_type ret; }; + + template<unsigned N, class> struct find_pow2sup; + template<unsigned N> struct find_pow2sup<N,true_type> { + enum { value = N }; + }; + template<unsigned N> struct find_pow2sup<N,false_type> { + enum { value = find_pow2sup< N+1, + typename is_pow2<N+1>::ret >::value }; + }; + + } // end of internal + + // Smaller power of 2 greater than N. + + template<unsigned N> + struct pow2sup { + enum { + value = + internal::find_pow2sup< N, + typename internal::is_pow2<N>::ret >::value + }; + private: + typedef typename is_true<N < 32>::ensure_type precondition_type; + }; + + // Various tests on N (actually, we tests only oddness.) + + template<unsigned N> + class utest { + public: + typedef typename is_true<N/2 == (N+1)/2>::ensure_type is_odd_type; + static void ensure_odd() { is_odd_type::is_true(); } + }; + +} // end of namespace mlc + +#endif // METALIC_MATH_HH Index: ntg/core/cats.hh --- ntg/core/cats.hh (revision 59) +++ ntg/core/cats.hh (working copy) @@ -1,77 +0,0 @@ -// 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 INTEGRE_CORE_CATS_HH -# define INTEGRE_CORE_CATS_HH - -# include <mlc/types.hh> - - -/*! \macro FIXME:doc -*/ - -# define ntg_category_type(T) typename ntg::category_type<T>::ret - - - -/*! \namespace ntg -** \brief ntg namespace. -*/ -namespace ntg { - - - /*! \class category_type<T> - ** - ** FIXME: doc - ** - */ - template <typename T> - struct category_type - { - typedef mlc::undefined_type ret; - }; - - - /*! \namespace ntg::cat - ** \brief ntg::cat namespace. - */ - namespace cat { - - struct color; - struct enum_value; - struct integer; - // FIXME:... - - } // end of namespace ntg::cat - - -} // end of namespace ntg - - - - -#endif // ! INTEGRE_CORE_CATS_HH Index: ntg/core/value.hh --- ntg/core/value.hh (revision 0) +++ ntg/core/value.hh (revision 0) @@ -0,0 +1,122 @@ +// Copyright (C) 2001, 2002, 2003 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_CORE_VALUE_HH +# define NTG_CORE_VALUE_HH + +# include <ntg/core/macros.hh> +# include <ntg/core/type.hh> +# include <ntg/core/type_traits.hh> + +namespace ntg { + + namespace internal { + + /*---------. + | any_ntg_ | + `---------*/ + + // FIXME: it is not possible to inherit from mlc::any, because it + // gives all subtypes an implicit access to the mlc + // namespace. This is problematic since min or max for example are + // defined in mlc and ntg::internal namespaces, and it creates + // conflicts with g++ (3.2, 3.3, 3.4). + + //! Bridge to internal for ntg type hierarchy. + /*! + This class is a bridge with the internal namespace. Indeed, + global operators (such as <T,U> operator+(T, U)) are defined in + the internal namespace to allow a "using namespace ntg" + directive without breaking external classes interactions. + + However, ntg types need to see those operators. This is done by + inheriting from internal::any_ntg_, thanks to Koenig lookup. + + See comments in <ntg/config/system.hh>. + */ + template <class E> + class any_ntg_ : public ntg::any<E> + {}; + + } // end of internal. + + /*--------. + | any_ntg | + `--------*/ + + //! Top of the ntg types hierarchy. + /*! + Just an abstraction. + */ + template <class E> + class any_ntg : public internal::any_ntg_<E> + {}; + + /*------. + | value | + `------*/ + + //! Concrete value storage class. + /*! + This class actually store the real value (usually a builtin). The + value type is determined from the exact type. + + For example, int_u8::val() returns an "unsigned char". + */ + template <class E> + class value : public any_ntg<E> + { + // note: here it is not possible to use ntg::type_traits, + // because of recursive instanciation problems. + typedef typename internal::typetraits<E>::storage_type storage_type; + + public: + // Hooks + storage_type& val() { return val_; } + const storage_type& val() const { return val_; } + + protected: + storage_type val_; + }; + + namespace internal { + + template <class E> + struct typetraits<value<E> > + { + typedef E unsafe_type; + }; + + template <class E> + struct optraits<value<E> > + {}; + + } + +} // end of ntg. + +#endif // !NTG_CORE_VALUE_HH Index: ntg/core/contract.hh --- ntg/core/contract.hh (revision 0) +++ ntg/core/contract.hh (revision 0) @@ -0,0 +1,57 @@ +// Copyright (C) 2001, 2002, 2003 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_CORE_CONTRACT_HH +# define NTG_CORE_CONTRACT_HH + +# include <mlc/contract.hh> + +/* + Custom version of assert, which can print a context string if + NTG_DEBUG is defined. The context string should be filled by + operators. +*/ + +# ifdef NDEBUG +# define ntg_assert(expr) (static_cast<void>(0)) +# else +// FIXME: repair NTG_DEBUG +# if 0 // ifdef NTG_DEBUG +# define ntg_assert(expr) \ + if (!(expr)) \ + { \ + if (!ntg::debug_context.empty()) \ + std::cerr << "In context: " << ntg::debug_context \ + << std::endl; \ + assertion(expr); \ + } +# else + # define ntg_assert(expr) assertion(expr) +# endif +# endif + +#endif // !NTG_CORE_CONTRACT_HH Index: ntg/core/internal/global_ops.hh --- ntg/core/internal/global_ops.hh (revision 0) +++ ntg/core/internal/global_ops.hh (revision 0) @@ -0,0 +1,243 @@ +// Copyright (C) 2001, 2002, 2003, 2004 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_CORE_INTERNAL_GLOBAL_OPS_HH +# define NTG_CORE_INTERNAL_GLOBAL_OPS_HH + +/* + This header defines global operators (arithmetic, logical, and + comparison). They are examined when at least one ntg type is + involved. They are required to have a precise dispatch, you can + check the documentation for more details. +*/ + +# include <mlc/contract.hh> +# include <mlc/is_a.hh> + +# include <ntg/real/builtin_float.hh> +# include <ntg/real/optraits_builtin_int.hh> +# include <ntg/core/internal/global_ops_traits.hh> +# include <ntg/core/macros.hh> +# include <ntg/core/value.hh> +# include <ntg/utils/debug.hh> + +// macros defs +# include <ntg/core/internal/global_ops_defs.hh> + +// min and max +# include <algorithm> + +namespace ntg +{ + + /* + Global operators are defined in the internal namespace to avoid + any possible clash, even when "using namespace ntg" directive is + used. + */ + + namespace internal + { + + /*------------------------. + | Arithmetic assignements | + `------------------------*/ + + GLOBAL_ASSIGN_OP(operator+=, plus_equal) + GLOBAL_ASSIGN_OP_BUILTIN_INT(operator+=, plus_equal) + GLOBAL_ASSIGN_OP_BUILTIN_FLOAT(operator+=, plus_equal) + + GLOBAL_ASSIGN_OP(operator-=, minus_equal) + GLOBAL_ASSIGN_OP_BUILTIN_INT(operator-=, minus_equal) + GLOBAL_ASSIGN_OP_BUILTIN_FLOAT(operator-=, minus_equal) + + GLOBAL_ASSIGN_OP(operator*=, times_equal) + GLOBAL_ASSIGN_OP_BUILTIN_INT(operator*=, times_equal) + GLOBAL_ASSIGN_OP_BUILTIN_FLOAT(operator*=, times_equal) + + GLOBAL_ASSIGN_OP(operator/=, div_equal) + GLOBAL_ASSIGN_OP_BUILTIN_INT(operator/=, div_equal) + GLOBAL_ASSIGN_OP_BUILTIN_FLOAT(operator/=, div_equal) + + GLOBAL_ASSIGN_OP(operator%=, mod_equal) + GLOBAL_ASSIGN_OP_BUILTIN_INT(operator%=, mod_equal) + + /*---------------------. + | Logical assignements | + `---------------------*/ + + // FIXME: implement |=, &= and ^= in optraits<bool>. + + GLOBAL_ASSIGN_OP(operator|=, logical_or_equal) + // GLOBAL_ASSIGN_OP_BUILTIN_BOOL(operator|=, logical_or_equal) + + GLOBAL_ASSIGN_OP(operator&=, logical_and_equal) + // GLOBAL_ASSIGN_OP_BUILTIN_BOOL(operator&=, logical_and_equal) + + GLOBAL_ASSIGN_OP(operator^=, logical_xor_equal) + // GLOBAL_ASSIGN_OP_BUILTIN_BOOL(operator^=, logical_xor_equal) + + /*----------------------. + | Arithmetic operations | + `----------------------*/ + + GLOBAL_ARITH_OP(operator+, plus) + GLOBAL_ARITH_OP(operator-, minus) + GLOBAL_ARITH_OP(operator*, times) + GLOBAL_ARITH_OP(operator/, div) + GLOBAL_ARITH_OP(operator%, mod) + + /*------------------. + | Logical operators | + `------------------*/ + + GLOBAL_LOGICAL_OP(operator|, logical_or) + GLOBAL_LOGICAL_OP(operator&, logical_and) + GLOBAL_LOGICAL_OP(operator^, logical_xor) + + /*---------------------. + | Comparison operators | + `---------------------*/ + + GLOBAL_CMP_OP(operator==, cmp_eq) + + template <class T1, class T2> inline + bool + operator!=(const T1& lhs, const T2& rhs) + { return !(lhs == rhs); } + + // >, >= and <= operators are defined using <. They are not + // implicitely defined so we have to do so by hand. + + GLOBAL_CMP_OP(operator<, cmp_lt) + + template <class T1, class T2> inline + bool + operator>(const T1& lhs, const T2& rhs) + { return rhs < lhs; } + + template <class T1, class T2> inline + bool + operator>=(const T1& lhs, const T2& rhs) + { return !(lhs < rhs); } + + template <class T1, class T2> inline + bool + operator<=(const T1& lhs, const T2& rhs) + { return !(rhs < lhs); } + + /*-----------------------------. + | Arithmetical unary operators | + `-----------------------------*/ + + // plus + + template <class T> inline + const T& + operator+(const T& val) + { + return val; + } + + template<class T> inline + const T& + operator++(T& val) + { + val += ntg_unit_val(T); + return val; + } + + template<class T> inline + T + operator++(T& val, int) + { + T tmp(val); + val += ntg_unit_val(T); + return tmp; + } + + // minus + + template <class T> inline + const ntg_signed_type(T) + operator-(const T& val) + { + typedef ntg_signed_type(T) signed_type; + return static_cast<signed_type>(ntg_zero_val(T)) - val; + } + + template<class T> inline + const T& operator--(T& val) + { + val -= ntg_unit_val(T); + return val; + } + + template<class T> inline + T operator--(T& val, int) + { + T tmp(val); + val -= ntg_unit_val(T); + return tmp; + } + + /*------------------. + | Min/Max operators | + `------------------*/ + + /* + These operators are slighly different from standard library ones + since they can operate on values of 2 different types. + */ + + template <class T1, class T2> inline + ntg_return_type(min, T1, T2) + min (const T1& lhs, const T2& rhs) + { + typedef ntg_return_type(max, T1, T2) result_type; + return (lhs < rhs) ? result_type(lhs) : result_type(rhs); + } + + template <class T1, class T2> inline + ntg_return_type(max, T1, T2) + max (const T1& lhs, const T2& rhs) + { + typedef ntg_return_type(max, T1, T2) result_type; + return (lhs > rhs) ? result_type(lhs) : result_type(rhs); + } + + } // end of internal. + + // FIXME: those are needed to handle max and min between two builtin + // types. Maybe std::min and std::max should be extended to work + // with builtin types? + using internal::min; + using internal::max; + +} // end of ntg. + +#endif // ndef NTG_CORE_INTERNAL_GLOBAL_OPS_HH Index: ntg/core/internal/global_ops_defs.hh --- ntg/core/internal/global_ops_defs.hh (revision 0) +++ ntg/core/internal/global_ops_defs.hh (revision 0) @@ -0,0 +1,274 @@ +// Copyright (C) 2001, 2002, 2003 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_CORE_INTERNAL_GLOBAL_OPS_DEFS_HH +# define NTG_CORE_INTERNAL_GLOBAL_OPS_DEFS_HH + +/* + Global operators macros, used to factorize global operators + definitions. +*/ + +/* + For every operator, we need a specialization for every builtin type + to avoid overloading problems. So here are the defined operators: + + operatorX(ntg_type, T2) (1) + operatorX(builtin1, T2) (2) + operatorX(builtin2, T2) + ... + + This handles all cases without ambiguity: + + ntg_type X ntg_type ==> (1) + ntg_type X builtin ==> (1) + builtin1 X ntg_type ==> (2) +*/ + +/*-------------. +| ASSIGNEMENTS | +`-------------*/ + +/*---------------------------------. +| Global assignements for builtins | +`---------------------------------*/ + +# define GLOBAL_ASSIGN_OP_BUILTIN(Op, Name, Builtin) \ +template <class T2> inline \ +Builtin& \ +Op(Builtin& lhs, const value<T2>& rhs) \ +{ return optraits<Builtin>::Name(lhs, rhs.exact()); } + +/*-----------------------------------------------. +| Global assignements for ntg_types and builtins | +`------------------------------------------------*/ + +# define GLOBAL_ASSIGN_OP_BUILTIN_INT(Op, Name) \ +GLOBAL_ASSIGN_OP_BUILTIN(Op, Name, signed long) \ +GLOBAL_ASSIGN_OP_BUILTIN(Op, Name, unsigned long) \ +GLOBAL_ASSIGN_OP_BUILTIN(Op, Name, signed int) \ +GLOBAL_ASSIGN_OP_BUILTIN(Op, Name, unsigned int) \ +GLOBAL_ASSIGN_OP_BUILTIN(Op, Name, signed short) \ +GLOBAL_ASSIGN_OP_BUILTIN(Op, Name, unsigned short) \ +GLOBAL_ASSIGN_OP_BUILTIN(Op, Name, char) \ +GLOBAL_ASSIGN_OP_BUILTIN(Op, Name, signed char) \ +GLOBAL_ASSIGN_OP_BUILTIN(Op, Name, unsigned char) + +# define GLOBAL_ASSIGN_OP_BUILTIN_FLOAT(Op, Name) \ +GLOBAL_ASSIGN_OP_BUILTIN(Op, Name, float) \ +GLOBAL_ASSIGN_OP_BUILTIN(Op, Name, double) + +# define GLOBAL_ASSIGN_OP_BUILTIN_BOOL(Op, Name) \ +GLOBAL_ASSIGN_OP_BUILTIN(Op, Name, bool) + +# define GLOBAL_ASSIGN_OP(Op, Name) \ +template <class T1, class T2> inline \ +T1& \ +Op(value<T1>& lhs, const T2& rhs) \ +{ return optraits<T1>::Name(lhs.exact(), rhs); } + +/*---------------------. +| ARITHMETIC OPERATORS | +`---------------------*/ + +/*-----------------------------------------. +| Global arithmetic operators for builtins | +`-----------------------------------------*/ + +# define GLOBAL_ARITH_OP_BUILTIN(Op, Name, Builtin) \ +template <class T2> inline \ +ntg_return_type(Name, Builtin, T2) \ +Op(Builtin lhs, const value<T2>& rhs) \ +{ \ + typedef ntg_deduced_traits_type(Name, Builtin, T2) deduced_type; \ + \ + typedef typename deduced_type::impl impl; \ + typedef typename deduced_type::lhs_type lhs_type; \ + typedef typename deduced_type::rhs_type rhs_type; \ + \ + return optraits<impl>::Name(static_cast<lhs_type>(lhs), \ + static_cast<rhs_type>(rhs.exact())); \ +} + +/*------------------------------------------------------------. +| Global arithmetic operators for both ntg_types and builtins | +`------------------------------------------------------------*/ + +# define GLOBAL_ARITH_OP(Op, Name) \ +template <class T1, class T2> inline \ +ntg_return_type(Name, T1, T2) \ +Op(const value<T1>& lhs, const T2& rhs) \ +{ \ + /* \ + This code is an example of debugging information, disabled until \ + a good way to handle debug is found. \ + */ \ + \ + /* \ + if (ntg_is_debug_active) \ + { \ + std::ostringstream s; \ + s << typename_of<ntg_return_type(Name, T1, T2)>() << " " \ + << #Op << "(" << typename_of<T1>() << " lhs, " \ + << typename_of<T2>() << " rhs)" << std::endl \ + << "\twith lhs = " << lhs.exact() << " and rhs = " << rhs; \ + ntg_debug_context_set(s.str()); \ + } \ + */ \ + \ + typedef ntg_deduced_traits_type(Name, T1, T2) deduced_type; \ + \ + typedef typename deduced_type::impl impl; \ + typedef typename deduced_type::lhs_type lhs_type; \ + typedef typename deduced_type::rhs_type rhs_type; \ + \ + return optraits<impl>::Name(static_cast<lhs_type>(lhs.exact()), \ + static_cast<rhs_type>(rhs)); \ +} \ + \ +GLOBAL_ARITH_OP_BUILTIN(Op, Name, signed long) \ +GLOBAL_ARITH_OP_BUILTIN(Op, Name, unsigned long) \ +GLOBAL_ARITH_OP_BUILTIN(Op, Name, signed int) \ +GLOBAL_ARITH_OP_BUILTIN(Op, Name, unsigned int) \ +GLOBAL_ARITH_OP_BUILTIN(Op, Name, signed short) \ +GLOBAL_ARITH_OP_BUILTIN(Op, Name, unsigned short) \ +GLOBAL_ARITH_OP_BUILTIN(Op, Name, signed char) \ +GLOBAL_ARITH_OP_BUILTIN(Op, Name, unsigned char) \ +GLOBAL_ARITH_OP_BUILTIN(Op, Name, char) \ +GLOBAL_ARITH_OP_BUILTIN(Op, Name, float) \ +GLOBAL_ARITH_OP_BUILTIN(Op, Name, double) \ +GLOBAL_ARITH_OP_BUILTIN(Op, Name, bool) + +/*------------------. +| LOGICAL OPERATORS | +`------------------*/ + +/*--------------------------------------. +| Global logical operators for builtins | +`--------------------------------------*/ + +# define GLOBAL_LOGICAL_OP_BUILTIN(Op, Name, Builtin) \ +template <class T2> inline \ +ntg_return_type(logical, Builtin, T2) \ +Op(const Builtin& lhs, const value<T2>& rhs) \ +{ \ + typedef ntg_deduced_traits_type(logical, Builtin, T2) deduced_type; \ + \ + typedef typename deduced_type::impl impl; \ + typedef typename deduced_type::lhs_type lhs_type; \ + typedef typename deduced_type::rhs_type rhs_type; \ + \ + return optraits<impl>::Name(static_cast<lhs_type>(lhs), \ + static_cast<rhs_type>(rhs.exact())); \ +} + +/*----------------------------------------------------. +| Global logical operators for ntg_types and builtins | +`----------------------------------------------------*/ + +# define GLOBAL_LOGICAL_OP(Op, Name) \ +template <class T1, class T2> inline \ +ntg_return_type(logical, T1, T2) \ +Op(const value<T1>& lhs, const T2& rhs) \ +{ \ + typedef ntg_deduced_traits_type(logical, T1, T2) deduced_type; \ + \ + typedef typename deduced_type::impl impl; \ + typedef typename deduced_type::lhs_type lhs_type; \ + typedef typename deduced_type::rhs_type rhs_type; \ + \ + return optraits<impl>::Name(static_cast<lhs_type>(lhs.exact()), \ + static_cast<rhs_type>(rhs)); \ +} \ + \ +GLOBAL_LOGICAL_OP_BUILTIN(Op, Name, signed long) \ +GLOBAL_LOGICAL_OP_BUILTIN(Op, Name, unsigned long) \ +GLOBAL_LOGICAL_OP_BUILTIN(Op, Name, signed int) \ +GLOBAL_LOGICAL_OP_BUILTIN(Op, Name, unsigned int) \ +GLOBAL_LOGICAL_OP_BUILTIN(Op, Name, signed short) \ +GLOBAL_LOGICAL_OP_BUILTIN(Op, Name, unsigned short) \ +GLOBAL_LOGICAL_OP_BUILTIN(Op, Name, signed char) \ +GLOBAL_LOGICAL_OP_BUILTIN(Op, Name, unsigned char) \ +GLOBAL_LOGICAL_OP_BUILTIN(Op, Name, float) \ +GLOBAL_LOGICAL_OP_BUILTIN(Op, Name, double) \ +GLOBAL_LOGICAL_OP_BUILTIN(Op, Name, bool) + +/*---------------------. +| COMPARISON OPERATORS | +`---------------------*/ + +/*-----------------------------------------. +| Global comparison operators for builtins | +`-----------------------------------------*/ + +# define GLOBAL_CMP_OP_BUILTIN(Op, Name, Builtin) \ +template <class T2> inline \ +bool \ +Op(const Builtin& lhs, const value<T2>& rhs) \ +{ \ + typedef ntg_deduced_traits_type(cmp, Builtin, T2) deduced_type; \ + \ + typedef typename deduced_type::impl impl; \ + typedef typename deduced_type::lhs_type lhs_type; \ + typedef typename deduced_type::rhs_type rhs_type; \ + \ + return optraits<impl>::Name(static_cast<lhs_type>(lhs), \ + static_cast<rhs_type>(rhs.exact())); \ +} + +/*------------------------------------------------------------. +| Global comparison operators for both ntg_types and builtins | +`------------------------------------------------------------*/ + +# define GLOBAL_CMP_OP(Op, Name) \ +template <class T1, class T2> inline \ +bool \ +Op(const value<T1>& lhs, const T2& rhs) \ +{ \ + typedef ntg_deduced_traits_type(cmp, T1, T2) deduced_type; \ + \ + typedef typename deduced_type::impl impl; \ + typedef typename deduced_type::lhs_type lhs_type; \ + typedef typename deduced_type::rhs_type rhs_type; \ + \ + return optraits<impl>::Name(static_cast<lhs_type>(lhs.exact()), \ + static_cast<rhs_type>(rhs)); \ +} \ + \ +GLOBAL_CMP_OP_BUILTIN(Op, Name, signed long) \ +GLOBAL_CMP_OP_BUILTIN(Op, Name, unsigned long) \ +GLOBAL_CMP_OP_BUILTIN(Op, Name, signed int) \ +GLOBAL_CMP_OP_BUILTIN(Op, Name, unsigned int) \ +GLOBAL_CMP_OP_BUILTIN(Op, Name, signed short) \ +GLOBAL_CMP_OP_BUILTIN(Op, Name, unsigned short) \ +GLOBAL_CMP_OP_BUILTIN(Op, Name, signed char) \ +GLOBAL_CMP_OP_BUILTIN(Op, Name, unsigned char) \ +GLOBAL_CMP_OP_BUILTIN(Op, Name, float) \ +GLOBAL_CMP_OP_BUILTIN(Op, Name, double) \ +GLOBAL_CMP_OP_BUILTIN(Op, Name, bool) + +#endif // !NTG_CORE_INTERNAL_GLOBAL_OPS_DEFS_HH Index: ntg/core/internal/macros.hh --- ntg/core/internal/macros.hh (revision 0) +++ ntg/core/internal/macros.hh (revision 0) @@ -0,0 +1,87 @@ +// Copyright (C) 2001, 2002, 2003, 2004 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_CORE_INTERNAL_MACROS_HH +# define NTG_CORE_INTERNAL_MACROS_HH + +/* + All internal macros starts have an ntgi prefix. +*/ + +/*----------------. +| types accessors | +`----------------*/ + +/* + In come internal code, it is not always possible to use + type_traits<T>, especially within the code of the T class itself. + That's why ntgi_* macros exists. +*/ + +# define ntgi_storage_type(T) \ +typename ntg::internal::typetraits< T >::storage_type + +# define ntgi_abstract_type(T) \ +typename ntg::internal::typetraits< T >::abstract_type + +# define ntgi_optraits_type(T) \ +typename ntg::internal::typetraits< T >::optraits_type + +# define ntgi_behavior_type(T) \ +typename ntg::internal::typetraits< T >::behavior_type + +# define ntgi_base_type(T) \ +typename ntg::internal::typetraits< T >::base_type + +# define ntgi_signed_type(T) \ +typename ntg::internal::typetraits< T >::signed_type + +# define ntgi_unsigned_type(T) \ +typename ntg::internal::typetraits< T >::unsigned_type + +# define ntgi_cumul_type(T) \ +typename ntg::internal::typetraits< T >::cumul_type + +# define ntgi_largest_type(T) \ +typename ntg::internal::typetraits< T >::largest_type + +# define ntgi_signed_largest_type(T) \ +typename ntg::internal::typetraits< T >::signed_largest_type + +# define ntgi_signed_cumul_type(T) \ +typename ntg::internal::typetraits< T >::signed_cumul_type + +# define ntgi_unsigned_largest_type(T) \ +typename ntg::internal::typetraits< T >::unsigned_largest_type + +# define ntgi_unsigned_cumul_type(T) \ +typename ntg::internal::typetraits< T >::unsigned_cumul_type + +# define ntgi_integer_type(T) \ +typename ntg::internal::typetraits< T >::integer_type + +#endif // !NTG_CORE_INTERNAL_MACROS_HH Index: ntg/core/internal/traits.hh --- ntg/core/internal/traits.hh (revision 0) +++ ntg/core/internal/traits.hh (revision 0) @@ -0,0 +1,82 @@ +// Copyright (C) 2001, 2002, 2003, 2004 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_CORE_INTERNAL_TRAITS_HH +# define NTG_CORE_INTERNAL_TRAITS_HH + +/* + Traits used internally, encapsulated in type_traits for external + use. +*/ + +# include <ntg/core/abstract_hierarchy.hh> +# include <string> +namespace ntg { + + namespace internal { + + /*-----------. + | typetraits | + `-----------*/ + + //! Associates types to types. + /*! + Specialize it for every types. + + Please note that typetraits only associates types, and not + methods. This is necessary to handle mutual instantiation + problems, as optraits usually needs typetraits to be + instantiated. + */ + template <class T> + struct typetraits + { + typedef data_type abstract_type; + }; + + /*---------. + | optraits | + `---------*/ + + //! Associates functions to types. + /* + It should be specialized for every types. + */ + template <class T> + struct optraits + { + static std::string name() + { + return "unknown_data_type"; + } + }; + + } // end of internal. + +} // end of ntg. + +#endif // !NTG_CORE_INTERNAL_TRAITS_HH Index: ntg/core/internal/global_ops_traits.hh --- ntg/core/internal/global_ops_traits.hh (revision 0) +++ ntg/core/internal/global_ops_traits.hh (revision 0) @@ -0,0 +1,213 @@ +// Copyright (C) 2001, 2002, 2003 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_CORE_INTERNAL_GLOBAL_OPS_TRAITS_HH +# define NTG_CORE_INTERNAL_GLOBAL_OPS_TRAITS_HH + +/* + Tools to determine return type of operators given the parameters + types. For each type, one has to specialize the traits + operator_xxx, and then use deduce_from_traits<operator_xxx, T1, T2> + as return type for operatorxxx(T1, T2) functions. +*/ + +# include <ntg/core/macros.hh> +# include <ntg/core/type_traits.hh> + +# include <mlc/bool.hh> + +namespace ntg { + + namespace internal { + + /*-----------. + | Meta tools | + `-----------*/ + + struct undefined_traits {}; + + template <class T> + struct meta_undefined_traits + { + typedef undefined_traits ret; + typedef undefined_traits lhs_type; + typedef undefined_traits rhs_type; + typedef undefined_traits traits_lhs_type; + typedef undefined_traits traits_rhs_type; + }; + + template <class T> + struct is_defined { enum { ret = true }; }; + template <> + struct is_defined<undefined_traits> { enum { ret = false }; }; + + /* + get_order, get_order_inv + + These structs are used to inverse input types (if the operator + is commutative) and to specify whether input types should be + converted into another type (eg. the corresponding ntg_type). + */ + + template <class T1, class T2> + struct get_order + { + typedef T1 traits_lhs_type; + typedef T2 traits_rhs_type; + + typedef T1 lhs_type; + typedef T2 rhs_type; + }; + + template <class T1, class T2> + struct get_order_inv + { + typedef T2 traits_lhs_type; + typedef T1 traits_rhs_type; + + typedef T1 lhs_type; + typedef T2 rhs_type; + }; + + /*---------------------------. + | Operator traits definition | + `---------------------------*/ + //! Give return type for operators, depending on the input types. + /*! + operator_traits traits should not be used directly. Instead one + should use deduce_from_traits, see comments below for more + details. + + These traits defines 3 properties: + + * commutative (enum): Tells whether the operator is commutative + or not. + + * ret (typedef): Specifies the return type. + + * impl (typedef): Specifies the type which implement the + operator, that is, the type T such as optraits<T>::operatorX + is the good implementation. + + To specify the concerned operator, one empty class represent + each operator. For example, to specify the traits associated + to the + operator with T1 and T2 as arguments: + + template <class T1, class T2> + struct operator_traits<operator_plus, T1, T2> + { + ... + } + */ + + template <class Op, class T, class U> + struct operator_traits + { + enum { commutative = false }; + typedef undefined_traits ret; + typedef undefined_traits impl; + }; + + struct operator_plus {}; + struct operator_minus {}; + struct operator_times {}; + struct operator_div {}; + struct operator_mod {}; + struct operator_logical {}; + struct operator_cmp {}; + struct operator_min {}; + struct operator_max {}; + + /*-----------------------------------. + | deduce_from_traits<operator, T, U> | + `-----------------------------------*/ + //! Find the good operator_traits, following a simple algorithm. + /*! + deduce_from_traits should generally be used instead of + operator_traits. Indeed, it has a handy algorithm to find return + types: + + 1) Convert T1 and T2 to ntg types. + 2) Check if traits<T1, T2> is defined. + 3) Else, check if traits<T2, T1> is defined + AND traits<T2, T1>::commutative is true. + + deduce_from_traits defines several types: + + - lhs_type and rhs_type: The types into which the first and + second paramaters should be converted before called the + implementation. + + - ret: The return type. + + - impl: The implementation type. + + - deduced_traits: A pointer to the good operator_traits<> + specialization. This can be useful sometimes. + */ + + template <class Op, class T, class U> + struct deduce_from_traits + { + private: + typedef ntg_type(T) T1; + typedef ntg_type(U) T2; + + typedef typename operator_traits<Op, T1, T2>::ret traits; + typedef typename operator_traits<Op, T2, T1>::ret rev_traits; + + enum { can_invert = (operator_traits<Op, T2, T1>::commutative + && is_defined<rev_traits>::ret) }; + + typedef typename + mlc::if_<is_defined<traits>::ret, + get_order<T1, T2>, typename + mlc::if_<can_invert, + get_order_inv<T1, T2>, + meta_undefined_traits<undefined_traits> + >::ret + >::ret deduced_type; + + typedef typename deduced_type::traits_lhs_type traits_lhs_type; + typedef typename deduced_type::traits_rhs_type traits_rhs_type; + + public: + typedef operator_traits<Op, + traits_lhs_type, + traits_rhs_type> deduced_traits; + + typedef typename deduced_type::lhs_type lhs_type; + typedef typename deduced_type::rhs_type rhs_type; + typedef typename deduced_traits::ret ret; + typedef typename deduced_traits::impl impl; + }; + + } // end of internal. + +} // end of ntg. + +#endif // !NTG_CORE_INTERNAL_GLOBAL_OPS_TRAITS_HH Index: ntg/int.hh --- ntg/int.hh (revision 0) +++ ntg/int.hh (revision 0) @@ -0,0 +1,42 @@ +// Copyright (C) 2001, 2002, 2003 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_INT_HH +# define NTG_INT_HH + +/* + Proxy header for integer types (int_u and int_s). +*/ + +// Note: these two types are included together as it is quite +// impossible to use only int_u. For example, doing int_u + 1 needs +// int_s as 1 is a signed int builtin type. + +# include <ntg/real/int_u.hh> +# include <ntg/real/int_s.hh> + +#endif // !NTG_INT_HH Index: ntg/range.hh --- ntg/range.hh (revision 0) +++ ntg/range.hh (revision 0) @@ -0,0 +1,37 @@ +// Copyright (C) 2001, 2002, 2003 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_RANGE_HH +# define NTG_RANGE_HH + +/* + Proxy header for range. +*/ + +# include <ntg/real/range.hh> + +#endif // !NTG_RANGE_HH Index: ntg/cycle.hh --- ntg/cycle.hh (revision 0) +++ ntg/cycle.hh (revision 0) @@ -0,0 +1,37 @@ +// Copyright (C) 2001, 2002, 2003 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_CYCLE_HH +# define NTG_CYCLE_HH + +/* + Proxy header for cycle. +*/ + +# include <ntg/real/cycle.hh> + +#endif // !NTG_CYCLE_HH Index: ntg/utils/debug.hh --- ntg/utils/debug.hh (revision 0) +++ ntg/utils/debug.hh (revision 0) @@ -0,0 +1,94 @@ +// Copyright (C) 2001, 2002, 2003 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_UTILS_DEBUG_HH +# define NTG_UTILS_DEBUG_HH + +# include <ntg/core/macros.hh> +# include <ntg/core/type_traits.hh> + +# include <string> + +namespace ntg +{ + + /*---------------------. + | typename_of_var(obj) | + `---------------------*/ + + template<class T> inline + std::string + typename_of_var(const T&) + { return ntg_name(T); } + + /*-----------------. + | typename_of<T>() | + `-----------------*/ + + /* + This function is handy then there are commas in the type + expression. Else ntg_name(T) is shorter. + */ + + template<class T> inline + std::string + typename_of() + { return ntg_name(T); } + + /* + Debug context. The idea is to keep a context string to simplify + debugging when an assert fails somewhere in a hidden operator. As + this can be slow, a dynamic boolean specifies wheter the context + has to be maintained or not. + */ + +#ifdef NTG_DEBUG + extern bool debug_active; + extern std::string debug_context; +#endif + +} + +# ifdef NTG_DEBUG +# define ntg_debug_define_vars(State) \ + bool ntg::debug_active = State; \ + std::string ntg::debug_context; +# define ntg_debug_activate() ntg::debug_active = true +# define ntg_debug_desactivate() ntg::debug_active = false +# define ntg_is_debug_active (ntg::debug_active == true) +# define ntg_debug_context_set(Context) ntg::debug_context = Context +# define ntg_debug_context_clear(Context) ntg::debug_context.clear() +# else +# define ntg_debug_define_vars(State) +# define ntg_debug_activate() +# define ntg_debug_desactivate() +# define ntg_is_debug_active false +# define ntg_debug_context_set(Context) +# define ntg_debug_context_clear(Context) +# endif + +#endif // !NTG_UTILS_DEBUG_HH Index: ntg/utils/cast.hh --- ntg/utils/cast.hh (revision 0) +++ ntg/utils/cast.hh (revision 0) @@ -0,0 +1,236 @@ +// Copyright (C) 2001, 2002, 2003, 2004 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_UTILS_CAST_HH +# define NTG_UTILS_CAST_HH + +# include <ntg/config/system.hh> +# include <ntg/core/macros.hh> +# include <ntg/core/predecls.hh> +# include <ntg/core/type_traits.hh> +# include <ntg/real/real_value.hh> + +// FIXME: this file is completely broken, taking float_value as +// parameter does not make sense. + +/*-------. +| macros | +`-------*/ + +# define TO_NTG_CAST(Dest) \ + template<class T> \ + inline ntg_##Dest##_type(T) to_##Dest##_ntg(T val) \ + { \ + return static_cast<ntg_##Dest##_type(T)>(val); \ + } + +namespace ntg { + + /*---------. + | to_ntg() | + `---------*/ + + template<class T> + inline ntg_type(T) to_ntg(T val) + { + return static_cast<ntg_type(T)>(val); + } + + TO_NTG_CAST(signed) + + namespace cast { + + // FIXME: force does not seem to have any reason to live. + + /*------. + | force | + `------*/ + + // a cast is performed instead of a constructor (unsafe one) call + // because this last one may not be available with the good + // signature. + template<class Tdest, class Tsrc> inline + const Tdest + force(const Tsrc& val) + { + return ntg_unsafe_type(Tdest)(val); + } + + /*------. + | bound | + `------*/ + + // Like cast::force, but with saturation. + template<class Tdest, class Tsrc> inline + const Tdest + bound(const Tsrc& val) + { + if (ntg_sup_val(Tsrc) > ntg_sup_val(Tdest)) + if (val > Tsrc(Tdest(ntg_sup_val(Tdest)))) + return ntg_sup_val(Tdest); + if (ntg_inf_val(Tsrc) < ntg_inf_val(Tdest)) + if (val < Tsrc(Tdest(ntg_inf_val(Tdest)))) + return ntg_inf_val(Tdest); + return val; + } + + /*------. + | round | + `------*/ + + namespace internal { + template<class Tdest, class Tsrc> + struct _round { + // By default we don't define any function. + // This cast does only work on float input. + }; + + template<class Tdest, class Tsrc> + struct _round<Tdest, float_value<Tsrc> > + { + static const Tdest + doit(const float_value<Tsrc>& val) + { + // FIXME: this code seems out of date. + +#if 1 + // KLUDGE: Cast the rounded value to Tdest::value_t before + // returning it as Tdest. Otherwise g++-3.* complains there + // is no Tdest constructor taking a float argument. + return (ntg_storage_type(Tdest)) round(val.exact()); +#endif + // return round(val.exact()); + } + }; + + template<class Tdest> + struct _round<Tdest, float_s > + { + static const Tdest + doit(const float_s& val) + { + // FIXME: this code seems out of date. +#if 1 + // KLUDGE: Cast the rounded value to Tdest::value_t before + // returning it as Tdest. Otherwise g++-3.* complains there + // is no Tdest constructor taking a float argument. + return (ntg_storage_type(Tdest)) roundf(val); +#endif + // return roundf(val); + } + }; + + template<class Tdest> + struct _round<Tdest, double> + { + static const Tdest + doit(const float_d& val) + { + // FIXME: this code seems out of date. +#if 0 + // KLUDGE: Cast the rounded value to Tdest::value_t before + // returning it as Tdest. Otherwise g++-3.0 complains there + // is no Tdest constructor taking a float argument. + return (ntg_storage_type(Tdest)) round(val); +#endif + return round(val); + } + }; + + template<class Tdest, class Tsrc> + struct _round<float_value<Tdest>, float_value<Tsrc> > + { + static const Tdest + doit(const float_value<Tsrc>& val) + { + return val.exact(); + } + }; + + template<class Tsrc> + struct _round<float_s, float_value<Tsrc> > + { + static float_s + doit(const float_value<Tsrc>& val) + { + return val.exact(); + } + }; + + template<class Tsrc> + struct _round<float_d, float_value<Tsrc> > + { + static float_d + doit(const float_value<Tsrc>& val) + { + return val.exact(); + } + }; + + template<> + struct _round<float_s, float_d> + { + static float + doit(const double& val) + { + return val; + } + }; + + template<> + struct _round<float_d, float_s> + { + static float_d + doit(const float& val) + { + return val; + } + }; + } // end of internal. + + template<class Tdest, class Tsrc> inline + const Tdest round(const Tsrc& val) + { + return internal::_round<Tdest, Tsrc>::doit(val); + } + + /* Like cast::round, but with saturation. */ + template<class Tdest, class Tsrc> inline + const Tdest rbound(const Tsrc& val) + { + if (val > Tsrc(Tdest(ntg_max_val(Tdest)))) + return ntg_max_val(Tdest); + if (val < Tsrc(Tdest(ntg_min_val(Tdest)))) + return ntg_min_val(Tdest); + return cast::round<Tdest>(val); + } + + } // end of cast. + +} // end of ntg. + +#endif // NTG_UTILS_CAST_HH Index: ntg/vect/cplx.hh --- ntg/vect/cplx.hh (revision 0) +++ ntg/vect/cplx.hh (revision 0) @@ -0,0 +1,655 @@ +// Copyright (C) 2001, 2002, 2003 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_VECT_CPLX_HH +# define NTG_VECT_CPLX_HH + +# include <ntg/basics.hh> +# include <ntg/vect/cplx_representation.hh> +# include <ntg/vect/vec.hh> + +# include <mlc/cmp.hh> +# include <mlc/is_a.hh> + +/*------------------------------. +| Assignements operators macros | +`------------------------------*/ + +# define ASSIGN_CPLX_SCALAR_OPERATOR_SINGLE(Rep, Name, Op) \ +template <class T1, class T2> inline \ +static cplx<Rep, T1>& \ +Name(cplx<Rep, T1>& lhs, const T2& rhs) \ +{ \ + ntg_is_a(T2, real)::ensure(); \ + lhs.first() Op rhs; \ + return lhs; \ +} + +# define ASSIGN_CPLX_SCALAR_OPERATOR_BOTH(Rep, Name, Op) \ +template <class T1, class T2> inline \ +static cplx<Rep, T1>& \ +Name(cplx<Rep, T1>& lhs, const T2& rhs) \ +{ \ + ntg_is_a(T2, real)::ensure(); \ + lhs.first() Op rhs; \ + lhs.second() Op rhs; \ + return lhs; \ +} + +# define ASSIGN_CPLX_POLAR_SCALAR_OPERATOR(Name, Op) \ +template <class T1, class T2> inline \ +static cplx<polar, T1>& \ +Name(cplx<polar, T1>& lhs, const T2& rhs) \ +{ \ + ntg_is_a(T2, real)::ensure(); \ + cplx<rect, float_d> tmp(lhs); \ + tmp.real() Op rhs; \ + lhs = tmp; \ + return lhs; \ +} + +# define ASSIGN_CPLX_RECT_CPLX_OPERATOR_MULT(Name, Op1, Op2) \ +template <class T1, cplx_representation R2, class T2> inline \ +static cplx<rect, T1>& \ +Name(cplx<rect, T1>& lhs, const cplx<R2, T2>& rhs) \ +{ \ + cplx<polar, float_d> tmp(lhs); \ + tmp.magn() Op1 (float_d)rhs.magn(); \ + tmp.angle() Op2 (float_d)rhs.angle(); \ + lhs = tmp; \ + return lhs; \ +} + +# define ASSIGN_CPLX_RECT_CPLX_OPERATOR_ADD(Name, Op1, Op2) \ +template <cplx_representation R, class T1, class T2> inline \ +static cplx<rect, T1>& \ +Name(cplx<rect, T1>& lhs, const cplx<R, T2>& rhs) \ +{ \ + lhs.first() Op1 rhs.real(); \ + lhs.second() Op2 rhs.imag(); \ + return lhs; \ +} + +# define ASSIGN_CPLX_POLAR_CPLX_OPERATOR_MULT(Name, Op1, Op2) \ +template <cplx_representation R, class T1, class T2> inline \ +static cplx<polar, T1>& \ +Name(cplx<polar, T1>& lhs, const cplx<R, T2>& rhs) \ +{ \ + lhs.magn() Op1 rhs.magn(); \ + lhs.angle() Op2 rhs.angle(); \ + return lhs; \ +} + +# define ASSIGN_CPLX_POLAR_CPLX_OPERATOR_ADD(Name, Op) \ +template <cplx_representation R, class T1, class T2> inline \ +static cplx<polar, T1>& \ +Name(cplx<polar, T1>& lhs, const cplx<R, T2>& rhs) \ +{ \ + cplx<rect, float_d> tmp(lhs); \ + tmp.real() Op (float_d)rhs.real(); \ + tmp.imag() Op (float_d)rhs.imag(); \ + lhs = tmp; \ + return lhs; \ +} + +# define ASSIGN_CPLX_VECTOR_OPERATOR(Rep, Name, Op) \ +template <class T1, class T2> inline \ +static cplx<Rep, T1>& \ +Name(cplx<Rep, T1>& lhs, const vec<2, T2>& rhs) \ +{ \ + lhs.first() Op rhs[0]; \ + lhs.second() Op rhs[1]; \ + return lhs; \ +} + +/*-----------------------------. +| Arithemetic operators macros | +`-----------------------------*/ + +# define ARITH_CPLX_CPLX_OPERATOR(Rep1, Rep2, Name, Op) \ +template <class T1, class T2> \ +inline static \ +cplx<Rep1, ntg_return_type(Name, T1, T2)> \ +Name(const cplx<Rep1, T1>& lhs, const cplx<Rep2, T2>& rhs) \ +{ \ + typedef cplx<Rep1, ntg_return_type(Name, T1, T2)> return_type; \ + return_type result(lhs); \ + result Op rhs; \ + return result; \ +} + +# define ARITH_CPLX_SCALAR_OPERATOR(Rep, Name, Op) \ +template <class T1, class T2> \ +inline static \ +cplx<Rep, ntg_return_type(Name, T1, T2)> \ +Name(const cplx<Rep, T1>& lhs, const T2& rhs) \ +{ \ + ntg_is_a(T2, real)::ensure(); \ + typedef cplx<Rep, ntg_return_type(Name, T1, T2)> return_type; \ + return_type result(lhs); \ + result Op rhs; \ + return result; \ +} + +# define ARITH_CPLX_SCALAR_OPERATOR_COMMUTE(Rep, Name, Op) \ +template <class T1, class T2> \ +inline static \ +cplx<Rep, ntg_return_type(Name, T1, T2)> \ +Name(const T1& lhs, const cplx<Rep, T2>& rhs) \ +{ \ + return Name(rhs, lhs); \ +} + +# define ARITH_CPLX_VECTOR_OPERATOR(Rep, Name, Op) \ +template <class T1, class T2> \ +inline static \ +cplx<Rep, ntg_return_type(Name, T1, T2)> \ +Name(const cplx<Rep, T1>& lhs, const vec<2, T2>& rhs) \ +{ \ + typedef cplx<Rep, ntg_return_type(Name, T1, T2)> return_type; \ + return_type result(lhs); \ + result Op rhs; \ + return result; \ +} + +# define ARITH_CPLX_VECTOR_OPERATOR_COMMUTE_PLUS(Rep, Name, Op) \ +template <class T1, class T2> \ +inline static \ +cplx<Rep, ntg_return_type(Name, T1, T2)> \ +Name(const vec<2, T1>& lhs, const cplx<Rep, T2>& rhs) \ +{ \ + return Name(rhs, lhs); \ +} + +# define ARITH_CPLX_VECTOR_OPERATOR_COMMUTE_MINUS(Rep, Name, Op) \ +template <class T1, class T2> \ +inline static \ +cplx<Rep, ntg_return_type(Name, T1, T2)> \ +Name(const vec<2, T1>& lhs, const cplx<Rep, T2>& rhs) \ +{ \ + return Name(rhs, lhs).invert(); \ +} + +namespace ntg { + + namespace internal { + + /*----------------------. + | typetraits<cplx<R, T> | + `----------------------*/ + + // FIXME: why cplx<polar> does not inherit from vec<2, ...> ? + + template <cplx_representation R, class T> + struct typetraits<cplx<R, T> > : + public typetraits<vec<2, T, cplx<R, T> > > + { + typedef cplx<R, T> self; + typedef self ntg_type; + typedef optraits<self> optraits_type; + }; + + } // end of internal. + + /*-----------. + | cplx<R, T> | + `-----------*/ + + //! No default implementation. + template <cplx_representation R, class T> + class cplx; + + /*--------------. + | cplx<rect, T> | + `--------------*/ + + template <class T> + class cplx<rect, T> : public vec<2, T, cplx<rect, T> > + { + public: + + cplx(const T& re = 0, const T& im = 0) + { + this->val_[0] = re; + this->val_[1] = im; + } + + cplx<rect, T>& + operator=(const T& r) + { + this->val_[0] = r; + this->val_[1] = 0; + return *this; + } + + template<cplx_representation R, class T2> + cplx(const cplx<R, T2>& rhs) + { + this->val_[0] = (T)rhs.real(); + this->val_[1] = (T)rhs.imag(); + } + + template<cplx_representation R, class T2> + cplx<rect, T>& + operator=(const cplx<R, T2>& rhs) + { + this->val_[0] = (T)rhs.real(); + this->val_[1] = (T)rhs.imag(); + return *this; + } + + template<class T2> + cplx(const vec<2, T2>& rhs) + { + this->val_[0] = (T)rhs[0]; + this->val_[1] = (T)rhs[1]; + } + + template<class T2> + cplx<rect, T>& + operator=(const vec<2, T2>& rhs) + { + this->val_[0] = (T)rhs[0]; + this->val_[1] = (T)rhs[1]; + return *this; + } + + ~cplx() + { + ntg_is_a(T, ntg::real)::ensure(); + } + + // accessors + + const T real() const { return this->val_[0]; } + T& real() { return this->val_[0]; } + + const T imag() const { return this->val_[1]; } + T& imag() { return this->val_[1]; } + + const T first() const { return this->val_[0]; } + T& first() { return this->val_[0]; } + + const T second() const { return this->val_[1]; } + T& second() { return this->val_[1]; } + + // methods + + const float_d + magn() const + { + return sqrt(this->val_[0] * this->val_[0] + this->val_[1] * this->val_[1]); + } + + const float_d + angle() const + { + return atan2(this->val_[1], this->val_[0]); + } + + const cplx<rect, T> + conj() const + { + return cplx<rect, T>(this->val_[0], -this->val_[1]); + } + + const cplx<rect, T> + invert() const + { + return cplx<rect, T>(-this->val_[0], -this->val_[1]); + } + + const cplx<polar, float_d> + to_polar() const + { + return cplx<polar, float_d>(magn(), angle()); + } + + }; + + /*---------------. + | cplx<polar, T> | + `---------------*/ + + template <class T> + class cplx<polar, T> : public vect_value<cplx<polar, T> > + { + public: + + cplx(const T& ma = 0, const T& an = 0) + { + ntg_assert(ma >= 0); + this->val_[0] = ma; + this->val_[1] = an; + } + + cplx<polar, T>& operator=(const T& r) + { + this->val_[0] = r; + this->val_[1] = 0; + return *this; + } + + template<cplx_representation R, class T2> + cplx(const cplx<R, T2>& rhs) + { + this->val_[0] = (T)rhs.magn(); + this->val_[1] = (T)rhs.angle(); + } + + template<cplx_representation R, class T2> + cplx<polar, T>& operator=(const cplx<R, T2>& rhs) + { + this->val_[0] = (T)rhs.magn(); + this->val_[1] = (T)rhs.angle(); + return *this; + } + + ~cplx() + { + ntg_is_a(T, ntg::real)::ensure(); + } + + // accessors + + const T magn() const { return this->val_[0]; } + T& magn() { return this->val_[0]; } + + const T angle() const { return this->val_[1]; } + T& angle() { return this->val_[1]; } + + const T first() const { return this->val_[0]; } + T& first() { return this->val_[0]; } + + const T second() const { return this->val_[1]; } + T& second() { return this->val_[1]; } + + // methods + + const float_d + real() const + { + return this->val_[0] * cos(this->val_[1]); + } + + const float_d + imag() const + { + return this->val_[0] * sin(this->val_[1]); + } + + const cplx<polar, T> + conj() const + { + return cplx<polar, T>(this->val_[0], -this->val_[1]); + } + + const cplx<rect, T> + invert() const + { + return cplx<rect, T>(this->val_[0], this->val_[1] + M_PI); + } + + const cplx<rect, float_d> + to_rect() const + { + return cplx<rect, float_d>(real(), imag()); + } + + }; + + template<class T> + inline std::ostream& + operator<<(std::ostream& ostr, const cplx<rect, T>& rhs) + { + // Using an ostringstream is necessary to pretty print. + std::ostringstream str; + str << rhs.real() << " + " << rhs.imag() << "i"; + return ostr << str.str(); + } + + template<class T> + inline std::ostream& + operator<<(std::ostream& ostr, const cplx<polar, T>& rhs) + { + // Using an ostringstream is necessary to pretty print. + std::ostringstream str; + str << rhs.magn() << " * exp(" << rhs.angle() << "i)"; + return ostr << str.str(); + } + + namespace internal + { + + /*-------------------------. + | optraits<cplx<rect, T> > | + `-------------------------*/ + + template <class T> + class optraits<cplx<rect, T> > : public optraits<vec<2, T> > + { + typedef cplx<rect, T> self; + typedef typename typetraits<self>::storage_type storage_type_; + + public: + static self zero () { return self(); } + static self unit () { return self(1); } + + static unsigned max_print_width() + { + return 2 * ntg_max_print_width(T) + 4; + } + + static std::string + name() + { + std::ostringstream out; + out << "cplx<rect, " << optraits<T>::name() << ">" << std::ends; + return out.str(); + } + + ASSIGN_CPLX_SCALAR_OPERATOR_SINGLE(rect, plus_equal, +=) + ASSIGN_CPLX_SCALAR_OPERATOR_SINGLE(rect, minus_equal, -=) + ASSIGN_CPLX_SCALAR_OPERATOR_BOTH(rect, times_equal, *=) + ASSIGN_CPLX_SCALAR_OPERATOR_BOTH(rect, div_equal, /=) + + ASSIGN_CPLX_RECT_CPLX_OPERATOR_ADD(plus_equal, +=, +=) + ASSIGN_CPLX_RECT_CPLX_OPERATOR_ADD(minus_equal, -=, -=) + ASSIGN_CPLX_RECT_CPLX_OPERATOR_MULT(times_equal, *=, +=) + ASSIGN_CPLX_RECT_CPLX_OPERATOR_MULT(div_equal, /=, -=) + + ASSIGN_CPLX_VECTOR_OPERATOR(rect, plus_equal, +=) + ASSIGN_CPLX_VECTOR_OPERATOR(rect, minus_equal, -=) + + ARITH_CPLX_SCALAR_OPERATOR(rect, plus, +=) + ARITH_CPLX_SCALAR_OPERATOR_COMMUTE(rect, plus, +=) + ARITH_CPLX_SCALAR_OPERATOR(rect, minus, -=) + ARITH_CPLX_SCALAR_OPERATOR(rect, times, *=) + ARITH_CPLX_SCALAR_OPERATOR_COMMUTE(rect, times, *=) + ARITH_CPLX_SCALAR_OPERATOR(rect, div, /=) + + ARITH_CPLX_CPLX_OPERATOR(rect, rect, plus, +=) + ARITH_CPLX_CPLX_OPERATOR(rect, rect, minus, -=) + ARITH_CPLX_CPLX_OPERATOR(rect, rect, times, *=) + ARITH_CPLX_CPLX_OPERATOR(rect, rect, div, /=) + + ARITH_CPLX_CPLX_OPERATOR(rect, polar, plus, +=) + ARITH_CPLX_CPLX_OPERATOR(rect, polar, minus, -=) + ARITH_CPLX_CPLX_OPERATOR(rect, polar, times, *=) + ARITH_CPLX_CPLX_OPERATOR(rect, polar, div, /=) + + ARITH_CPLX_VECTOR_OPERATOR(rect, plus, +=) + ARITH_CPLX_VECTOR_OPERATOR_COMMUTE_PLUS(rect, plus, +=) + ARITH_CPLX_VECTOR_OPERATOR(rect, minus, -=) + ARITH_CPLX_VECTOR_OPERATOR_COMMUTE_MINUS(rect, minus, -=) + + template <class T1, cplx_representation R2, class T2> + inline static bool + cmp_eq (const cplx<rect, T1>& lhs, const cplx<R2, T2>& rhs) + { + if (lhs.real() != rhs.real() || lhs.imag() != rhs.imag()) + return false; + return true; + } + + }; + + /*--------------------------. + | optraits<cplx<polar, T> > | + `--------------------------*/ + + template <class T> + class optraits<cplx<polar, T> > + { + typedef cplx<polar, T> self; + typedef ntgi_storage_type(self) storage_type_; + + public: + static self zero () { return self(); } + + static self unit () { return self(1); } + + static unsigned max_print_width() + { + return 2 * ntg_max_print_width(T) + 4; + } + + static std::string + name() + { + std::ostringstream out; + out << "cplx<polar, " << optraits<T>::name() << ">" << std::ends; + return out.str(); + } + + ASSIGN_CPLX_POLAR_SCALAR_OPERATOR(plus_equal, +=) + ASSIGN_CPLX_POLAR_SCALAR_OPERATOR(minus_equal, -=) + ASSIGN_CPLX_SCALAR_OPERATOR_SINGLE(polar, times_equal, *=) + ASSIGN_CPLX_SCALAR_OPERATOR_SINGLE(polar, div_equal, /=) + + ASSIGN_CPLX_POLAR_CPLX_OPERATOR_ADD(plus_equal, +=) + ASSIGN_CPLX_POLAR_CPLX_OPERATOR_ADD(minus_equal, -=) + ASSIGN_CPLX_POLAR_CPLX_OPERATOR_MULT(times_equal, *=, +=) + ASSIGN_CPLX_POLAR_CPLX_OPERATOR_MULT(div_equal, /=, -=) + + ARITH_CPLX_SCALAR_OPERATOR(polar, plus, +=) + ARITH_CPLX_SCALAR_OPERATOR_COMMUTE(polar, plus, +=) + ARITH_CPLX_SCALAR_OPERATOR(polar, minus, -=) + ARITH_CPLX_SCALAR_OPERATOR(polar, times, *=) + ARITH_CPLX_SCALAR_OPERATOR_COMMUTE(polar, times, *=) + ARITH_CPLX_SCALAR_OPERATOR(polar, div, /=) + + ARITH_CPLX_CPLX_OPERATOR(polar, polar, plus, +=) + ARITH_CPLX_CPLX_OPERATOR(polar, polar, minus, -=) + ARITH_CPLX_CPLX_OPERATOR(polar, polar, times, *=) + ARITH_CPLX_CPLX_OPERATOR(polar, polar, div, /=) + + ARITH_CPLX_CPLX_OPERATOR(polar, rect, plus, +=) + ARITH_CPLX_CPLX_OPERATOR(polar, rect, minus, -=) + ARITH_CPLX_CPLX_OPERATOR(polar, rect, times, *=) + ARITH_CPLX_CPLX_OPERATOR(polar, rect, div, /=) + + template <class T1, cplx_representation R2, class T2> + inline static bool + cmp_eq (const cplx<polar, T1>& lhs, const cplx<R2, T2>& rhs) + { + if (lhs.magn() != rhs.magn() || lhs.angle() != rhs.angle()) + return false; + return true; + } + + }; + + /*-----------------------. + | operator traits macros | + `-----------------------*/ + + // FIXME: I think there should be an easy way to simplify this. + // -- nes + +# define CPLX_SCALAR_OPERATORS_TRAITS(Name, CommuteBool) \ + template <cplx_representation R1, class T1, class T2> \ + struct operator_traits<operator_##Name, cplx<R1, T1>, T2> \ + { \ + enum { commutative = CommuteBool }; \ + typedef cplx<R1, ntg_return_type(Name, T1, T2)> ret; \ + typedef cplx<R1, T1> impl; \ + } + +# define CPLX_CPLX_OPERATORS_TRAITS(Name, CommuteBool) \ + template <cplx_representation R1, \ + class T1, \ + cplx_representation R2, class T2> \ + struct operator_traits<operator_##Name, \ + cplx<R1, T1>, cplx<R2, T2> > \ + { \ + enum { commutative = CommuteBool }; \ + typedef cplx<R1, ntg_return_type(Name, T1, T2)> ret; \ + typedef cplx<R1, T1> impl; \ + } + +# define CPLX_VECTOR_OPERATORS_TRAITS(Rep, Name, CommuteBool) \ + template <class T1, class T2> \ + struct operator_traits<operator_##Name, \ + cplx<Rep, T1>, vec<2, T2> > \ + { \ + enum { commutative = CommuteBool }; \ + typedef cplx<Rep, ntg_return_type(Name, T1, T2)> ret; \ + typedef cplx<Rep, T1> impl; \ + } + + /*----------------. + | operator traits | + `----------------*/ + + CPLX_SCALAR_OPERATORS_TRAITS(plus, true); + CPLX_SCALAR_OPERATORS_TRAITS(minus, true); + CPLX_SCALAR_OPERATORS_TRAITS(times, true); + CPLX_SCALAR_OPERATORS_TRAITS(div, true); + + CPLX_CPLX_OPERATORS_TRAITS(plus, true); + CPLX_CPLX_OPERATORS_TRAITS(minus, true); + CPLX_CPLX_OPERATORS_TRAITS(times, true); + CPLX_CPLX_OPERATORS_TRAITS(div, true); + + CPLX_VECTOR_OPERATORS_TRAITS(rect, plus, true); + CPLX_VECTOR_OPERATORS_TRAITS(rect, minus, true); + + template<cplx_representation R1, class T1, + cplx_representation R2, class T2> + struct operator_traits<operator_cmp, cplx<R1, T1>, cplx<R2, T2> > + { + enum { commutative = true }; + typedef cplx<R1, ntg_return_type(cmp, T1, T2)> ret; + typedef cplx<R1, T1> impl; + }; + + } // end of internal. + +} // end of ntg. + +#endif // !NTG_VECT_CPLX_HH Index: ntg/vect/cplx_representation.hh --- ntg/vect/cplx_representation.hh (revision 0) +++ ntg/vect/cplx_representation.hh (revision 0) @@ -0,0 +1,43 @@ +// Copyright (C) 2001, 2002, 2003 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_VECT_CPLX_REPRESENTATION_HH +# define NTG_VECT_CPLX_REPRESENTATION_HH + +namespace ntg +{ + + // Different representations of cplx : + typedef enum + { + rect, + polar + } cplx_representation; + +} // end of ntg. + +#endif // !NTG_VECT_CPLX_REPRESENTATION_HH Index: ntg/vect/vect_value.hh --- ntg/vect/vect_value.hh (revision 0) +++ ntg/vect/vect_value.hh (revision 0) @@ -0,0 +1,68 @@ +// Copyright (C) 2001, 2002, 2003 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_VECT_VECT_VALUE_HH +# define NTG_VECT_VECT_VALUE_HH + +# include <ntg/core/value.hh> + +namespace ntg +{ + + /*-----------. + | vect_value | + `-----------*/ + + template <class E> + class vect_value : public value<E> + { + typedef typename internal::typetraits<E>::comp_type comp_type; + enum { nb_comp = internal::typetraits<E>::nb_comp }; + + public: + // accessor + comp_type& operator[](unsigned i) { return this->val_[i]; } + comp_type operator[](unsigned i) const { return this->val_[i]; } + + static unsigned size() { return nb_comp; } + }; + + namespace internal { + + template <class E> + class typetraits<vect_value<E> > : public typetraits<value<E> > + {}; + + template <class E> + class optraits<vect_value<E> > : public optraits<value<E> > + {}; + + } + +} + +#endif // !NTG_VECT_VECT_VALUE_HH Index: ntg/vect/vec.hh --- ntg/vect/vec.hh (revision 0) +++ ntg/vect/vec.hh (revision 0) @@ -0,0 +1,443 @@ +// Copyright (C) 2001, 2002, 2003, 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_VECT_VEC_HH +# define NTG_VECT_VEC_HH + +# include <ntg/basics.hh> +# include <ntg/core/internal/macros.hh> +# include <ntg/vect/vect_value.hh> + +# include <mlc/array/all.hh> + +/*--------------------. +| assignements macros | +`--------------------*/ + +# define ASSIGN_VECTOR_VECTOR_OPERATOR(Name, Op) \ +template <class T1, class T2> inline \ +static T1& \ +Name(T1& lhs, const T2& rhs) \ +{ \ + ntg_is_a(T1, ntg::vectorial)::ensure(); \ + ntg_is_a(T2, ntg::vectorial)::ensure(); \ + precondition(lhs.size() == rhs.size()); \ + unsigned s = lhs.size(); \ + for (unsigned i = 0; i < s; ++i) \ + lhs[i] Op rhs[i]; \ + return lhs; \ +} + +# define ASSIGN_VECTOR_SCALAR_OPERATOR(Name, Op) \ +template <class T1, class T2> inline \ +static T1& \ +Name(T1& lhs, const T2& rhs) \ +{ \ + ntg_is_a(T1, ntg::vectorial)::ensure(); \ + ntg_is_a(T2, ntg::real)::ensure(); \ + unsigned s = lhs.size(); \ + for (unsigned i = 0; i < s; ++i) \ + lhs[i] Op rhs; \ + return lhs; \ +} + +# define ARITH_VECTOR_VECTOR_OPERATOR(Name, Op) \ +template <class T1, class T2> \ +inline static \ +ntg_return_type(Name,T1, T2) \ +Name(const T1& lhs, const T2& rhs) \ +{ \ + ntg_is_a(T1, ntg::vectorial)::ensure(); \ + ntg_is_a(T2, ntg::vectorial)::ensure(); \ + typedef ntg_return_type(Name,T1, T2) return_type; \ + return_type result(lhs); \ + result Op rhs; \ + return result; \ +} + +namespace ntg { + + namespace internal { + + /*----------------. + | typetraits<vec> | + `----------------*/ + + template <unsigned N, class T, class Self> + struct typetraits<vec<N, T, Self> > : public typetraits<vect_value<vec<N, T, Self> > > + { + enum { nb_comp = N }; + + typedef vec<N, T, Self> self; + typedef vectorial abstract_type; + typedef self ntg_type; + typedef optraits<self> optraits_type; + + ntg_build_value_type(vect_value<E>); + + // FIXME: document comp_type + typedef T comp_type; + typedef self base_type; + typedef T storage_type[N]; + typedef typename typetraits<T>::cumul_type cumul_type[N]; + + static const self &sup() + { + static self tmp = mkSup(); + + return tmp; + }; + + protected: + static self mkSup() + { + self tmp; + + for (unsigned i = 0; i < N; ++i) + tmp[i] = ntg_sup_val(T); + return tmp; + }; + }; + + } // end of internal. + + /*----------. + | vec<N, T> | + `----------*/ + + template <unsigned N, class T, class E> + class vec : + public vect_value<typename ntg::exact_vt<vec<N, T, ntg::final>, E>::ret> + { + public : + + vec() + { + _fill (ntg_zero_val(T)); + } + + /* A vector can be built from a 1xM array. */ + template<int ncols, class T2> + vec(const mlc::array2d< mlc::array2d_info<1, ncols>, T2>& arr) + { + mlc::is_true< ncols == N >::ensure(); + for (unsigned i = 0; i < N; ++i) + this->val_[i] = arr[i]; + } + + template<class U, class E2> + vec(const vec<N, U, E2>& v) + { + for (unsigned i = 0; i < N; ++i) + this->val_[i] = v[i]; + } + + template<class U, class E2> + vec<N, T>& operator=(const vec<N, U, E2>& v) + { + for (unsigned i = 0; i < N; ++i) + this->val_[i] = v[i]; + return *this; + } + + static const vec<N,T> zero() { return vec(); } + // There is no unit() for vec<>. + + ~vec() {} + + protected: + vec& _fill(T t) + { + for (unsigned i = 0; i < N; ++i) + this->val_[i] = t; + return *this; + } + }; + + template<unsigned N,class T> inline + std::ostream& + operator<<(std::ostream& ostr, const vec<N,T>& rhs) + { + // dev note: we use an ostringstream to make only one output + // on the ostream. This allows calling procedures to consider + // data type printing as atomic, thus ostr.width(...) can + // work. + std::ostringstream str; + str << "["; + for (unsigned i = 0; i < N; ++i) + str << rhs[i] << ((i < N-1) ? "," : "]"); + ostr << str.str(); + return ostr; + } + + namespace internal + { + + /*--------------. + | optraits<vec> | + `--------------*/ + + template <unsigned N, class T, class E> + class optraits<vec<N, T, E> > : public optraits<vect_value<vec<N, T, E> > > + { + typedef vec<N, T, E> self; + typedef ntgi_storage_type(self) storage_type_; + + public: + static self zero () + { + // A vectorial type MUST return a zero initialized value. + return self(); + } + + static unsigned max_print_width () + { + return (N * ntg_max_print_width(T)) + (N - 1) + 2; + } + + static std::string + name() { + std::ostringstream out; + out << "vec<" << N << ", " << ntg_name(T) << ">"<< std::ends; + return out.str(); + } + + // No unit() for vector. + // static storage_type_ unit (); + + ASSIGN_VECTOR_VECTOR_OPERATOR(plus_equal, +=) + ASSIGN_VECTOR_VECTOR_OPERATOR(minus_equal, -=) + ASSIGN_VECTOR_SCALAR_OPERATOR(times_equal, *=) + ASSIGN_VECTOR_SCALAR_OPERATOR(div_equal, /=) + ASSIGN_VECTOR_SCALAR_OPERATOR(mod_equal, %=) + + ARITH_VECTOR_VECTOR_OPERATOR(plus, +=) + ARITH_VECTOR_VECTOR_OPERATOR(minus, -=) + + // division + + template <class T1, class T2> + inline static + ntg_return_type(div, T1, T2) + div(const T1& lhs, const T2& rhs) + { + ntg_is_a(T1, ntg::vectorial)::ensure(); + ntg_is_a(T2, ntg::real)::ensure(); + typedef ntg_return_type(div, T1, T2) return_type; + return_type result(lhs); + result /= rhs; + return result; + } + + // modulo + + template <class T1, class T2> + inline static + ntg_return_type(mod, T1, T2) + mod(const T1& lhs, const T2& rhs) + { + ntg_is_a(T1, ntg::vectorial)::ensure(); + ntg_is_a(T2, ntg::real)::ensure(); + typedef ntg_return_type(mod, T1, T2) return_type; + return_type result(lhs); + result %= rhs; + return result; + } + + // multiplication + + // dot-product + template <unsigned M, class T1, class T2> + inline static typename + internal::deduce_from_traits<internal::operator_times, + vec<M, T1>, + vec<M, T2> >::ret + times(const vec<M, T1>& lhs, const vec<M, T2>& rhs) + { + typedef vec<M, T1> vec1; + typedef vec<M, T2> vec2; + ntg_is_a(vec1, ntg::vectorial)::ensure(); + ntg_is_a(vec2, ntg::vectorial)::ensure(); + typedef typename + internal::deduce_from_traits<internal::operator_times, + vec<M, T1>, vec<M, T2> >::ret return_type; + precondition(lhs.size() == rhs.size()); + + return_type result = optraits<return_type>::zero(); + unsigned s = lhs.size(); + for (unsigned i = 0; i < s; ++i) + result += lhs[i] * rhs[i]; + + return result; + } + + // vector * scalar + template <class T1, class T2> + inline static + ntg_return_type(times, T1, T2) + times(const vect_value<T1>& lhs, const T2& rhs) + { + ntg_is_a(T1, ntg::vectorial)::ensure(); + ntg_is_a(T2, ntg::real)::ensure(); + typedef ntg_return_type(times, T1, T2) return_type; + return_type result(lhs.exact()); + result *= rhs; + return result; + } + + // scalar * vector + template <class T1, class T2> + inline static + ntg_return_type(times, T1, T2) + times(const T1& lhs, const vect_value<T2>& rhs) + { + return times(rhs, lhs); + } + + + template <class T1, class T2> + inline static bool + cmp_eq (const T1& lhs, const T2& rhs) + { + ntg_is_a(T1, ntg::vectorial)::ensure(); + ntg_is_a(T2, ntg::vectorial)::ensure(); + ntg_assert(lhs.size() == rhs.size()); + + typedef ntg_return_type(cmp, T1, T2) tmp_type; + + unsigned s = lhs.size(); + for (unsigned i = 0; i < s; ++i) + if (lhs[i] != rhs[i]) + return false; + return true; + } + }; + + /*----------------. + | operator traits | + `----------------*/ + + // + // plus + // + + // vec + vec + + template<unsigned N, class T1, class T2, class S1, class S2> + struct operator_traits<operator_plus, vec<N, T1, S1>, vec<N, T2, S2> > + { + enum { commutative = true }; + typedef vec<N, ntg_return_type(plus, T1, T2)> ret; + typedef vec<N, T1> impl; + }; + + // + // minus + // + + // vec - vec + + template<unsigned N, class T1, class T2> + struct operator_traits<operator_minus, vec<N, T1>, vec<N, T2> > + { + enum { commutative = true }; + typedef vec<N, ntg_return_type(minus, T1, T2)> ret; + typedef vec<N, T1> impl; + }; + + // + // times + // + + // vec * s; s * vec + + template<unsigned N, class T1, class T2> + struct operator_traits<operator_times, vec<N, T1>, T2> + { + enum { commutative = true }; + typedef vec<N, ntg_return_type(times, T1, T2)> ret; + typedef vec<N, T1> impl; + }; + + // vec * vec + + template<unsigned N, class T1, class T2> + struct operator_traits<operator_times, vec<N, T1>, vec<N, T2> > + { + enum { commutative = true }; + typedef ntg_return_type(times,T1,T2) t; + typedef typename typetraits<t>::cumul_type ret; + typedef vec<N, T1> impl; + }; + + // + // div + // + + // vec / s + + template<unsigned N, class T1, class T2> + struct operator_traits<operator_div, vec<N, T1>, T2> + { + enum { commutative = false }; + typedef vec<N, ntg_return_type(div, T1, T2)> ret; + typedef vec<N, T1> impl; + }; + + // + // mod + // + + // vec % s + + template<unsigned N, class T1, class T2> + struct operator_traits<operator_mod, vec<N, T1>, T2> + { + enum { commutative = false }; + typedef vec<N, ntg_return_type(mod, T1, T2)> ret; + typedef vec<N, T1> impl; + }; + + // + // Comparison operator + // + + // vec compared with vec + + template<unsigned N, class T1, class T2, class S1, class S2> + struct operator_traits<operator_cmp, vec<N, T1, S1>, vec<N, T2, S2> > + { + enum { commutative = true }; + typedef vec<N, ntg_return_type(cmp, T1, T2)> ret; + typedef vec<N, T1> impl; + }; + + } // end of internal. + +} // end of ntg. + +#endif // !NTG_VECT_VEC_HH Index: ntg/basics.hh --- ntg/basics.hh (revision 0) +++ ntg/basics.hh (revision 0) @@ -0,0 +1,61 @@ +// Copyright (C) 2001, 2002, 2003 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_BASICS_HH +# define NTG_BASICS_HH + +/* + Basic header that regroup basic common headers every file + will certainely need. +*/ + +# include <ntg/config/system.hh> + +# include <ntg/core/predecls.hh> + +# include <ntg/core/abstract_hierarchy.hh> +# include <ntg/real/behavior.hh> +# include <ntg/core/contract.hh> +# include <ntg/core/interval.hh> +# include <ntg/real/builtin_properties.hh> +# include <ntg/core/type.hh> +# include <ntg/core/value.hh> + +/* + These headers are included as builtins may be used anywhere, without + having previously included the corresponding integre headers. +*/ +# include <ntg/enum/builtin_bool.hh> +# include <ntg/real/builtin_int.hh> +# include <ntg/real/builtin_float.hh> + +# include <ntg/core/internal/global_ops.hh> +# include <ntg/core/macros.hh> + +# include <ntg/utils/cast.hh> + +#endif // !NTG_BASICS_HH Index: ntg/makefile.src --- ntg/makefile.src (revision 59) +++ ntg/makefile.src (working copy) @@ -4,14 +4,60 @@ ## NTG_DEP = \ - color/rgb_8.hh \ + all.hh \ + basics.hh \ + bin.hh \ + color.hh \ color/color.hh \ + color/hsi.hh \ + color/hsl.hh \ + color/hsv.hh \ + color/nrgb.hh \ + color/rgb.hh \ + color/xyz.hh \ + color/yiq.hh \ + color/yuv.hh \ + config/math.hh \ config/system.hh \ - config/math.hh \ - core/cats.hh \ + core/abstract_hierarchy.hh \ + real/behavior.hh \ + core/contract.hh \ + core/internal/global_ops.hh \ + core/internal/global_ops_defs.hh \ + core/internal/global_ops_traits.hh \ + core/internal/macros.hh \ + core/internal/traits.hh \ + core/interval.hh \ core/macros.hh \ - core/props.hh \ + core/pred_succ.hh \ + core/predecls.hh \ + core/type.hh \ + core/type_traits.hh \ + core/value.hh \ + cplx.hh \ + cycle.hh \ enum/bin.hh \ - enum/enum.hh \ - real/int_u8.hh \ - real/integer.hh + enum/builtin_bool.hh \ + enum/enum_value.hh \ + float.hh \ + int.hh \ + range.hh \ + real/builtin_int.hh \ + real/builtin_float.hh \ + real/builtin_properties.hh \ + real/cycle.hh \ + real/int_s.hh \ + real/int_u.hh \ + real/optraits_builtin_int.hh \ + real/optraits_real.hh \ + real/optraits_real_defs.hh \ + real/range.hh \ + real/real_value.hh \ + real/typetraits_builtin_int.hh \ + utils/cast.hh \ + utils/debug.hh \ + vec.hh \ + vect/cplx.hh \ + vect/cplx_representation.hh \ + vect/vec.hh \ + vect/vect_value.hh Index: ntg/float.hh --- ntg/float.hh (revision 0) +++ ntg/float.hh (revision 0) @@ -0,0 +1,38 @@ +// Copyright (C) 2001, 2002, 2003 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_FLOAT_HH +# define NTG_FLOAT_HH + +/* + Proxy header for float types (float_s and float_d). +*/ + +# include <ntg/basics.hh> +# include <ntg/real/builtin_float.hh> + +#endif // !NTG_FLOAT_HH Index: ntg/enum/builtin_bool.hh --- ntg/enum/builtin_bool.hh (revision 0) +++ ntg/enum/builtin_bool.hh (revision 0) @@ -0,0 +1,87 @@ +// Copyright (C) 2002, 2003 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_ENUM_BUILTIN_BOOL_HH +# define NTG_ENUM_BUILTIN_BOOL_HH + +# include <ntg/core/abstract_hierarchy.hh> +# include <ntg/real/behavior.hh> +# include <ntg/core/predecls.hh> +# include <ntg/core/type_traits.hh> + +namespace ntg { + + namespace internal { + + /*-----------------. + | typetraits<bool> | + `-----------------*/ + + template <> + struct typetraits<bool> + { + typedef bool self; + typedef binary abstract_type; + typedef bin ntg_type; + typedef optraits<self> optraits_type; + typedef unsafe::get<self> behavior_type; + + typedef self base_type; + typedef self storage_type; + typedef self cumul_type; + typedef self largest_type; + typedef self signed_largest_type; + typedef self signed_cumul_type; + typedef self unsigned_largest_type; + typedef self unsigned_cumul_type; + typedef unsigned int integer_type; + }; + + /*---------------. + | optraits<bool> | + `---------------*/ + + template<> + struct optraits<bool> + { + static bool min() { return 0; } + static bool max() { return 1; } + static bool zero() { return 0; } + static bool unit() { return 1; } + static bool inf() { return min(); } + static bool sup() { return max(); } + + static unsigned max_print_width () { return 1U; } + + static std::string name() { return "bool"; } + }; + + } // end of internal. + +} // end of ntg. + +#endif // !NTG_ENUM_BUILTIN_BOOL_HH Index: ntg/enum/enum.hh --- ntg/enum/enum.hh (revision 59) +++ ntg/enum/enum.hh (working copy) @@ -1,97 +0,0 @@ -// 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 INTEGRE_ENUM_ENUM_HH -# define INTEGRE_ENUM_ENUM_HH - -# include <mlc/any.hh> - -# include <ntg/core/cats.hh> -# include <ntg/core/props.hh> - -namespace ntg { - - template <typename E> struct enum_value; - - template <typename E> - struct category_type< enum_value<E> > { typedef cat::enum_value ret; }; - - template <> - struct default_props < cat::enum_value > - { - enum { max_val = 0 }; - enum { depth = 1 }; - typedef mlc::no_type io_type; - - protected: - default_props() {} - }; - - template <typename E> - struct enum_value : public mlc::any__best_memory<E> - { - typedef E exact_type; - - bool operator==(int rhs) const - { - return this->exact().impl_eq(rhs); - } - - template <typename I> - bool operator==(const enum_value<I>& rhs) const - { - return this->exact().impl_eq(rhs.exact()); - } - - template <typename V> - bool operator!=(const V& rhs) const - { - return ! this->operator==(rhs); - } - - template <typename V> - exact_type& operator=(const V& rhs) - { - return this->exact().impl_assign(rhs); - } - - template <typename V> - exact_type& operator+(const V& rhs) const - { - return this->exact().impl_add(rhs); - } - - protected: - enum_value() {} - }; - -} // end of namespace ntg - - - - -#endif // ! INTEGRE_ENUM_ENUM_HH Index: ntg/enum/bin.hh --- ntg/enum/bin.hh (revision 59) +++ ntg/enum/bin.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2005 EPITA Research and Development Laboratory +// Copyright (C) 2001, 2002, 2003, 2004 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 @@ -25,98 +25,243 @@ // reasons why the executable file might be covered by the GNU General // Public License. -#ifndef INTEGRE_ENUM_BIN_HH -# define INTEGRE_ENUM_BIN_HH +#ifndef NTG_ENUM_BIN_HH +# define NTG_ENUM_BIN_HH -# include <mlc/traits.hh> +/* + Binary type. Possible values are 0 and 1 (not true and false). +*/ -# include <ntg/core/props.hh> -# include <ntg/core/cats.hh> -# include <ntg/enum/enum.hh> +# include <ntg/basics.hh> +# include <ntg/enum/enum_value.hh> +# include <ntg/core/internal/global_ops.hh> +# include <mlc/contract.hh> + +# include <string> + namespace ntg { - struct bin; + namespace internal { - template <> - struct category_type< bin > { typedef cat::enum_value ret; }; + /*----------------. + | typetraits<bin> | + `----------------*/ + template <> + struct typetraits<bin> : typetraits<enum_value<bin> > + { + typedef binary abstract_type; + typedef bin self; + typedef self ntg_type; - template <> - struct props<cat::enum_value, bin> : public default_props<cat::enum_value> - { - enum { max_val = 1 }; - typedef unsigned char io_type; - }; + ntg_build_value_type(enum_value<E>); - struct bin : public enum_value<bin> + typedef optraits<self> optraits_type; + + typedef self base_type; + typedef bool storage_type; + typedef bin signed_type; + typedef bin unsigned_type; + typedef bin cumul_type; + typedef bin largest_type; + typedef bin signed_largest_type; + typedef bin signed_cumul_type; + typedef bin unsigned_largest_type; + typedef bin unsigned_cumul_type; + typedef unsigned int integer_type; + + // Particular properties + enum { size = 1 }; + }; + + } // end of internal. + + /*----. + | bin | + `----*/ + + class bin : public enum_value<bin> { - bin() : - value_(0) - { - } + public: + bin () + { this->val_ = 0; } - bin(unsigned char value) : - value_(value) - { - } + // FIXME: create a template constructor and check into it if T + // is a real or whatever ? - bin(const bin& rhs) : - value_(rhs) + bin (unsigned char val) { + ntg_assert(val < 2); + this->val_ = val; } - template <typename V> - bin& impl_assign(const V& rhs) + bin& + operator=(unsigned char val) { - this->value_ = (int)rhs % 2; + ntg_assert(val < 2); + this->val_ = val; return *this; } - operator unsigned char() const + template <class T> + bin (const real_value<T>& val) { - return value_; + ntg_assert(val < 2); + this->val_ = val.val(); } - - bool impl_eq(const unsigned char& rhs) const + template <class T> + bin& + operator=(const real_value<T>& val) { - return this->value_ == rhs; + ntg_assert(val < 2); + this->val_ = val.val(); + return *this; } - template <typename V> - bool impl_eq(const V& rhs) const - { - return this->value_ == (unsigned char)rhs; - } + operator unsigned char() const { return this->val_; } + }; + inline std::ostream& + operator<<(std::ostream& stream, const bin& rhs) + { + stream << (unsigned int) rhs.val(); + return stream; + } - template <typename V> - bin impl_add(const V& rhs) const + namespace internal { + + /*--------------. + | optraits<bin> | + `--------------*/ + + template <> + struct optraits<bin> : public optraits<enum_value<bin> > { - bin tmp((this->value_ + rhs) % 2); - return tmp; - } + private: + typedef typetraits<bin>::storage_type storage_type_; - private: + public: + static storage_type_ zero() { return 0; } + static storage_type_ unit() { return 1; } + static storage_type_ min() { return 0; } + static storage_type_ max() { return 1; } + static storage_type_ inf() { return min(); } + static storage_type_ sup() { return max(); } + static unsigned max_print_width () { return 1U; } - unsigned char value_; - }; + // logical assignement operators + static bin& + logical_or_equal(bin& lhs, const bin& rhs) + { + lhs = lhs.val() | rhs.val(); + return lhs; + } -} // end of namespace ntg + static bin& + logical_and_equal(bin& lhs, const bin& rhs) + { + lhs = lhs.val() & rhs.val(); + return lhs; + } + static bin& + logical_xor_equal(bin& lhs, const bin& rhs) + { + lhs = lhs.val() ^ rhs.val(); + return lhs; + } + // logical binary ops -namespace mlc { + static bin + logical_or(const bin& lhs, const bin& rhs) + { + bin tmp(lhs); + tmp |= rhs; + return tmp; + } - template <> - struct traits < ntg::bin > - { - typedef unsigned char encoding_type; - }; + static bin + logical_and(const bin& lhs, const bin& rhs) + { + bin tmp(lhs); + tmp &= rhs; + return tmp; + } -} // end of namespace mlc + static bin + logical_xor(const bin& lhs, const bin& rhs) + { + bin tmp(lhs); + tmp ^= rhs; + return tmp; + } + // comparisons + static bool + cmp_lt(const bin& lhs, const bin& rhs) + { + return lhs.val() < rhs.val(); + } -#endif // ! INTEGRE_ENUM_BIN_HH + static bool + cmp_eq(const bin& lhs, const bin& rhs) + { + return lhs.val() == rhs.val(); + } + + static std::string name() { return "bin"; } + }; + + /*-----------------. + | operators traits | + `-----------------*/ + + // Logical operators + + template <class T> + struct operator_traits<operator_logical, bin, T> + { + enum { commutative = true }; + typedef bin ret; + typedef bin impl; + }; + + // Comparison operators + + template <> + struct operator_traits<operator_cmp, bin, bin> + { + enum { commutative = true }; + typedef bin ret; + typedef bin impl; + }; + + // Max + + template <> + struct operator_traits<operator_max, bin, bin> + { + enum { commutative = true }; + typedef bin ret; + typedef bin impl; + }; + + // Min + + template <> + struct operator_traits<operator_min, bin, bin> + { + enum { commutative = true }; + typedef bin ret; + typedef bin impl; + }; + + } // end of internal. + +} // end of ntg. + +#endif // !NTG_ENUM_BIN_HH Index: ntg/enum/enum_value.hh --- ntg/enum/enum_value.hh (revision 0) +++ ntg/enum/enum_value.hh (revision 0) @@ -0,0 +1,59 @@ +// Copyright (C) 2001, 2002, 2003 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_ENUM_ENUM_VALUE_HH +# define NTG_ENUM_ENUM_VALUE_HH + +# include <ntg/core/value.hh> +# include <ntg/core/type_traits.hh> + +namespace ntg +{ + + /*-----------. + | enum_value | + `-----------*/ + + template <class E> + class enum_value : public value<E> + {}; + + namespace internal { + + template <class E> + class typetraits<enum_value<E> > : public typetraits<value<E> > + {}; + + template <class E> + class optraits<enum_value<E> > : public optraits<value<E> > + {}; + + } + +} + +#endif // !NTG_ENUM_ENUM_VALUE_HH Index: ntg/cplx.hh --- ntg/cplx.hh (revision 0) +++ ntg/cplx.hh (revision 0) @@ -0,0 +1,37 @@ +// Copyright (C) 2001, 2002, 2003 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_CPLX_HH +# define NTG_CPLX_HH + +/* + Proxy header for cplx type. +*/ + +# include <ntg/vect/cplx.hh> + +#endif // !NTG_CPLX_HH Index: ntg/all.hh --- ntg/all.hh (revision 59) +++ ntg/all.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2005 EPITA Research and Development Laboratory +// Copyright (C) 2001, 2002, 2003 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 @@ -28,9 +28,23 @@ #ifndef NTG_ALL_HH # define NTG_ALL_HH -# include <ntg/core/macros.hh> -# include <ntg/color/rgb_8.hh> -# include <ntg/real/int_u8.hh> -# include <ntg/enum/bin.hh> +/* + Include all Integre's features. +*/ -#endif // ! NTG_ALL_HH +# include <ntg/basics.hh> + +# include <ntg/bin.hh> + +# include <ntg/int.hh> +# include <ntg/cycle.hh> +# include <ntg/range.hh> + +# include <ntg/vec.hh> +# include <ntg/cplx.hh> + +# include <ntg/color.hh> + +# include <ntg/utils/cast.hh> + +#endif // !NTG_ALL_HH Index: ntg/bin.hh --- ntg/bin.hh (revision 0) +++ ntg/bin.hh (revision 0) @@ -0,0 +1,37 @@ +// Copyright (C) 2001, 2002, 2003 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_BIN_HH +# define NTG_BIN_HH + +/* + Proxy header for bin type. +*/ + +# include <ntg/enum/bin.hh> + +#endif // !NTG_BIN_HH Index: ntg/Makefile.am --- ntg/Makefile.am (revision 59) +++ ntg/Makefile.am (working copy) @@ -5,3 +5,61 @@ include $(srcdir)/makefile.src ntgdir = $(includedir)/ntg +nobase_ntg_HEADERS = \ + all.hh \ + basics.hh \ + bin.hh \ + color.hh \ + color/color.hh \ + color/hsi.hh \ + color/hsl.hh \ + color/hsv.hh \ + color/nrgb.hh \ + color/rgb.hh \ + color/xyz.hh \ + color/yiq.hh \ + color/yuv.hh \ + config/math.hh \ + config/system.hh \ + core/abstract_hierarchy.hh \ + real/behavior.hh \ + core/contract.hh \ + core/internal/global_ops.hh \ + core/internal/global_ops_defs.hh \ + core/internal/global_ops_traits.hh \ + core/internal/macros.hh \ + core/internal/traits.hh \ + core/interval.hh \ + core/macros.hh \ + core/pred_succ.hh \ + core/predecls.hh \ + core/type.hh \ + core/type_traits.hh \ + core/value.hh \ + cplx.hh \ + cycle.hh \ + enum/bin.hh \ + enum/builtin_bool.hh \ + enum/enum_value.hh \ + float.hh \ + int.hh \ + range.hh \ + real/builtin_int.hh \ + real/builtin_float.hh \ + real/builtin_properties.hh \ + real/cycle.hh \ + real/int_s.hh \ + real/int_u.hh \ + real/optraits_builtin_int.hh \ + real/optraits_real.hh \ + real/optraits_real_defs.hh \ + real/range.hh \ + real/real_value.hh \ + real/typetraits_builtin_int.hh \ + utils/cast.hh \ + utils/debug.hh \ + vec.hh \ + vect/cplx.hh \ + vect/cplx_representation.hh \ + vect/vec.hh \ + vect/vect_value.hh Index: ntg/vec.hh --- ntg/vec.hh (revision 0) +++ ntg/vec.hh (revision 0) @@ -0,0 +1,35 @@ +// Copyright (C) 2001, 2002, 2003 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_VEC_HH +# define NTG_VEC_HH + +// Proxy header for vec type. + +# include <ntg/vect/vec.hh> + +#endif // !NTG_VEC_HH Index: ntg/color.hh --- ntg/color.hh (revision 0) +++ ntg/color.hh (revision 0) @@ -0,0 +1,44 @@ +// Copyright (C) 2001, 2002, 2003 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_COLOR_HH +# define NTG_COLOR_HH + +/* + Proxy header for color types. +*/ + +# include <ntg/color/rgb.hh> +# include <ntg/color/nrgb.hh> +# include <ntg/color/hsi.hh> +# include <ntg/color/hsl.hh> +# include <ntg/color/hsv.hh> +# include <ntg/color/xyz.hh> +# include <ntg/color/yiq.hh> +# include <ntg/color/yuv.hh> + +#endif // !NTG_COLOR_HH Index: ntg/color/rgb_8.hh --- ntg/color/rgb_8.hh (revision 59) +++ ntg/color/rgb_8.hh (working copy) @@ -1,153 +0,0 @@ -// 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 INTEGRE_COLOR_RGB_8_HH -# define INTEGRE_COLOR_RGB_8_HH - -# include <mlc/traits.hh> - -# include <ntg/core/props.hh> -# include <ntg/color/color.hh> - -namespace ntg { - - struct rgb_8; - - template <> - struct category_type< rgb_8 > { typedef cat::color ret; }; - - - template <> - struct props<cat::color, rgb_8> : default_props<cat::color> - { - enum { max_val = 255 }; - enum { depth = 3 }; - - typedef char io_type; - typedef unsigned char comp_type; - }; - - enum { - rgb_red = 0, - rgb_green = 1, - rgb_blue = 2 - }; - - - struct rgb_8: public color <rgb_8> - { - rgb_8() - { - this->value_[rgb_red] = 0; - this->value_[rgb_green] = 0; - this->value_[rgb_blue] = 0; - } - - rgb_8(const unsigned char init[3]) - { - for (unsigned i = 0; i < 3; i++) - value_[i] = init[i]; - } - - rgb_8(unsigned char red, - unsigned char green, - unsigned char blue) - { - this->value_[rgb_red] = red; - this->value_[rgb_green] = green; - this->value_[rgb_blue] = blue; - } - - rgb_8(const rgb_8& rhs) - { - this->value_[rgb_red] = rhs[rgb_red]; - this->value_[rgb_green] = rhs[rgb_green]; - this->value_[rgb_blue] = rhs[rgb_blue]; - } - - rgb_8& impl_assign(const rgb_8& rhs) - { - this->value_[rgb_red] = rhs[rgb_red]; - this->value_[rgb_green] = rhs[rgb_green]; - this->value_[rgb_blue] = rhs[rgb_blue]; - return *this; - } - - bool impl_eq(const rgb_8& rhs) const - { - return this->value_[rgb_red] == rhs[rgb_red] && - this->value_[rgb_green] == rhs[rgb_green] && - this->value_[rgb_blue] == rhs[rgb_blue]; - } - - unsigned char& impl_op_sqbr(unsigned int i) - { - assert(i < 3); - return value_[i]; - } - - const unsigned char impl_op_sqbr(unsigned int i) const - { - assert(i < 3); - return value_[i]; - } - - private: - - unsigned char value_[3]; - }; - - -} // end of namespace ntg - - -# include <ostream> - -std::ostream& operator<<(std::ostream& ostr, const ntg::rgb_8& to_print) -{ - ostr << "(" << unsigned(to_print[0]) - << "," << unsigned(to_print[1]) - << "," << unsigned(to_print[2]) - << ")"; - return ostr; -} - - - -namespace mlc { - - template <> - struct traits < ntg::rgb_8 > - { - typedef ntg::rgb_8 encoding_type; - }; - -} // end of namespace mlc - - - -#endif // ! NTG_COLOR_RGB_8_HH Index: ntg/color/yiq.hh --- ntg/color/yiq.hh (revision 0) +++ ntg/color/yiq.hh (revision 0) @@ -0,0 +1,64 @@ +// Copyright (C) 2001, 2002, 2003 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_COLOR_YIQ_HH +# define NTG_COLOR_YIQ_HH + +# include <ntg/color/color.hh> + +namespace ntg +{ + + enum yiq_comp + { + yiq_Y = 0, + yiq_I = 1, + yiq_Q = 2 + }; + + template<unsigned icomp> struct yiq_traits; + template<> struct yiq_traits<yiq_Y> : public interval<0,1> {}; + + template<> struct yiq_traits<yiq_I> + { + static float lower_bound() { return -.4192; } + static float upper_bound() { return .5346; } + }; + + template<> struct yiq_traits<yiq_Q> + { + static float lower_bound() { return -.6783; } + static float upper_bound() { return .6527; } + }; + + typedef color<3,8,yiq_traits> yiq_8; + typedef color<3,16,yiq_traits> yiq_16; + typedef color<3,32,yiq_traits> yiq_32; + +} // end of ntg. + +#endif // !NTG_COLOR_YIQ_HH Index: ntg/color/hsi.hh --- ntg/color/hsi.hh (revision 0) +++ ntg/color/hsi.hh (revision 0) @@ -0,0 +1,63 @@ +// Copyright (C) 2001, 2002, 2003 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_COLOR_HSI_HH +# define NTG_COLOR_HSI_HH + +# include <ntg/color/color.hh> + +namespace ntg +{ + + enum hsi_comp + { + hsi_H = 0, + hsi_S = 1, + hsi_I = 2 + }; + + template<unsigned icomp> struct hsi_traits; + template<> struct hsi_traits<hsi_H> : public interval<0,360> {}; + template<> struct hsi_traits<hsi_S> + { + static float lower_bound() { return 0.; } + static float upper_bound() { return 0.816497; } //2 / sqrt(6) + }; + + template<> struct hsi_traits<hsi_I> + { + static float lower_bound() { return 0.; } + static float upper_bound() { return 1.7320508; } //sqrt(3) + }; + + typedef color<3,8,hsi_traits> hsi_8; + typedef color<3,16,hsi_traits> hsi_16; + typedef color<3,32,hsi_traits> hsi_32; + +} // end of ntg. + +#endif // !NTG_COLOR_HSI_HH Index: ntg/color/yuv.hh --- ntg/color/yuv.hh (revision 0) +++ ntg/color/yuv.hh (revision 0) @@ -0,0 +1,63 @@ +// Copyright (C) 2001, 2002, 2003 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_COLOR_YUV_HH +# define NTG_COLOR_YUV_HH + +# include <ntg/color/color.hh> + +namespace ntg +{ + + enum yuv_comp + { + yuv_Y = 0, + yuv_U = 1, + yuv_V = 2 + }; + + template<unsigned icomp> struct yuv_traits; + template<> struct yuv_traits<yuv_Y> : public interval<0,1> {}; + template<> struct yuv_traits<yuv_U> + { + static float lower_bound() { return -0.517; } + static float upper_bound() { return 0.437; } + }; + + template<> struct yuv_traits<yuv_V> + { + static float lower_bound() { return -0.576; } + static float upper_bound() { return 0.654; } + }; + + typedef color<3,8,yuv_traits> yuv_8; + typedef color<3,16,yuv_traits> yuv_16; + typedef color<3,32,yuv_traits> yuv_32; + +} // end of ntg. + +#endif // !NTG_COLOR_YUV_HH Index: ntg/color/hsl.hh --- ntg/color/hsl.hh (revision 0) +++ ntg/color/hsl.hh (revision 0) @@ -0,0 +1,54 @@ +// Copyright (C) 2001, 2002, 2003 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_COLOR_HSL_HH +# define NTG_COLOR_HSL_HH + +# include <ntg/color/color.hh> + +namespace ntg +{ + + enum hsl_comp + { + hsl_H = 0, + hsl_S = 1, + hsl_L = 2 + }; + + template<unsigned icomp> struct hsl_traits; + template<> struct hsl_traits<hsl_H> : public interval<0,360> {}; + template<> struct hsl_traits<hsl_S> : public interval<0,1> {}; + template<> struct hsl_traits<hsl_L> : public interval<0,1> {}; + + typedef color<3,8,hsl_traits> hsl_8; + typedef color<3,16,hsl_traits> hsl_16; + typedef color<3,32,hsl_traits> hsl_32; + +} // end of ntg + +#endif // !NTG_COLOR_HSL_HH Index: ntg/color/nrgb.hh --- ntg/color/nrgb.hh (revision 0) +++ ntg/color/nrgb.hh (revision 0) @@ -0,0 +1,130 @@ +// Copyright (C) 2001, 2002, 2003 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_NRGB_HH +# define NTG_NRGB_HH + +# include <ntg/color/color.hh> + +namespace ntg +{ + + /*! + NTSC RGB format. + */ + + enum nrgb_comp + { + nrgb_R = 0, + nrgb_G = 1, + nrgb_B = 2 + }; + + template<unsigned icomp> struct nrgb_traits; + template<> + struct nrgb_traits<nrgb_R> + { + static float lower_bound() { return 0;} + static float upper_bound() { return 1.0885004;} + }; + + + template<> + struct nrgb_traits<nrgb_G> + { + static float lower_bound() { return -0.3321984;} + static float upper_bound() { return 1.3189264;} + }; + + + template<> + struct nrgb_traits<nrgb_B> + { + static float lower_bound() { return -0.0688480;} + static float upper_bound() { return 0.904727;} + }; + + + typedef color<3,8,nrgb_traits> nrgb_8; + typedef color<3,16,nrgb_traits> nrgb_16; + typedef color<3,32,nrgb_traits> nrgb_32; + + // FIXME: not thread safe ! +# define DEFINE_COLOR(Type, Name, V1, V2, V3) \ + inline const Type& Name() { \ + static const Type tmp(V1, V2, V3); \ + return tmp; \ + } + + namespace nrgb_8_color + { + + DEFINE_COLOR(nrgb_8, white, 255, 255, 255) + DEFINE_COLOR(nrgb_8, gray, 128, 128, 128) + DEFINE_COLOR(nrgb_8, black, 0, 0, 0) + DEFINE_COLOR(nrgb_8, red, 255, 0, 0) + DEFINE_COLOR(nrgb_8, green, 0, 255, 0) + DEFINE_COLOR(nrgb_8, blue, 0, 0, 255) + DEFINE_COLOR(nrgb_8, yellow,255, 255, 0) + DEFINE_COLOR(nrgb_8, cyan, 0, 255, 255) + DEFINE_COLOR(nrgb_8, pink, 255, 0, 255) + + } // end of nrgb_8_color + + namespace nrgb_16_color + { + + DEFINE_COLOR(nrgb_16, white, 255, 255, 255) + DEFINE_COLOR(nrgb_16, gray, 128, 128, 128) + DEFINE_COLOR(nrgb_16, black, 0, 0, 0) + DEFINE_COLOR(nrgb_16, red, 255, 0, 0) + DEFINE_COLOR(nrgb_16, green, 0, 255, 0) + DEFINE_COLOR(nrgb_16, blue, 0, 0, 255) + DEFINE_COLOR(nrgb_16, yellow,255, 255, 0) + DEFINE_COLOR(nrgb_16, cyan, 0, 255, 255) + DEFINE_COLOR(nrgb_16, pink, 255, 0, 255) + + } // end of nrgb_16_color + + namespace nrgb_32_color + { + + DEFINE_COLOR(nrgb_32, white, 255, 255, 255) + DEFINE_COLOR(nrgb_32, gray, 128, 128, 128) + DEFINE_COLOR(nrgb_32, black, 0, 0, 0) + DEFINE_COLOR(nrgb_32, red, 255, 0, 0) + DEFINE_COLOR(nrgb_32, green, 0, 255, 0) + DEFINE_COLOR(nrgb_32, blue, 0, 0, 255) + DEFINE_COLOR(nrgb_32, yellow,255, 255, 0) + DEFINE_COLOR(nrgb_32, cyan, 0, 255, 255) + DEFINE_COLOR(nrgb_32, pink, 255, 0, 255) + + } // end of nrgb_32_color. + +} // end of ntg. + +#endif // !NTG_COLOR_NRGB_HH Index: ntg/color/rgb.hh --- ntg/color/rgb.hh (revision 0) +++ ntg/color/rgb.hh (revision 0) @@ -0,0 +1,58 @@ +// Copyright (C) 2001, 2002, 2003 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_COLOR_RGB_HH +# define NTG_COLOR_RGB_HH + +# include <ntg/color/color.hh> + +namespace ntg +{ + + /*! + CIE RGB format. + */ + + enum rgb_comp + { + rgb_R = 0, + rgb_G = 1, + rgb_B = 2 + }; + + template<unsigned icomp> struct rgb_traits; + template<> struct rgb_traits<rgb_R> : public interval<0,1> {}; + template<> struct rgb_traits<rgb_G> : public interval<0,1> {}; + template<> struct rgb_traits<rgb_B> : public interval<0,1> {}; + + typedef color<3,8,rgb_traits> rgb_8; + typedef color<3,16,rgb_traits> rgb_16; + typedef color<3,32,rgb_traits> rgb_32; + +} // end of ntg. + +#endif // !NTG_COLOR_RGB_HH Index: ntg/color/xyz.hh --- ntg/color/xyz.hh (revision 0) +++ ntg/color/xyz.hh (revision 0) @@ -0,0 +1,54 @@ +// Copyright (C) 2001, 2002, 2003 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_COLOR_XYZ_HH +# define NTG_COLOR_XYZ_HH + +# include <ntg/color/color.hh> + +namespace ntg +{ + + enum xyz_comp + { + xyz_X = 0, + xyz_Y = 1, + xyz_Z = 2 + }; + + template<unsigned icomp> struct xyz_traits; + template<> struct xyz_traits<xyz_X> : public interval<0,1> {}; + template<> struct xyz_traits<xyz_Y> : public interval<0,1> {}; + template<> struct xyz_traits<xyz_Z> : public interval<0,1> {}; + + typedef color<3,8,xyz_traits> xyz_8; + typedef color<3,16,xyz_traits> xyz_16; + typedef color<3,32,xyz_traits> xyz_32; + +} // end of ntg. + +#endif // !NTG_COLOR_XYZ_HH Index: ntg/color/color.hh --- ntg/color/color.hh (revision 59) +++ ntg/color/color.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2005 EPITA Research and Development Laboratory +// 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 @@ -25,75 +25,298 @@ // reasons why the executable file might be covered by the GNU General // Public License. -#ifndef INTEGRE_COLOR_COLOR_HH -# define INTEGRE_COLOR_COLOR_HH +#ifndef NTG_COLOR_COLOR_HH +# define NTG_COLOR_COLOR_HH -# include <mlc/any.hh> -# include <mlc/types.hh> +/* + Header for generic color type, from which real color types are defined. +*/ -# include <ntg/core/cats.hh> -# include <ntg/core/props.hh> +# include <ntg/basics.hh> +# include <ntg/int.hh> +# include <ntg/vect/vec.hh> +# include <ntg/core/pred_succ.hh> +# include <mlc/cmp.hh> + +# include <iostream> +# include <sstream> +# include <string> + namespace ntg { - template <typename E> - struct color; + namespace internal { - template <typename E> - struct category_type< color<E> > { typedef cat::color ret; }; + /*------------------. + | typetraits<color> | + `------------------*/ + template <unsigned ncomps, + unsigned qbits, + template <unsigned> class color_system> + struct typetraits<color<ncomps, qbits, color_system> > + { + enum { nb_comp = ncomps }; - template <> - struct default_props < cat::color > - { - enum { max_val = 0 }; - enum { depth = 0 }; - typedef mlc::undefined_type comp_type; - typedef mlc::undefined_type io_type; + typedef color<ncomps, qbits, color_system> self; + typedef self ntg_type; + typedef vectorial abstract_type; + typedef int_u<qbits> comp_type; + typedef self base_type; + typedef vec<ncomps, int_u<qbits> > storage_type; + }; + /*-------------------------. + | Helper structs for float | + `-------------------------*/ - protected: - default_props() {} - }; + /*! + Helper struct to convert vec<N,T> to vec<N,float>, + taking color_system into account. + */ + template <unsigned n, + unsigned ncomps, + unsigned qbits, + template <unsigned> class color_system> + struct _to_float + { + typedef int_u<qbits> T; + typedef vec<ncomps, T> in_type; + typedef vec<ncomps, float> out_type; - template <typename E> - struct color : public mlc::any__best_memory<E> - { - typedef E exact_type; - typedef typename props<cat::color, E>::comp_type comp_type; + static void + doit (const in_type& in, out_type& out) + { + float in_range = float(ntg_max_val(T)) - float(ntg_min_val(T)); + float out_range = float(color_system<n>::upper_bound()) + - float(color_system<n>::lower_bound()); + out[n] = ((float(in[n]) - float(ntg_min_val(T))) + * out_range / in_range + + float(color_system<n>::lower_bound())); - E& operator=(const exact_type& rhs) + // process next componant recursively: + _to_float<n + 1, ncomps, qbits, color_system>::doit(in, out); + } + }; + + // Stop recursion when n == ncomps. + template <unsigned ncomps, + unsigned qbits, + template <unsigned> class color_system> + struct _to_float<ncomps, ncomps, qbits, color_system> { - return this->exact.impl_assign(rhs); - } + typedef vec<ncomps, int_u<qbits> > in_type; + typedef vec<ncomps, float> out_type; - template <typename I> - bool operator==(const color<I>& rhs) const + static void + doit (const in_type&, out_type&) + {} + }; + + /*! + Helper struct to convert vec<N,float> to vec<N,T>, + taking color_system into account. + */ + template <unsigned n, + unsigned ncomps, + unsigned qbits, + template <unsigned> class color_system> + struct _from_float { - return this->exact().impl_eq(rhs.exact()); - } + typedef int_u<qbits> T; + typedef vec<ncomps, float> in_type; + typedef vec<ncomps, T> out_type; - template <typename V> - bool operator!=(const V& rhs) const + static void + doit (const in_type& in, out_type& out) + { + float out_range = float(optraits<T>::max()) + - float(optraits<T>::min()); + float in_range = float(color_system<n>::upper_bound()) + - float(color_system<n>::lower_bound()); + + out[n] = cast::rbound<int_u<qbits> > + ((in[n] - float(color_system<n>::lower_bound())) + * out_range / in_range + + float(color_system<n>::lower_bound())); + + // process next componant recursively: + _from_float<n + 1, ncomps, qbits, color_system>::doit(in, out); + } + }; + + // stop recursion when n == ncomps. + template <unsigned ncomps, + unsigned qbits, + template <unsigned> class color_system> + struct _from_float<ncomps, ncomps, qbits, color_system> { - return ! this->operator==(rhs); + typedef vec<ncomps, float> in_type; + typedef vec<ncomps, int_u<qbits> > out_type; + + static void + doit (const in_type&, out_type&) + {} + }; + + } // end of internal. + + /*-----------------------------------. + | color<ncomps, qbits, color_system> | + `-----------------------------------*/ + + //! Generic type for color. + /*! + Specific color types (such as rgb, xyz, etc.) are defined by + specifying ncomps, qbits and a color_system trait. + + ncomps: number of components. + qbits: number of bits of each unsigned integer component. + color_system: traits defining the intervals of each component. + + Colors are implemented and seen as a vector of components. + */ + + + template <typename E> + struct color_value: public vect_value<E> + {}; + + namespace internal { + + template <class E> + struct typetraits<color_value<E> > : public typetraits<vect_value<E> > + {}; + + } + + template <unsigned ncomps, + unsigned qbits, + template <unsigned> class color_system> + struct color : public color_value<color<ncomps, qbits, color_system> > + { + typedef int_u<qbits> comp_type; + typedef vec<ncomps, comp_type> vec_type; + typedef vec<ncomps, float> float_vec_type; + + color() {}; + color(const vec_type& vec) { this->val_ = vec; }; + color(const float_vec_type& vec) + { + internal::_from_float<0,ncomps,qbits,color_system>::doit(vec,this->val_); } - comp_type& operator [](const unsigned int &i) + color(const comp_type& c1, const comp_type& c2, const comp_type& c3) { - return this->exact().impl_op_sqbr(i); + mlc::is_true<ncomps == 3>::ensure(); + this->val_[0] = c1; + this->val_[1] = c2; + this->val_[2] = c3; } - const comp_type operator [](const unsigned int &i) const + vec_type& as_vec() { return this->val_; } + const vec_type& as_vec() const { return this->val_; } + + float_vec_type + to_float() const { - return this->exact().impl_op_sqbr(i); + float_vec_type tmp; + internal::_to_float<0,ncomps,qbits,color_system>::doit(this->val_, tmp); + return tmp; } - protected: - color() {} + bool + operator==(const color& r) const + { return this->val_ == r.val_; } }; -} // end of namespace ntg + /*! + Helper function to complete color_system (by inheritance). + */ + template<int lval, int uval> + struct interval + { + static int lower_bound() { return lval; } + static int upper_bound() { return uval; } + }; + template <unsigned ncomps, + unsigned qbits, + template <unsigned> class color_system> + inline std::ostream& + operator<<(std::ostream& o, + const color<ncomps, qbits, color_system>& r) + { + o << r.as_vec(); + return o; + } -#endif // ! INTEGRE_COLOR_COLOR_HH + namespace internal + { + + /*----------------. + | optraits<color> | + `----------------*/ + + template <unsigned ncomps, + unsigned qbits, + template <unsigned> class color_system> + struct optraits<color<ncomps, qbits, color_system> > + { + private: + typedef color<ncomps, qbits, color_system> self; + typedef typename typetraits<self>::storage_type storage_type; + + public: + static unsigned max_print_width () + { + return ntg_max_print_width(storage_type); + } + + static std::string + name() + { + std::ostringstream out; + // FIXME: Output color_system somehow. + out << "color<" << ncomps << "," << qbits << ",...>" << std::ends; + return out.str(); + } + }; + + + template <typename T> struct default_less; + + /*! The specialized version of default_less for colors. + ** + ** \warning This class is only provided to build classes + ** that need a less class, it does not correspond to + ** the reality. \n + ** Example of a std::set of RGB colors: + ** \verbatim + ** std::set<ntg:rgb_8, + ** ntg::internal::default_less<ntg::rgb8> > s; + ** s.insert(ntg::rgb_8(10, 16, 64)); + ** \endverbatim + */ + template <unsigned ncomps, + unsigned qbits, + template <unsigned> class color_system> + struct default_less< ntg::color<ncomps, qbits, color_system> > + { + typedef ntg::color<ncomps, qbits, color_system> arg_type; + bool operator()(const arg_type& l, + const arg_type& r) const + { + for (unsigned i = 0; i < ntg_nb_comp(arg_type); ++i) + if (l[i] < r[i]) + return true; + else if (l[i] > r[i]) + return false; + return false; + } + }; + } // end of internal. + +} // end of ntg. + +#endif // !NTG_COLOR_COLOR_HH Index: ntg/color/hsv.hh --- ntg/color/hsv.hh (revision 0) +++ ntg/color/hsv.hh (revision 0) @@ -0,0 +1,55 @@ +// Copyright (C) 2001, 2002, 2003 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_COLOR_HSV_HH +# define NTG_COLOR_HSV_HH + +# include <ntg/color/color.hh> + +namespace ntg +{ + + enum hsv_comp + { + hsv_H = 0, + hsv_S = 1, + hsv_V = 2 + }; + + template<unsigned icomp> struct hsv_traits; + template<> struct hsv_traits<hsv_H> : public interval<0,360> {}; + template<> struct hsv_traits<hsv_S> : public interval<0,1> {}; + template<> struct hsv_traits<hsv_V> : public interval<0,1> {}; + + + typedef color<3,8,hsv_traits> hsv_8; + typedef color<3,16,hsv_traits> hsv_16; + typedef color<3,32,hsv_traits> hsv_32; + +} // end of ntg. + +#endif // !NTG_COLOR_HSV_HH

19 years, 1 month

proto-1.0 59: Undo previous change

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * mlc/properties.hh: Undo previous change. properties.hh | 2 +- 1 files changed, 1 insertion(+), 1 deletion(-) Index: mlc/properties.hh --- mlc/properties.hh (revision 58) +++ mlc/properties.hh (working copy) @@ -229,7 +229,7 @@ NAMESPACE::target::TARGET##_type>::ret # define mlc_type_of_(NAMESPACE, TYPE, TARGET) \ -NAMESPACE::get_type_of<NAMESPACE::internal::get_category<TYPE>::ret, \ +NAMESPACE::get_type_of<typename NAMESPACE::internal::get_category<TYPE>::ret, \ TYPE, \ NAMESPACE::target::TARGET##_type>::ret

19 years, 1 month

proto-1.0 58: Fix on mlc_type_of_

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * mlc/properties.hh (oln_type_of_): Remove a `typename'. properties.hh | 4 ++-- 1 files changed, 2 insertions(+), 2 deletions(-) Index: mlc/properties.hh --- mlc/properties.hh (revision 57) +++ mlc/properties.hh (working copy) @@ -49,7 +49,7 @@ template <class T1, class T2> struct my_eq { typedef mlc::false_type ret; }; template <class T> struct my_eq <T, T> { typedef mlc::true_type ret; }; - + } } @@ -229,7 +229,7 @@ NAMESPACE::target::TARGET##_type>::ret # define mlc_type_of_(NAMESPACE, TYPE, TARGET) \ -NAMESPACE::get_type_of<typename NAMESPACE::internal::get_category<TYPE>::ret, \ +NAMESPACE::get_type_of<NAMESPACE::internal::get_category<TYPE>::ret, \ TYPE, \ NAMESPACE::target::TARGET##_type>::ret

19 years, 1 month

proto-1.0 57: Add i/o test suite to configure.ac

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * configure.ac: Add i/o test suite. configure.ac | 1 + 1 files changed, 1 insertion(+) Index: configure.ac --- configure.ac (revision 53) +++ configure.ac (working copy) @@ -103,6 +103,7 @@ # OLN_TESTS defined in oln-local.m4 OLN_TESTS([core]) OLN_TESTS([sanity]) + OLN_TESTS([io]) AC_SUBST([OLN_TESTS_SUBDIRS])

19 years, 1 month

proto-1.0 56: Fix operator== on data types

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * ntg/real/int_u8.hh: Fix operator==. * ntg/real/integer.hh: Likewise. * ntg/enum/enum.hh: Likewise. * ntg/enum/bin.hh: Likewise. * ntg/all.hh: New. * ntg/core/macros.hh: Fix operator==. * ntg/color/rgb_8.hh: Likewise. * ntg/color/color.hh: Likewise. all.hh | 36 ++++++++++++++++++++++++++++++++++ color/color.hh | 12 ++++++----- color/rgb_8.hh | 58 +++++++++----------------------------------------------- core/macros.hh | 2 - enum/bin.hh | 10 ++++----- enum/enum.hh | 20 ++++++++++++------- real/int_u8.hh | 14 ++++++++----- real/integer.hh | 11 +++++++--- 8 files changed, 89 insertions(+), 74 deletions(-) Index: ntg/real/int_u8.hh --- ntg/real/int_u8.hh (revision 53) +++ ntg/real/int_u8.hh (working copy) @@ -83,16 +83,20 @@ return value_; } - template <typename V> - bool impl_eq(const V& rhs) const +// template <typename V> +// bool impl_eq(const V& rhs) const +// { +// return this->value_ == rhs; +// } + + bool impl_eq(int rhs) const { return this->value_ == rhs; } - template <typename V> - bool impl_not_eq(const V& rhs) const + bool impl_eq(const int_u8& rhs) const { - return this->value_ != rhs; + return this->value_ == (unsigned char)rhs; } template <typename V> Index: ntg/real/integer.hh --- ntg/real/integer.hh (revision 53) +++ ntg/real/integer.hh (working copy) @@ -62,16 +62,21 @@ return this->exact().impl_assign(rhs); } - template <typename V> - bool operator==(const V& rhs) const + bool operator==(int rhs) const { return this->exact().impl_eq(rhs); } + template <typename I> + bool operator==(const integer<I>& rhs) const + { + return this->exact().impl_eq(rhs.exact()); + } + template <typename V> bool operator!=(const V& rhs) const { - return this->exact().impl_not_eq(rhs); + return ! this->operator==(rhs); } template <typename V> Index: ntg/enum/enum.hh --- ntg/enum/enum.hh (revision 53) +++ ntg/enum/enum.hh (working copy) @@ -44,6 +44,7 @@ struct default_props < cat::enum_value > { enum { max_val = 0 }; + enum { depth = 1 }; typedef mlc::no_type io_type; protected: @@ -55,25 +56,30 @@ { typedef E exact_type; - template <typename V> - exact_type& operator=(const V& rhs) + bool operator==(int rhs) const { - return this->exact().impl_assign(rhs); + return this->exact().impl_eq(rhs); } - template <typename V> - bool operator==(const V& rhs) const + template <typename I> + bool operator==(const enum_value<I>& rhs) const { - return this->exact().impl_eq(rhs); + return this->exact().impl_eq(rhs.exact()); } template <typename V> bool operator!=(const V& rhs) const { - return this->exact().impl_not_eq(rhs); + return ! this->operator==(rhs); } template <typename V> + exact_type& operator=(const V& rhs) + { + return this->exact().impl_assign(rhs); + } + + template <typename V> exact_type& operator+(const V& rhs) const { return this->exact().impl_add(rhs); Index: ntg/enum/bin.hh --- ntg/enum/bin.hh (revision 53) +++ ntg/enum/bin.hh (working copy) @@ -69,7 +69,7 @@ template <typename V> bin& impl_assign(const V& rhs) { - this->value_ = rhs % 2; + this->value_ = (int)rhs % 2; return *this; } @@ -78,18 +78,18 @@ return value_; } - template <typename V> - bool impl_eq(const V& rhs) const + bool impl_eq(const unsigned char& rhs) const { return this->value_ == rhs; } template <typename V> - bool impl_not_eq(const V& rhs) const + bool impl_eq(const V& rhs) const { - return this->value_ != rhs; + return this->value_ == (unsigned char)rhs; } + template <typename V> bin impl_add(const V& rhs) const { Index: ntg/all.hh --- ntg/all.hh (revision 0) +++ ntg/all.hh (revision 0) @@ -0,0 +1,36 @@ +// 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_ALL_HH +# define NTG_ALL_HH + +# include <ntg/core/macros.hh> +# include <ntg/color/rgb_8.hh> +# include <ntg/real/int_u8.hh> +# include <ntg/enum/bin.hh> + +#endif // ! NTG_ALL_HH Index: ntg/core/macros.hh --- ntg/core/macros.hh (revision 53) +++ ntg/core/macros.hh (working copy) @@ -30,7 +30,7 @@ # define ntg_max_val(T) ntg::props<ntg_category_type(T),T>::max_val -# define ntg_nb_comp(T) ntg::props<ntg_category_type(T),T>::nb_comp +# define ntg_depth(T) ntg::props<ntg_category_type(T),T>::depth # define ntg_comp_type(T) typename ntg::props<ntg_category_type(T),T>::comp_type Index: ntg/color/rgb_8.hh --- ntg/color/rgb_8.hh (revision 53) +++ ntg/color/rgb_8.hh (working copy) @@ -45,7 +45,7 @@ struct props<cat::color, rgb_8> : default_props<cat::color> { enum { max_val = 255 }; - enum { nb_comp = 3 }; + enum { depth = 3 }; typedef char io_type; typedef unsigned char comp_type; @@ -84,33 +84,26 @@ rgb_8(const rgb_8& rhs) { - this->value_[rgb_red] = rhs.red(); - this->value_[rgb_green] = rhs.green(); - this->value_[rgb_blue] = rhs.blue(); + this->value_[rgb_red] = rhs[rgb_red]; + this->value_[rgb_green] = rhs[rgb_green]; + this->value_[rgb_blue] = rhs[rgb_blue]; } rgb_8& impl_assign(const rgb_8& rhs) { - this->value_[rgb_red] = rhs.red(); - this->value_[rgb_green] = rhs.green(); - this->value_[rgb_blue] = rhs.blue(); + this->value_[rgb_red] = rhs[rgb_red]; + this->value_[rgb_green] = rhs[rgb_green]; + this->value_[rgb_blue] = rhs[rgb_blue]; return *this; } bool impl_eq(const rgb_8& rhs) const { - return this->value_[rgb_red] == rhs.red() && - this->value_[rgb_green] == rhs.green() && - this->value_[rgb_blue] == rhs.blue(); + return this->value_[rgb_red] == rhs[rgb_red] && + this->value_[rgb_green] == rhs[rgb_green] && + this->value_[rgb_blue] == rhs[rgb_blue]; } - bool impl_not_eq(const rgb_8& rhs) const - { - return this->value_[rgb_red] != rhs.red() || - this->value_[rgb_green] != rhs.green() || - this->value_[rgb_blue] != rhs.blue(); - } - unsigned char& impl_op_sqbr(unsigned int i) { assert(i < 3); @@ -123,37 +116,6 @@ return value_[i]; } - - unsigned char& red() - { - return value_[rgb_red]; - } - - const unsigned char red() const - { - return value_[rgb_red]; - } - - unsigned char& green() - { - return value_[rgb_green]; - } - - const unsigned char green() const - { - return value_[rgb_green]; - } - - unsigned char& blue() - { - return value_[rgb_blue]; - } - - const unsigned char blue() const - { - return value_[rgb_blue]; - } - private: unsigned char value_[3]; Index: ntg/color/color.hh --- ntg/color/color.hh (revision 53) +++ ntg/color/color.hh (working copy) @@ -47,7 +47,7 @@ struct default_props < cat::color > { enum { max_val = 0 }; - enum { nb_comp = 0 }; + enum { depth = 0 }; typedef mlc::undefined_type comp_type; typedef mlc::undefined_type io_type; @@ -67,14 +67,16 @@ return this->exact.impl_assign(rhs); } - bool operator==(const exact_type& rhs) const + template <typename I> + bool operator==(const color<I>& rhs) const { - return this->exact().impl_eq(rhs); + return this->exact().impl_eq(rhs.exact()); } - bool operator!=(const exact_type& rhs) const + template <typename V> + bool operator!=(const V& rhs) const { - return this->exact().impl_not_eq(rhs); + return ! this->operator==(rhs); } comp_type& operator [](const unsigned int &i)

19 years, 1 month

proto-1.0 55: Add all.hh header

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * oln/makefile.src: Add new file. * oln/all.hh: New. all.hh | 38 ++++++++++++++++++++++++++++++++++++++ makefile.src | 1 + 2 files changed, 39 insertions(+) Index: oln/makefile.src --- oln/makefile.src (revision 54) +++ oln/makefile.src (working copy) @@ -4,6 +4,7 @@ ## OLN_DEP = \ + all.hh \ basics.hh \ basics1d.hh \ basics2d.hh \ Index: oln/all.hh --- oln/all.hh (revision 0) +++ oln/all.hh (revision 0) @@ -0,0 +1,38 @@ +// 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 OLN_ALL_HH +# define OLN_ALL_HH + +# include <oln/core/1d/image1d.hh> +# include <oln/core/2d/image2d.hh> +# include <oln/core/3d/image3d.hh> + +# include <oln/io/write_image.hh> +# include <oln/io/read_image.hh> + +#endif // ! OLN_ALL_HH

19 years, 1 month

proto-1.0 54: Add gzip i/o

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * tests/io: New. * tests/io/tests: New. * tests/io/tests/2d: New. * tests/io/Makefile.am: New. * tests/io/loadsave.hh: New. * oln/makefile.src: Add new files. * oln/io/write_image_2d_pnm.hh: Modify function prototypes. * oln/io/gz_stream.hh: New. Gz stream classes. * oln/io/read_image_2d_pnm.hh: Modify function prototypes. * oln/io/write_image.hh: Add gz stream support. * oln/io/read_image.hh: Likewise. * oln/io/utils.hh: Modify function prototypes. * oln/core/value_box.hh: Add new operator== for value_box. * oln/core/2d/image2d.hh: Remove debug output. * img/lena.pgm.gz: New. * img/lena.pgm: New. * img/chien.pbm.gz: New. * img/chien.pbm: New. * img/lena.ppm.gz: New. * img/lena.ppm: New. * img/lena.pbm.gz: New. * img/lena.pbm: New. img/lena.pbm | 0 img/lena.pgm | 4 img/lena.ppm | 541 +++++++++++++++++++++++++++++++++++++++++++ oln/core/2d/image2d.hh | 1 oln/core/value_box.hh | 64 ++++- oln/io/gz_stream.hh | 482 ++++++++++++++++++++++++++++++++++++++ oln/io/read_image.hh | 102 +++++++- oln/io/read_image_2d_pnm.hh | 134 ++-------- oln/io/utils.hh | 34 -- oln/io/write_image.hh | 65 ++++- oln/io/write_image_2d_pnm.hh | 39 +-- oln/makefile.src | 1 tests/io/Makefile.am | 9 tests/io/loadsave.hh | 49 +++ tests/io/tests/2d | 52 ++++ 15 files changed, 1399 insertions(+), 178 deletions(-) Index: tests/io/tests/2d --- tests/io/tests/2d (revision 0) +++ tests/io/tests/2d (revision 0) @@ -0,0 +1,52 @@ +// -*- c++ -*- +// 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. + + +#include "loadsave.hh" + +bool +check(void) +{ + bool fail = false; + + typedef oln::image2d<ntg::int_u8> ima_int_u8; + typedef oln::image2d<ntg::rgb_8> ima_rgb_8; + typedef oln::image2d<ntg::bin> ima_bin; + + fail |= loadsave< ima_int_u8 >(rdata("lena.pgm"), "lena.pgm"); + fail |= loadsave< ima_bin >(rdata("lena.pbm"), "lena.pbm"); + fail |= loadsave< ima_rgb_8 >(rdata("lena.ppm"), "lena.ppm"); + +#if HAVE_ZLIB + fail |= loadsave< ima_bin >(rdata("lena.pbm.gz"), "lena.pbm.gz"); + fail |= loadsave< ima_int_u8 >(rdata("lena.pgm.gz"), "lena.pgm.gz"); + fail |= loadsave< ima_rgb_8 >(rdata("lena.ppm.gz"), "lena.ppm.gz"); +#endif + + return fail; +} Index: tests/io/Makefile.am --- tests/io/Makefile.am (revision 0) +++ tests/io/Makefile.am (revision 0) @@ -0,0 +1,9 @@ +## Process this file through Automake to create Makefile.in -*- Makefile -*- + +include ../check/Makefile.runtests + +noinst_HEADERS = loadsave.hh + +CLEANFILES += \ + lena.ppm lena.pgm lena.pbm \ + lena.ppm.gz lena.pgm.gz lena.pbm.gz Index: tests/io/loadsave.hh --- tests/io/loadsave.hh (revision 0) +++ tests/io/loadsave.hh (revision 0) @@ -0,0 +1,49 @@ +#include <oln/basics1d.hh> +#include <oln/basics2d.hh> +#include <oln/basics3d.hh> +#include <oln/all.hh> + +#include <ntg/all.hh> + +#include "check.hh" +#include "data.hh" + +template<typename E> +bool compare(const oln::abstract::image<E>& a, + const oln::abstract::image<E>& b) +{ + + oln_type_of(E, fwd_piter) it(a.size()); + + if (a.size().nrows() != b.size().nrows() || + a.size().ncols() != b.size().ncols()) + return false; + + for (it.start(); !it.is_valid(); it.next()) + if (a[it] != b[it]) + return false; + + return true; +} + +template< typename T > +bool +loadsave(const std::string& name, const std::string& savename) +{ + bool fail = false; + + T im1, im2; + im1 = oln::io::read(name); + oln::io::write(im1, savename); + + im2 = oln::io::read(savename); + + if (compare(im1, im2)) + std::cout << "OK" << std::endl; + else + { + std::cout << "FAILED" << std::endl; + fail = true; + } + return fail; +} Index: oln/makefile.src --- oln/makefile.src (revision 53) +++ oln/makefile.src (working copy) @@ -40,6 +40,7 @@ core/value_box.hh \ fancy/iota.hh \ fancy/print.hh \ + io/gz_stream.hh \ io/read_image.hh \ io/read_image_2d_pnm.hh \ io/utils.hh \ Index: oln/io/write_image_2d_pnm.hh --- oln/io/write_image_2d_pnm.hh (revision 53) +++ oln/io/write_image_2d_pnm.hh (working copy) @@ -59,9 +59,9 @@ typedef ntg_io_type(value_type) io_type; const I& to_write_; - std::ofstream& ostr_; + std::ostream& ostr_; - write_image_2d_raw(const I& to_write, std::ofstream& ostr): + write_image_2d_raw(const I& to_write, std::ostream& ostr): to_write_(to_write), ostr_(ostr) {} @@ -70,7 +70,7 @@ { point2d p; value_type c; - bool b; + bool b = false; for (p.row() = 0; p.row() < to_write_.size().nrows(); ++p.row()) for (p.col() = 0; p.col() < to_write_.size().ncols(); ++p.col()) @@ -80,21 +80,25 @@ } while (b == false) b = write_value_type(c); - ostr_.close(); } bool write_value_type(const ntg::integer<value_type> &c) { - ostr_ << (io_type)(c.exact()); + io_type v = c.exact(); + ostr_.write((char *)&v, sizeof(io_type)); return true; } bool write_value_type(const ntg::color<value_type> &c) { - assert ((ntg_nb_comp(value_type) == 3)); + assert ((ntg_depth(value_type) == 3)); + io_type v; for (unsigned i = 0; i < 3; i++) - ostr_ << (io_type)(c[i]); + { + v = c[i]; + ostr_.write((char *)(&v), sizeof(io_type)); + } return true; } @@ -107,7 +111,7 @@ if (offset == -1) { - ostr_ << v; + ostr_.write((char *)&v, 1); offset = 7; v = 0; ret = true; @@ -123,15 +127,15 @@ template <typename I, typename T> void write(const abstract::image2d<I>& to_write, const ntg::integer<T>&, - const std::string& name, + std::ostream& ostr, const std::string& ext) { - std::ofstream ostr; + point2d p; size2d s = to_write.size(); if (ext == "pgm") - if (internal::write_pnm_header(ostr, name, "P5", + if (internal::write_pnm_header(ostr, "P5", s.ncols(), s.nrows(), ntg_max_val(T))) { @@ -139,7 +143,7 @@ tmp.run(); } else - std::cerr << "error: unable to write header" << std::endl; + std::cerr << "error: unable to write file header" << std::endl; else std::cerr << "error: image data type (`integer') does not match" << " file extension (`" << ext << "')" << std::endl; @@ -148,15 +152,15 @@ template <typename I, typename T> void write(const abstract::image2d<I>& to_write, const ntg::color<T>&, - const std::string& name, + std::ostream& ostr, const std::string& ext) { - std::ofstream ostr; + point2d p; size2d s = to_write.size(); if (ext == "ppm") - if (internal::write_pnm_header(ostr, name, "P6", + if (internal::write_pnm_header(ostr, "P6", s.ncols(), s.nrows(), ntg_max_val(T))) { @@ -173,15 +177,14 @@ template <typename I, typename T> void write(const abstract::image2d<I>& to_write, const ntg::enum_value<T>&, - const std::string& name, + std::ostream& ostr, const std::string& ext) { - std::ofstream ostr; point2d p; size2d s = to_write.size(); if (ext == "pbm") - if (internal::write_pnm_header(ostr, name, "P4", + if (internal::write_pnm_header(ostr, "P4", s.ncols(), s.nrows(), ntg_max_val(T))) { Index: oln/io/gz_stream.hh --- oln/io/gz_stream.hh (revision 0) +++ oln/io/gz_stream.hh (revision 0) @@ -0,0 +1,482 @@ +// 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 OLN_IO_GZ_STREAM_HH +# define OLN_IO_GZ_STREAM_HH + +# include <oln/config/system.hh> + +#if defined HAVE_ZLIB && HAVE_ZLIB == 1 +# include <cassert> +# include <fstream> +# include <string> +# include <zlib.h> + +namespace oln { + + namespace io { + + /// Functions for gz files + namespace gz { + + + ///Performs operation on compressed files. + class zfilebuf : public std::streambuf + { + public: + + + zfilebuf() : file(0), mode(0), own_file_descriptor(0) + { + inbuf = new char[lenbuf]; + outbuf = new char[lenbuf]; + setg(0, 0, 0); + setp(outbuf, outbuf + lenbuf); + } + + virtual ~zfilebuf() + { + sync(); + delete[] inbuf; + delete[] outbuf; + if (own_file_descriptor) + close(); + } + + + /*! \brief Return a stream on the file \a name regarding + ** the opening mode: \a io_mode. + */ + zfilebuf* + open(const char *name, int io_mode) + { + if (is_open()) + return 0; + + char char_mode[10]; + char *p; + memset(char_mode,'\0',10); + p = char_mode; + + if (io_mode & std::ios::in) + { + mode = std::ios::in; + *p++ = 'r'; + } + else + if (io_mode & std::ios::app) + { + mode = std::ios::app; + *p++ = 'a'; + } + else + { + mode = std::ios::out; + *p++ = 'w'; + } + if (io_mode & std::ios::binary) + { + mode |= std::ios::binary; + *p++ = 'b'; + } + + // Hard code the compression level + if (io_mode & (std::ios::out|std::ios::app)) + *p++ = '9'; + + if ((file = gzopen(name, char_mode)) == 0) + return 0; + + name_ = name; + own_file_descriptor = 1; + return this; + } + + /*! \brief Attach a stream on \a file_descriptor regarding + ** the opening mode: \a io_mode. + */ + zfilebuf* + attach(int file_descriptor, int io_mode) + { + if (is_open()) + return 0; + + char char_mode[10]; + char *p; + memset(char_mode,'\0',10); + p = char_mode; + + if (io_mode & std::ios::in) + { + mode = std::ios::in; + *p++ = 'r'; + } + else + if (io_mode & std::ios::app) + { + mode = std::ios::app; + *p++ = 'a'; + } + else + { + mode = std::ios::out; + *p++ = 'w'; + } + + if (io_mode & std::ios::binary) + { + mode |= std::ios::binary; + *p++ = 'b'; + } + + // Hard code the compression level + if (io_mode & (std::ios::out|std::ios::app)) + *p++ = '9'; + + if ((file = gzdopen(file_descriptor, char_mode)) == 0) + return 0; + + own_file_descriptor = 0; + return this; + } + + /// Close the stream. + zfilebuf* + close() + { + if (is_open()) + { + sync(); + gzclose(file); + file = 0; + } + return this; + } + + + int + setcompressionlevel(short comp_level) + { + return gzsetparams(file, comp_level, -2); + } + + int + setcompressionstrategy(short comp_strategy) + { + return gzsetparams(file, -2, comp_strategy); + } + + /// Return true if the stream is open, false otherwise. + inline int + is_open() const + { return (file != 0); } + + virtual std::streampos + seekoff(std::streamoff off, std::ios::seekdir dir, int) // which) + { + return std::streampos(gzseek(file, off, dir)); + } + + /// Flush the buffer associated to the stream. + virtual int + sync() + { + if (!is_open()) + return EOF; + return flushbuf(); + } + + protected: + + /*! \brief Return the next character in the stream. + ** On failure, \a EOF is returned. + */ + virtual int + underflow() + { + // If the file hasn't been opened for reading, error. + if (!is_open() || !(mode & std::ios::in)) + return EOF; + + if (in_avail()) + return (unsigned char) *gptr(); + + if (flushbuf() == EOF) + return EOF; + + // Attempt to fill the buffer. + if (fillbuf() == EOF) + return EOF; + + assert (eback()); + + return (unsigned char) *gptr(); + } + + /*! \brief Flush the output buffer associated to the stream + ** then write \a c. On failure, \a EOF is returned. + */ + + virtual int + overflow(int c = EOF) + { + if (!is_open() || !(mode & std::ios::out)) + return EOF; + + assert (pbase()); + + if (flushbuf() == EOF) + return EOF; + + if (c != EOF) + { + *pptr() = c; + pbump(1); + } + return 0; + } + + private: + + gzFile file; + short mode; + short own_file_descriptor; + std::string name_; + char *inbuf; + char *outbuf; + static const int lenbuf = 16 * 1024; + + /// Flush the output buffer + int + flushbuf() + { + int n = pptr() - outbuf; + + if (n == 0) + return 0; + + if (gzwrite(file, outbuf, n) < n) + return EOF; + + setp(outbuf, outbuf + lenbuf); + return 0; + } + /// Fill the input buffer. + int + fillbuf() + { + int t = gzread(file, inbuf, lenbuf); + if (t <= 0) return EOF; + setg(inbuf, inbuf, inbuf + t); + return t; + } + + }; + + ///Define an interface for compressed file stream manipulation. + class zfilestream_common : virtual public std::ios + { + friend class zifstream; + friend class zofstream; + friend zofstream &setcompressionlevel(zofstream &, int); + friend zofstream &setcompressionstrategy(zofstream &, int); + + public: + virtual ~zfilestream_common() {} + + /*! \brief Open the stream on the file descriptor: + ** \a fd regarding the opening mode. + */ + void + attach(int fd, int io_mode) + { + if (!buffer.attach(fd, io_mode)) + clear(std::ios::failbit | std::ios::badbit); + else + clear(); + } + + /*! \brief Open the stream on the file named \a name + ** regarding the opening mode. + */ + void + open(const char *name, int io_mode) + { + if (!buffer.open(name, io_mode)) + clear(std::ios::failbit | std::ios::badbit); + else + clear(); + } + + /// Close the current stream. + void + close() + { + if (!buffer.close()) + clear(std::ios::failbit | std::ios::badbit); + } + + bool + is_open() + { + return buffer.is_open(); + } + + + protected: + /// Prevent instantiation. + zfilestream_common() : std::ios(zfilestream_common::rdbuf()) + { } + + + private: + zfilebuf* + rdbuf() + { + return &buffer; + } + + zfilebuf buffer; + }; + + + /// Read only zstream. + class zifstream : public zfilestream_common, public std::istream + { + public: + + zifstream() : std::istream(zfilestream_common::rdbuf()) + { + clear(std::ios::badbit); + } + + /// Open a read only stream on the file named \a name. + zifstream(const char *name, int io_mode = std::ios::in) : + std::istream(zfilestream_common::rdbuf()) + { + zfilestream_common::open(name, io_mode); + } + + /// Open a read only stream on the file descriptor \a fd. + zifstream(int fd, int io_mode = std::ios::in) : + std::istream(zfilestream_common::rdbuf()) + { + zfilestream_common::attach(fd, io_mode); + } + + virtual ~zifstream() {} + }; + + class zofstream : public zfilestream_common, public std::ostream { + + public: + + zofstream() : std::ostream(zfilestream_common::rdbuf()) + { + clear(std::ios::badbit); + } + + /// Open a write only stream on the file named \a name. + zofstream(const char *name, int io_mode = std::ios::out) : + std::ostream(zfilestream_common::rdbuf()) + { + zfilestream_common::open(name, io_mode); + } + + /// Open a write only stream on the file descriptor \a fd. + zofstream(int fd, int io_mode = std::ios::out) : + std::ostream(zfilestream_common::rdbuf()) + { + zfilestream_common::attach(fd, io_mode); + } + + virtual ~zofstream() {} + + }; + + // Forward declaration. + template <class T> + class zomanip; + + /// Apply a function on \a s via the operator <<. + template <class T> + zofstream& + operator<<(zofstream &s, const zomanip<T> &m) { + return (*m.func)(s, m.val); + } + + + /// Define a pair func / val to perform manipulation on zofstream. + template<class T> class zomanip + { + friend zofstream &operator<< <T>(zofstream &, const zomanip<T> &); + public: + zomanip(zofstream &(*f)(zofstream &, T), T v) : func(f), val(v) { } + private: + zofstream &(*func)(zofstream &, T); + T val; + }; + + + /// Set the compression level of \a s to \a l. + inline zofstream& + setcompressionlevel(zofstream &s, int l) { + (s.rdbuf())->setcompressionlevel(l); + return s; + } + + /// Set the compression strategy of \a s to \a l. + inline zofstream& + setcompressionstrategy(zofstream &s, int l) + { + (s.rdbuf())->setcompressionstrategy(l); + return s; + } + + /// Specialized version for zomanip<int> + inline zomanip<int> + setcompressionlevel(int l) + { + return zomanip<int>(&setcompressionlevel,l); + } + + /// Specialized version for zomanip<int> + inline zomanip<int> + setcompressionstrategy(int l) + { + return zomanip<int>(&setcompressionstrategy,l); + } + + } // end of namespace gz + + } // end of namespace io + +} // end of namespace oln + +# endif // ! HAVE_ZLIB + +#endif // ! OLN_IO_GZ_STREAM_HH Index: oln/io/read_image_2d_pnm.hh --- oln/io/read_image_2d_pnm.hh (revision 53) +++ oln/io/read_image_2d_pnm.hh (working copy) @@ -1,3 +1,30 @@ +// 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 OLN_IO_READ_IMAGE_2D_PNM_HH # define OLN_IO_READ_IMAGE_2D_PNM_HH @@ -59,11 +86,11 @@ typedef ntg_io_type(value_type) io_type; mlc::box<I> image_; - std::ifstream& istr_; + std::istream& istr_; internal::pnm_info& info_; read_image_2d_raw(I& image, - std::ifstream &istr, + std::istream &istr, internal::pnm_info &info) : super_type(image), image_(image), @@ -97,7 +124,6 @@ read_value_type(c); tmp[p] = c; } - istr_.close(); *image_ = tmp; } @@ -110,10 +136,9 @@ void read_value_type(ntg::color<value_type> &c) { - assert((ntg_nb_comp(value_type) == 3)); io_type v; - for (unsigned i = 0; i < 3; i++) + for (unsigned i = 0; i < ntg_depth(value_type); i++) { istr_.read(&v, sizeof (v)); c[i] = v; @@ -135,107 +160,20 @@ else c = 1; } - - }; - template <typename I, typename T> + template <typename I> void read(abstract::image2d<I>& ima, - const ntg::integer<T>&, - const std::string& filename, - const std::string& ext) + std::istream& istr, + internal::pnm_info info) { - std::ifstream istr; - internal::pnm_info info; - - if (internal::read_pnm_header(istr, info, filename)) - if (ext == "pgm") - if (info.type == "P5") - { - read_image_2d_raw<I> tmp(ima.exact(), istr, info); - tmp.run(); - tmp.output(ima.exact()); - } - else if (info.type == "P2") - std::cerr << "error: read_image_2d_pgm_ascii not implemented" - << std::endl; - else - std::cerr << "error: file header (`" << info.type - << "') does not match file extension (`" - << ext << "')" << std::endl; - else - std::cerr << "error: image data type (`integer') does not match" - << " file extension (`" << ext << "')" << std::endl; - else - std::cerr << "error: unable to get a valid header" << std::endl; + read_image_2d_raw<I> tmp(ima.exact(), istr, info); + tmp.run(); + tmp.output(ima.exact()); } - - - template <typename I, typename T> - void read(abstract::image2d<I>& ima, - const ntg::color<T>&, - const std::string& filename, - const std::string& ext) - { - std::ifstream istr; - internal::pnm_info info; - - if (internal::read_pnm_header(istr, info, filename)) - if (ext == "ppm") - if (info.type == "P6") - { - read_image_2d_raw<I> tmp(ima.exact(), istr, info); - tmp.run(); - tmp.output(ima.exact()); - } - else if (info.type == "P3") - std::cerr << "error: read_image_2d_ppm_ascii not implemented" - << std::endl; - else - std::cerr << "error: file header (`" << info.type - << "') does not match file extension (`" - << ext << "')" << std::endl; - else - std::cerr << "error: image data type (`color') does not match" - << " file extension (`" << ext << "')" << std::endl; - else - std::cerr << "error: unable to get a valid header" << std::endl; - } - - template <typename I, typename T> - void read(abstract::image2d<I>& ima, - const ntg::enum_value<T>&, - const std::string& filename, - const std::string& ext) - { - std::ifstream istr; - internal::pnm_info info; - - if (internal::read_pnm_header(istr, info, filename)) - if (ext == "pbm") - if (info.type == "P4") - { - read_image_2d_raw<I> tmp(ima.exact(), istr, info); - tmp.run(); - tmp.output(ima.exact()); - } - else if (info.type == "P1") - std::cerr << "error: read_image_2d_ppm_ascii not implemented" - << std::endl; - else - std::cerr << "error: file header (`" << info.type - << "') does not match file extension (`" - << ext << "')" << std::endl; - else - std::cerr << "error: image data type (`enum_value') does not match" - << " file extension (`" << ext << "')" << std::endl; - else - std::cerr << "error: unable to get a valid header" << std::endl; - } - } } Index: oln/io/write_image.hh --- oln/io/write_image.hh (revision 53) +++ oln/io/write_image.hh (working copy) @@ -30,6 +30,7 @@ # include <string> +# include <oln/io/gz_stream.hh> # include <oln/io/utils.hh> # include <oln/io/write_image_2d_pnm.hh> @@ -38,22 +39,68 @@ namespace io { template <typename I> - void write(const abstract::image<I>& im, const std::string& name) + void do_write(const abstract::image<I>& ima, + std::ostream& ostr, + const std::string& ext) { + typedef oln_type_of(I, value) value_type; + value_type t; + + impl::write(ima.exact(), t, ostr, ext); + } + +#if defined HAVE_ZLIB && HAVE_ZLIB == 1 + template <typename I> + void write_gz(const abstract::image<I>& ima, const std::string& name) + { + gz::zofstream zostr(name.c_str(), std::ios::out); + + if (zostr.is_open() == false) + std::cerr << "error: couldn't open " << name << std::endl; + else + { + std::string ext; + + ext = internal::utils::extension(name.substr(0, name.size() - 3)); + do_write(ima, zostr, ext); + } + zostr.close(); + } + +#endif // ! HAVE_ZLIB + + template <typename I> + void write_non_gz(const abstract::image<I>& ima, + const std::string& name, + const std::string& ext) + { + std::ofstream ostr; + + ostr.open(name.c_str(), std::ifstream::out); + + if (ostr.is_open() == false) + std::cerr << "error: couldn't open " << name << std::endl; + else + do_write(ima, ostr, ext); + ostr.close(); + } + + template <typename I> + void write(const abstract::image<I>& ima, const std::string& name) + { std::string ext; oln_type_of(I, value) t; ext = internal::utils::extension(name); - if (ext == "pgm" || - ext == "ppm" || - ext == "pbm") - impl::write(im.exact(), t, name, ext); +#if defined HAVE_ZLIB && HAVE_ZLIB == 1 + if (ext == "gz") + write_gz(ima, name); else - std::cerr << "error: output method for '" - << name.c_str() - << "' not implemented" - << std::endl; + write_non_gz(ima, name, ext); +# else + write_non_gz(ima, name, ext); +#endif // ! HAVE_ZLIB } } Index: oln/io/read_image.hh --- oln/io/read_image.hh (revision 53) +++ oln/io/read_image.hh (working copy) @@ -33,8 +33,12 @@ # include <mlc/box.hh> +# include <ntg/core/macros.hh> + +# include <oln/core/properties.hh> # include <oln/io/read_image_2d_pnm.hh> # include <oln/io/utils.hh> +# include <oln/io/gz_stream.hh> namespace oln { @@ -59,28 +63,102 @@ return tmp; } + template <typename I> - void do_read(abstract::image<I>& ima, const filename& name) + void read_dispatch_ext(abstract::image<I>& ima, + std::istream& istr, + const std::string& ext) + { - std::string ext; - const oln_type_of(I, value) t; + if (ext == "pgm" || ext == "pbm" || ext == "ppm" || + ext == "pnm") + { + internal::pnm_info info; - ext = internal::utils::extension(name.get()); + if (internal::read_pnm_header(istr, info)) + if ((ext == "ppm" || ext == "pnm") && info.type == "P6") + impl::read(ima.exact(), istr, info); + else if ((ext == "ppm" || ext == "pnm") && info.type == "P3") + std::cerr << "error: read_image_2d_ppm_ascii not implemented" + << std::endl; + else if ((ext == "pbm" || ext == "pnm") && info.type == "P4") + impl::read(ima.exact(), istr, info); + else if ((ext == "pbm" || ext == "pnm") && info.type == "P1") + std::cerr << "error: read_image_2d_ppm_ascii not implemented" + << std::endl; + else if ((ext == "pgm" || ext == "pnm") && info.type == "P5") + impl::read(ima.exact(), istr, info); + else if ((ext == "pgm" || ext == "pnm") && info.type == "P2") + std::cerr << "error: read_image_2d_ppm_ascii not implemented" + << std::endl; + else + std::cerr << "error: file header (`" << info.type + << "') does not match file extension (`" + << ext << "')" << std::endl; + else + std::cerr << "error: unable to get a valid header" << std::endl; + } + else + std::cout << "no input method for '" + << ext << "' file extension" + << std::endl; + } - if (ext == "pgm" || - ext == "pbm" || - ext == "ppm") - impl::read(ima.exact(), t, name.get(), ext); +#if defined HAVE_ZLIB && HAVE_ZLIB == 1 + template <typename I> + void do_read_gz(abstract::image<I>& ima, const std::string& name) + { + gz::zifstream zistr(name.c_str(), std::ios::in); + + if (zistr.is_open() == false) + std::cerr << "error: couldn't open " << name << std::endl; else { - std::cout << "input method for '" - << name.get() - << "' not implemented" - << std::endl; + std::string ext; + + ext = internal::utils::extension(name.substr(0, name.size() - 3)); + read_dispatch_ext(ima, zistr, ext); } + zistr.close(); + } +#endif // ! HAVE_ZLIB + + template <typename I> + void do_read_non_gz(abstract::image<I>& ima, + const std::string& name, + const std::string& ext) + { + std::ifstream istr; + + istr.open(name.c_str(), std::ifstream::in); + + if (istr.is_open() == false) + std::cerr << "error: couldn't open " << name << std::endl; + else + read_dispatch_ext(ima, istr, ext); + istr.close(); } + template <typename I> + void do_read(abstract::image<I>& ima, const filename& name) + { + std::string ext; + + ext = internal::utils::extension(name.get()); + +#if defined HAVE_ZLIB && HAVE_ZLIB == 1 + + if (ext == "gz") + do_read_gz(ima, name.get()); + else + do_read_non_gz(ima, name.get(), ext); +#else + do_read_non_gz(ima, name.get(), ext); +#endif // ! HAVE_ZLIB + } + + } } Index: oln/io/utils.hh --- oln/io/utils.hh (revision 53) +++ oln/io/utils.hh (working copy) @@ -76,17 +76,13 @@ std::string type; }; - bool read_pnm_header(std::ifstream& istr, - internal::pnm_info& info, - const std::string& name) + bool read_pnm_header(std::istream& istr, + internal::pnm_info& info) { - istr.open(name.c_str(), std::ifstream::in); - - if (!istr.is_open()) - return false; - std::getline(istr, info.type); + info.max_val = 1; + // skip comments while (istr.peek() == '#') { @@ -121,11 +117,9 @@ std::getline(istr, line); } - // FIXME: it can be either '\n', 'whitespace', ..., not only '\n'! - - // extract or skip maxvalue if (istr.get() != '\n') return false; + // extract or skip maxvalue if (info.type != "P1" && info.type != "P4") { istr >> info.max_val; @@ -137,29 +131,15 @@ return true; } - bool write_pnm_header(std::ofstream& ostr, - const std::string& name, + bool write_pnm_header(std::ostream& ostr, const std::string& type, int ncols, int nrows, int max_val) { if (max_val > 65535) - { - std::cerr << "error: can't save " << name - << ", data type too large" - << std::endl; - return false; - } + return false; - ostr.open(name.c_str(), std::ofstream::out); - - if (ostr.is_open() == false) - { - std::cerr << "error: couldn't open " << name << std::endl; - return false; - } - ostr << type << std::endl << "# Olena 1.0" << std::endl << ncols << " " << nrows << std::endl; Index: oln/core/value_box.hh --- oln/core/value_box.hh (revision 53) +++ oln/core/value_box.hh (working copy) @@ -79,6 +79,26 @@ typedef oln_type_of(I, point) point_type; + /// op== + + bool operator==(const value_box<I>& value) const + { + return this->value() == value.value(); + } + + template <typename V> + bool operator==(const V& value) const + { + return this->value() == value; + } + + template <typename V> + bool operator!=(const V& value) const + { + return ! this->operator==(value); + } + + /*! \brief op= ** FIXME:... ** \return (*this) @@ -87,7 +107,7 @@ template <typename V> value_box& operator=(const V& value) { - ima_.set(p_, value); + this->ima_->set(this->p_, value); return *this; } @@ -103,7 +123,7 @@ template <typename II> value_box& operator=(const value_box<II>& rhs) { - ima_.set(p_, rhs); // automatic conversion from rhs to value_type + ima_->set(p_, rhs); // automatic conversion from rhs to value_type return *this; } @@ -118,7 +138,7 @@ template <typename A, typename V> value_box& set(void (I::*method)(A), const V& value) { - ima_.set(p_, method, value); + ima_->set(p_, method, value); return *this; } @@ -133,13 +153,13 @@ template <typename V> operator const V() const { - const V value = ima_.get(p_); + const V value = ima_->get(p_); return value; } operator const value_type() const { - return ima_.get(p_); + return ima_->get(p_); } @@ -156,7 +176,7 @@ const value_type value() const { - return ima_.get(p_); + return ima_->get(p_); } @@ -180,7 +200,7 @@ /// Ctor (restricted access). value_box(abstract::image<I>& ima, const point_type& p) : - ima_(ima.exact()), + ima_(&ima.exact()), p_(p) { } @@ -189,7 +209,7 @@ ! attributes ! *------------*/ - I& ima_; + I* ima_; point_type p_; }; @@ -219,7 +239,25 @@ typedef oln_type_of(I, point) point_type; + /// op== + bool operator==(const value_box<const I>& value) const + { + return this->value() == value.value(); + } + template <typename V> + bool operator==(const V& value) const + { + return this->value() == value; + } + + template <typename V> + bool operator!=(const V& value) const + { + return ! this->operator==(value); + } + + /*! \brief Assignment (op=) is declared but undefined. */ @@ -235,13 +273,13 @@ template <typename V> operator const V() const { - const V value = ima_.get(p_); + const V value = ima_->get(p_); return value; } operator const value_type() const { - return ima_.get(p_); + return ima_->get(p_); } @@ -258,7 +296,7 @@ const value_type value() const { - return ima_.get(p_); + return ima_->get(p_); } // IDEA: provide op-> @@ -284,7 +322,7 @@ /// Ctor (restricted access). value_box(const abstract::image<I>& ima, const point_type& p) : - ima_(ima.exact()), + ima_(&ima.exact()), p_(p) { } @@ -293,7 +331,7 @@ ! attributes ! *------------*/ - const I& ima_; + const I* ima_; point_type p_; }; Index: oln/core/2d/image2d.hh --- oln/core/2d/image2d.hh (revision 53) +++ oln/core/2d/image2d.hh (working copy) @@ -140,7 +140,6 @@ { if (&rhs == this) return *this; - std::cout << "shallow copy" << std::endl; super_type::operator=(rhs); return *this; }; Index: img/lena.pgm.gz Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: img/lena.pgm.gz ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: img/lena.pgm Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: img/lena.pgm ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: img/chien.pbm.gz Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: img/chien.pbm.gz ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: img/chien.pbm Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: img/chien.pbm ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: img/lena.ppm.gz Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: img/lena.ppm.gz ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: img/lena.ppm Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: img/lena.ppm ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: img/lena.pbm.gz Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: img/lena.pbm.gz ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: img/lena.pbm Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: img/lena.pbm ___________________________________________________________________ Name: svn:mime-type + application/octet-stream

19 years, 1 month

proto-1.0 53: Use the compiler's debug flags in the test suite

by Roland Levillain

(Au passage, je profite de ce patch pour marquer les fichiers générés comme ignorés par Subversion.) https://svn.lrde.epita.fr/svn/oln/prototypes/proto-1.0 ChangeLog | 6 ++++++ tests/check/Makefile.flags | 8 ++++++-- 2 files changed, 12 insertions(+), 2 deletions(-) Index: olena/ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Use the compiler's debug flags in the test suite. * tests/check/Makefile.flags (AM_CXXFLAGS): Add $(CXXFLAGS_DEBUG). Property changes on: ___________________________________________________________________ Name: svn:ignore - aclocal.m4 autom4te.cache config.hin configure Makefile.in + Makefile Makefile.in aclocal.m4 autom4te.cache config.h config.hin config.log config.status configure diffs.patch stamp-h1 Property changes on: integre ___________________________________________________________________ Name: svn:ignore - Makefile.in + Makefile Makefile.in Property changes on: integre/tests ___________________________________________________________________ Name: svn:ignore - Makefile.in + Makefile Makefile.in Property changes on: integre/tests/sanity ___________________________________________________________________ Name: svn:ignore - Makefile.in + Makefile Makefile.in incltest.cc Property changes on: integre/tests/check ___________________________________________________________________ Name: svn:ignore + defs Property changes on: integre/ntg ___________________________________________________________________ Name: svn:ignore - Makefile.in + Makefile Makefile.in Property changes on: olena ___________________________________________________________________ Name: svn:ignore - Makefile.in + Makefile Makefile.in Property changes on: olena/tests ___________________________________________________________________ Name: svn:ignore - Makefile.in + Makefile Makefile.in incltest.cc Property changes on: olena/tests/sanity ___________________________________________________________________ Name: svn:ignore - Makefile.in + Makefile Makefile.in incltest.cc Property changes on: olena/tests/core ___________________________________________________________________ Name: svn:ignore - Makefile.in + Makefile Makefile.in runs Property changes on: olena/tests/check ___________________________________________________________________ Name: svn:ignore - Makefile.in + .deps Makefile Makefile.in defs libolncheck.a Index: olena/tests/check/Makefile.flags --- olena/tests/check/Makefile.flags (revision 52) +++ olena/tests/check/Makefile.flags (working copy) @@ -1,5 +1,9 @@ # -*- Makefile -*- -AM_CXXFLAGS = $(CXXFLAGS_OPTIMIZE) $(CXXFLAGS_STRICT_ERRORS) $(ZLIB_CXXFLAGS) -AM_CPPFLAGS = -I$(top_srcdir)/metalic/tests/check -I$(top_srcdir)/olena/tests/check +AM_CXXFLAGS = \ + $(CXXFLAGS_DEBUG) $(CXXFLAGS_OPTIMIZE) \ + $(CXXFLAGS_STRICT_ERRORS) $(ZLIB_CXXFLAGS) +AM_CPPFLAGS = \ + -I$(top_srcdir)/metalic/tests/check \ + -I$(top_srcdir)/olena/tests/check AM_LDFLAGS =

19 years, 1 month

proto-1.0 52: Make it pass make check

by Thierry GERAUD

hop --- :from: Thierry Geraud <theo(a)lrde.epita.fr> :server: :subject: "proto-1.0 52: Make it pass make check" :groups: - lrde.olena.patches --- Index: ChangeLog from Thierry Geraud <theo(a)lrde.epita.fr> * oln/core/3d/fwd_piter3d.hh: New. * tests/core/tests/readwrite_image: Fix to pass make check. * tests/core/tests/image_identity: Likewise. * oln/fancy/print.hh: Likewise. * oln/core/1d/array1d.hh: Likewise. * oln/core/1d/fwd_piter1d.hh: Likewise. * oln/core/1d/point1d.hh: Likewise. * oln/core/1d/size1d.hh: Likewise. * oln/core/coord.hh: Likewise. * oln/core/2d/fwd_piter2d.hh: Likewise. * oln/core/2d/point2d.hh: Likewise. * oln/core/2d/size2d.hh: Likewise. * oln/core/3d/size3d.hh: Likewise. * oln/core/3d/array3d.hh: Likewise. * oln/core/3d/image3d.hh: Likewise. * oln/core/3d/point3d.hh: Likewise. oln/core/1d/array1d.hh | 18 ++--- oln/core/1d/fwd_piter1d.hh | 4 - oln/core/1d/point1d.hh | 1 oln/core/1d/size1d.hh | 4 - oln/core/2d/fwd_piter2d.hh | 27 ++++---- oln/core/2d/point2d.hh | 1 oln/core/2d/size2d.hh | 4 - oln/core/3d/array3d.hh | 52 ++++++++------- oln/core/3d/fwd_piter3d.hh | 129 +++++++++++++++++++++++++++++++++++++++ oln/core/3d/image3d.hh | 5 - oln/core/3d/point3d.hh | 6 - oln/core/3d/size3d.hh | 14 +--- oln/core/coord.hh | 4 + oln/fancy/print.hh | 40 +++++------- tests/core/tests/image_identity | 1 tests/core/tests/readwrite_image | 26 ++++--- 16 files changed, 237 insertions(+), 99 deletions(-) Index: tests/core/tests/readwrite_image --- tests/core/tests/readwrite_image (revision 51) +++ tests/core/tests/readwrite_image (working copy) @@ -11,23 +11,26 @@ struct dummy_image; template <> - struct category_type< dummy_image > { typedef cat::image ret; }; + struct set_category< dummy_image > { typedef category::image ret; }; template <> - struct props <cat::image, dummy_image> : - public default_props < cat::image > + struct set_super_type< dummy_image > { + typedef abstract::image_with_data< dummy_image > ret; + }; + + template <> + struct set_props <category::image, dummy_image> : + public props_of < category::image > { - typedef prop_of<abstract::readwrite_image> image_constness; - typedef prop_of<abstract::image2d> image_dimension; + typedef is_a<abstract::readwrite_image> image_constness; + typedef is_a<abstract::image2d> image_dimension_type; typedef size2d size_type; typedef point2d point_type; typedef ntg::int_u8 value_type; - typedef mlc_encoding_type_(value_type) value_storage_type; - typedef array2d<value_storage_type> value_container_type; - - typedef mlc::no_type delegated_type; + typedef value_type value_storage_type; + typedef array2d<value_storage_type> storage_type; }; struct dummy_image : public abstract::image_with_data< dummy_image > @@ -55,7 +58,8 @@ bool check() { oln::dummy_image ima(3, 3); - ima[oln::point2d(0,0)] = 42; - std::cout << ima[oln::point2d(0,0)].value() << std::endl; + oln::point2d p(0,0); + ima[p] = 51; + std::cout << int(ima[p]) << std::endl; return false; } Index: tests/core/tests/image_identity --- tests/core/tests/image_identity (revision 51) +++ tests/core/tests/image_identity (working copy) @@ -1,7 +1,6 @@ #include <oln/core/abstract/image_identity.hh> #include <oln/core/2d/image2d.hh> #include <ntg/real/int_u8.hh> -#include <oln/core/cats.hh> template <typename I> Index: oln/fancy/print.hh --- oln/fancy/print.hh (revision 51) +++ oln/fancy/print.hh (working copy) @@ -38,6 +38,7 @@ # include <oln/core/abstract/image_dimension.hh> # include <oln/core/1d/point1d.hh> # include <oln/core/2d/point2d.hh> +# include <oln/core/3d/point3d.hh> # include <oln/core/coord.hh> @@ -104,18 +105,15 @@ template <typename E> void print(const abstract::image1d<E>& input, std::ostream& ostr) { - // FIXME: lacks cleaning for (coord_t index = 0; index < input.size().nindices(); ++index) - { - ostr << internal::pp<oln_type_of(E, value)>(input[point1d(index)]) << ' '; - } + ostr << internal::pp<oln_type_of(E, value)>(input[point1d(index)]) + << ' '; ostr << std::endl; } template <typename E> void print(const abstract::image2d<E>& input, std::ostream& ostr) { - // FIXME: lacks cleaning for (coord_t row = 0; row < input.size().nrows(); ++row) { for (coord_t col = 0; col < input.size().ncols(); ++col) @@ -124,24 +122,22 @@ } } - // FIXME: remove comments when dpoint3d are available. -// template <typename E> -// void print(const abstract::image3d<E>& input, std::ostream& ostr) -// { -// // FIXME: lacks cleaning -// for (coord_t slice = 0; slice < input.size().nslices(); ++slice) -// { -// for (coord_t row = 0; row < input.size().nrows(); ++row) -// { -// for (coord_t col = 0; col < input.size().ncols(); ++col) -// ostr << internal::pp<oln_value_type(E)>(input[point3d(slice,row,col)]) -// << ' '; -// ostr << ", "; -// } -// ostr << std::endl; -// } -// } + template <typename E> + void print(const abstract::image3d<E>& input, std::ostream& ostr) + { + for (coord_t slice = 0; slice < input.size().nslices(); ++slice) + { + for (coord_t row = 0; row < input.size().nrows(); ++row) + { + for (coord_t col = 0; col < input.size().ncols(); ++col) + ostr << internal::pp<oln_type_of(E, value)>(input[point3d(slice,row,col)]) + << ' '; + ostr << std::endl; + } + ostr << "---" << std::endl; + } + } } // end of namespace impl Index: oln/core/1d/array1d.hh --- oln/core/1d/array1d.hh (revision 51) +++ oln/core/1d/array1d.hh (working copy) @@ -116,7 +116,7 @@ void impl_resize(const size1d& s) { - precondition(s.nindices() > 0 and + precondition(s.nindices() > 0 && s.border() >= 0); invariant_(); this->clear_data(); @@ -134,14 +134,14 @@ bool impl_hold(const point1d& p) const { return - p.index() >= 0 and + p.index() >= 0 && p.index() < size_.nindices(); } bool impl_hold_large(const point1d& p) const { return - p.index() >= - size_.border() and + p.index() >= - size_.border() && p.index() < size_.nindices() + size_.border(); } @@ -173,13 +173,13 @@ void invariant_() const { - invariant((buffer_ != 0 and - size_.nindices() > 0 and + invariant((buffer_ != 0 && + size_.nindices() > 0 && size_.border() >= 0) - or - (buffer_ == 0 and - size_.nindices() == 0 and - size_.border() == 0)); + || + (buffer_ == 0 && + size_.nindices().is_undefined() && + size_.border().is_undefined())); } }; Index: oln/core/1d/fwd_piter1d.hh --- oln/core/1d/fwd_piter1d.hh (revision 51) +++ oln/core/1d/fwd_piter1d.hh (working copy) @@ -88,9 +88,7 @@ void impl_next() { precondition(this->p_.index().is_defined()); - precondition(this->p_.index() >= 0 and this->p_.index() <= this->s_.nindices()); - if (this->p_.index() == this->s_.nindices()) - return; + precondition(this->p_.index() >= 0 && this->p_.index() < this->s_.nindices()); ++this->p_.index(); postcondition(this->p_.index().is_defined()); } Index: oln/core/1d/point1d.hh --- oln/core/1d/point1d.hh (revision 51) +++ oln/core/1d/point1d.hh (working copy) @@ -65,6 +65,7 @@ { point1d() { + // no initialization here so that index_ is 'undef' } point1d(coord_t index_) : Index: oln/core/1d/size1d.hh --- oln/core/1d/size1d.hh (revision 51) +++ oln/core/1d/size1d.hh (working copy) @@ -39,7 +39,9 @@ struct size1d : public abstract::size< size1d > { size1d() - {} + { + // no initialization here so that members are 'undef' + } size1d(coord_t nindices_) : nindices_(nindices_), Index: oln/core/coord.hh --- oln/core/coord.hh (revision 51) +++ oln/core/coord.hh (working copy) @@ -71,6 +71,10 @@ bool operator==(value_type rhs) const { + if (! this->is_defined()) + { + std::cerr << "oops" << std::endl; + } precondition(this->is_defined()); return value_ == rhs; } Index: oln/core/2d/fwd_piter2d.hh --- oln/core/2d/fwd_piter2d.hh (revision 51) +++ oln/core/2d/fwd_piter2d.hh (working copy) @@ -25,8 +25,8 @@ // reasons why the executable file might be covered by the GNU General // Public License. -#ifndef PROTO_OLN_CORE_2D_FWD_PITER2D_HH -# define PROTO_OLN_CORE_2D_FWD_PITER2D_HH +#ifndef OLENA_CORE_2D_FWD_PITER2D_HH +# define OLENA_CORE_2D_FWD_PITER2D_HH # include <mlc/contract.hh> @@ -76,39 +76,42 @@ { this->p_.row() = 0; this->p_.col() = 0; - postcondition(this->p_.row().is_defined() && this->p_.col().is_defined()); + postcondition(this->p_.row().is_defined() && + this->p_.col().is_defined()); } bool impl_is_valid() const { - precondition(this->p_.row().is_defined() && this->p_.col().is_defined()); + precondition(this->p_.row().is_defined() && + this->p_.col().is_defined()); return this->p_.row() < this->s_.nrows(); } void impl_next() { - precondition(this->p_.row().is_defined() && this->p_.col().is_defined()); - precondition(this->p_.row() >= 0 && this->p_.row() <= this->s_.nrows() - && - this->p_.col() >= 0 && this->p_.col() <= this->s_.ncols()); + precondition(this->p_.row().is_defined() && + this->p_.col().is_defined()); + precondition(this->p_.row() >= 0 && this->p_.row() < this->s_.nrows() && + this->p_.col() >= 0 && this->p_.col() < this->s_.ncols()); ++this->p_.col(); if (this->p_.col() != this->s_.ncols()) return; this->p_.col() = 0; - precondition(this->p_.row() != this->s_.nrows()); ++this->p_.row(); - postcondition(this->p_.row().is_defined() && this->p_.col().is_defined()); + postcondition(this->p_.row().is_defined() && + this->p_.col().is_defined()); } void impl_invalidate() { this->p_.row() = this->s_.nrows(); this->p_.col() = this->s_.ncols(); - postcondition(this->p_.row().is_defined() && this->p_.col().is_defined()); + postcondition(this->p_.row().is_defined() && + this->p_.col().is_defined()); } }; } -#endif // ndef PROTO_OLN_CORE_2D_FWD_PITER2D_HH +#endif // ! OLENA_CORE_2D_FWD_PITER2D_HH Index: oln/core/2d/point2d.hh --- oln/core/2d/point2d.hh (revision 51) +++ oln/core/2d/point2d.hh (working copy) @@ -63,6 +63,7 @@ { point2d() { + // no initialization here so that row_ and col_ are 'undef' } point2d(coord_t row_, coord_t col_) : Index: oln/core/2d/size2d.hh --- oln/core/2d/size2d.hh (revision 51) +++ oln/core/2d/size2d.hh (working copy) @@ -39,7 +39,9 @@ struct size2d : public abstract::size< size2d > { size2d() - {} + { + // no initialization here so that members are 'undef' + } size2d(coord_t nrows_, coord_t ncols_) : nrows_(nrows_), Index: oln/core/3d/size3d.hh --- oln/core/3d/size3d.hh (revision 51) +++ oln/core/3d/size3d.hh (working copy) @@ -39,12 +39,10 @@ struct size3d : public abstract::size< size3d > { - size3d() : - nslices_(0), - nrows_(0), - ncols_(0), - border_(0) - {} + size3d() + { + // no initialization here so that members are 'undef' + } size3d(coord_t nslices_, coord_t nrows_, coord_t ncols_) : nslices_(nslices_), @@ -84,8 +82,8 @@ bool impl_eq(const size3d& rhs) const { - return this->nslices_ == rhs.nslices_ and - this->nrows_ == rhs.nrows_ and + return this->nslices_ == rhs.nslices_ && + this->nrows_ == rhs.nrows_ && this->ncols_ == rhs.ncols_; } Index: oln/core/3d/array3d.hh --- oln/core/3d/array3d.hh (revision 51) +++ oln/core/3d/array3d.hh (working copy) @@ -127,9 +127,9 @@ void impl_resize(const size3d& s) { - precondition(s.nslices() > 0 and - s.nrows() > 0 and - s.ncols() > 0 and + precondition(s.nslices() > 0 && + s.nrows() > 0 && + s.ncols() > 0 && s.border() >= 0); invariant_(); this->clear_data(); @@ -167,22 +167,22 @@ bool impl_hold(const point3d& p) const { return - p.slice() >= 0 and - p.slice() < size_.nslices() and - p.row() >= 0 and - p.row() < size_.nrows() and - p.col() >= 0 and + p.slice() >= 0 && + p.slice() < size_.nslices() && + p.row() >= 0 && + p.row() < size_.nrows() && + p.col() >= 0 && p.col() < size_.ncols(); } bool impl_hold_large(const point3d& p) const { return - p.slice() >= - size_.border() and - p.slice() < size_.nslices() + size_.border() and - p.row() >= - size_.border() and - p.row() < size_.nrows() + size_.border() and - p.col() >= - size_.border() and + p.slice() >= - size_.border() && + p.slice() < size_.nslices() + size_.border() && + p.row() >= - size_.border() && + p.row() < size_.nrows() + size_.border() && + p.col() >= - size_.border() && p.col() < size_.ncols() + size_.border(); } @@ -219,19 +219,21 @@ void invariant_() const { - invariant((buffer_ != 0 and - array_ != 0 and - size_.nslices() > 0 and - size_.nrows() > 0 and - size_.ncols() > 0 and + invariant((buffer_ != 0 && + array_ != 0 && + array2_ != 0 && + size_.nslices() > 0 && + size_.nrows() > 0 && + size_.ncols() > 0 && size_.border() >= 0) - or - (buffer_ == 0 and - array_ == 0 and - size_.nslices() == 0 and - size_.nrows() == 0 and - size_.ncols() == 0 and - size_.border() == 0)); + || + (buffer_ == 0 && + array_ == 0 && + array2_ == 0 && + size_.nslices().is_undefined() && + size_.nrows().is_undefined() && + size_.ncols().is_undefined() && + size_.border().is_undefined())); } }; Index: oln/core/3d/image3d.hh --- oln/core/3d/image3d.hh (revision 51) +++ oln/core/3d/image3d.hh (working copy) @@ -32,6 +32,7 @@ # include <oln/core/abstract/image_with_data.hh> # include <oln/core/3d/array3d.hh> +# include <oln/core/3d/fwd_piter3d.hh> /*! \namespace oln ** \brief oln namespace. @@ -67,8 +68,8 @@ typedef point3d point_type; typedef T value_type; -// typedef fwd_piter3d piter_type; -// typedef fwd_piter3d fwd_piter_type; + typedef fwd_piter3d piter_type; + typedef fwd_piter3d fwd_piter_type; // please note that value_storage_type means data_type // since image3d is an image_with_data Index: oln/core/3d/fwd_piter3d.hh --- oln/core/3d/fwd_piter3d.hh (revision 0) +++ oln/core/3d/fwd_piter3d.hh (revision 0) @@ -0,0 +1,129 @@ +// 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_3D_FWD_PITER3D_HH +# define OLENA_CORE_3D_FWD_PITER3D_HH + +# include <mlc/contract.hh> + +# include <oln/core/abstract/piter.hh> +# include <oln/core/3d/point3d.hh> +# include <oln/core/3d/size3d.hh> + + +namespace oln { + + // fwd decl + struct fwd_piter3d; + + // category + template <> + struct set_category<fwd_piter3d> { typedef category::piter ret; }; + + + // props + template <> + struct set_props < category::piter, fwd_piter3d > : public props_of<category::piter> + { + typedef point3d point_type; + typedef size3d size_type; + }; + + + + struct fwd_piter3d : public abstract::piter< fwd_piter3d > + { + + typedef abstract::piter<fwd_piter3d> super_type; + + fwd_piter3d(const size3d& size) : + super_type(size) + { + this->exact_ptr = this; + this->invalidate(); + } + +# if defined __GNUC__ && __GNUC__ >= 3 + friend class abstract::piter< fwd_piter3d >; + protected: +# endif + + void impl_start() + { + this->p_.row() = 0; + this->p_.col() = 0; + this->p_.slice() = 0; + postcondition(this->p_.row().is_defined() && + this->p_.col().is_defined() && + this->p_.slice().is_defined()); + } + + bool impl_is_valid() const + { + precondition(this->p_.row().is_defined() && + this->p_.col().is_defined() && + this->p_.slice().is_defined()); + return this->p_.slice() < this->s_.nslices(); + } + + void impl_next() + { + precondition(this->p_.row().is_defined() && + this->p_.col().is_defined() && + this->p_.slice().is_defined()); + precondition(this->p_.row() >= 0 && this->p_.row() < this->s_.nrows() && + this->p_.col() >= 0 && this->p_.col() < this->s_.ncols() && + this->p_.slice() >= 0 && this->p_.slice() < this->s_.nslices()); + ++this->p_.col(); + if (this->p_.col() != this->s_.ncols()) + return; + this->p_.col() = 0; + ++this->p_.row(); + if (this->p_.row() != this->s_.nrows()) + return; + this->p_.row() = 0; + ++this->p_.slice(); + postcondition(this->p_.row().is_defined() && + this->p_.col().is_defined() && + this->p_.slice().is_defined()); + } + + void impl_invalidate() + { + this->p_.row() = this->s_.nrows(); + this->p_.col() = this->s_.ncols(); + this->p_.slice() = this->s_.nslices(); + postcondition(this->p_.row().is_defined() && + this->p_.col().is_defined() && + this->p_.slice().is_defined()); + } + + }; +} + + +#endif // ! OLENA_CORE_3D_FWD_PITER3D_HH Index: oln/core/3d/point3d.hh --- oln/core/3d/point3d.hh (revision 51) +++ oln/core/3d/point3d.hh (working copy) @@ -57,11 +57,9 @@ struct point3d : public abstract::point< point3d > { - point3d() : - slice_(0), - row_(0), - col_(0) + point3d() { + // no initialization here so that slice_, row_, and col_ are 'undef' } point3d(coord_t slice_, coord_t row_, coord_t col_) :

19 years, 1 month

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches March 2005