Commit f3ceaba8 authored by Simon Nivault's avatar Simon Nivault
Browse files

Add vector and trait for binary

	* sandbox/nivault/binary_arith.hh: New.
	* sandbox/nivault/tests/test.cc: Update.
	* sandbox/nivault/vec.hh: New.

git-svn-id: https://svn.lrde.epita.fr/svn/oln/trunk@1117 4aad255d-cdde-0310-9447-f3009e2ae8c0
parent 17c14a7a
2007-09-17 Simon Nivault <simon.nivault@lrde.epita.fr>
Add vector and trait for binary
* sandbox/nivault/binary_arith.hh: New.
* sandbox/nivault/tests/test.cc: Update.
* sandbox/nivault/vec.hh: New.
2007-09-17 Thierry Geraud <thierry.geraud@lrde.epita.fr>
Bug fix.
......
// Copyright (C) 2006 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, 51 Franklin Street, Fifth Floor,
// 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 MLN_CORE_TRAIT_BINARY_ARITH_HH
# define MLN_CORE_TRAIT_BINARY_ARITH_HH
template <typename T, typename U>
struct binary_arith
{
typedef T ret;
};
template <>
struct binary_arith<int, float>
{
typedef float ret;
};
template <>
struct binary_arith<float, int>
{
typedef float ret;
};
template <>
struct binary_arith<int, double>
{
typedef double ret;
};
template <>
struct binary_arith<double, int>
{
typedef double ret;
};
template <>
struct binary_arith<double, float>
{
typedef double ret;
};
template <>
struct binary_arith<float, double>
{
typedef double ret;
};
#endif // ! MLN_CORE_TRAIT_BINARY_ARITH_HH
......@@ -30,22 +30,14 @@
* \brief Test on mln::median::median_dir.
*/
#include <median.hh>
#include <mln/io/load_pgm.hh>
#include <mln/io/save_pgm.hh>
#include <mln/level/paste.hh>
#include <mln/core/win/hline2d.hh>
#include <vec.hh>
int main()
{
using namespace mln;
using namespace xtd;
image2d_b< value::int_u8 >
lena = io::load_pgm("lena.pgm"),
out = image2d_b< value::int_u8 >(lena.domain());
vec<3,int> v_int = mk_vec(3,6,7);
vec<3,float> v_f = mk_vec(2.6, 1.9, 5.2);
win::hline2d win(7);
level::impl::median_dir(lena, win, 0, out);
io::save_pgm(out, "out.pgm");
std::cout << v_int + v_f << std::endl;
}
// Copyright (C) 2006 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, 51 Franklin Street, Fifth Floor,
// 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 XTD_VEC_HH
# define XTD_VEC_HH
# include <iostream>
# include "binary_arith.hh"
// FIXME: Document.
namespace xtd
{
namespace internal
{
template <unsigned n, typename T>
class vec_base_
{
protected:
T data_[n];
};
template <typename T>
class vec_base_ <1, T>
{
public:
void set(const T& val0)
{
data_[0] = val0;
}
protected:
T data_[1];
};
template <typename T>
class vec_base_ <2, T>
{
public:
void set(const T& val0, const T& val1)
{
data_[0] = val0;
data_[1] = val1;
}
protected:
T data_[2];
};
template <typename T>
class vec_base_ <3, T>
{
public:
void set(const T& val0, const T& val1, const T& val2)
{
data_[0] = val0;
data_[1] = val1;
data_[2] = val2;
}
protected:
T data_[3];
};
template <typename T>
class vec_base_ <4, T>
{
public:
void set(const T& val0, const T& val1, const T& val2, const T& val3)
{
data_[0] = val0;
data_[1] = val1;
data_[2] = val2;
data_[3] = val3;
}
protected:
T data_[4];
};
} // end of namespace xtd::internal
template <unsigned n, typename T>
class vec : public internal::vec_base_<n, T>
{
typedef internal::vec_base_<n,T> super;
using super::data_;
public:
typedef T value_type;
enum { dim = n };
vec()
{
}
template <typename U>
vec(const vec<n, U>& rhs)
{
for (unsigned i = 0; i < n; ++i)
data_[i] = rhs[i];
}
template <typename U>
vec& operator=(const vec<n, U>& rhs)
{
for (unsigned i = 0; i < n; ++i)
data_[i] = rhs[i];
return *this;
}
const T& operator[](unsigned i) const
{
// precondition(i < dim);
return data_[i];
}
T& operator[](unsigned i)
{
// precondition(i < dim);
return data_[i];
}
void set_all(const T& val)
{
for (unsigned i = 0; i < n; ++i)
data_[i] = val;
}
unsigned size() const
{
return n;
}
};
// eq
template <unsigned n, typename T, typename U>
bool operator==(const vec<n,T>& lhs, const vec<n,U>& rhs)
{
for (unsigned i = 0; i < n; ++i)
if (lhs[i] != rhs[i])
return false;
return true;
}
template <unsigned n, typename T, typename U>
bool operator!=(const vec<n,T>& lhs, const vec<n,U>& rhs)
{
return not (lhs == rhs);
}
// +
template <unsigned n, typename T, typename U>
vec<n,T>&
operator+=(vec<n,T>& lhs, const vec<n,U>& rhs)
{
for (unsigned i = 0; i < n; ++i)
lhs[i] += rhs[i];
return lhs;
}
template <unsigned n, typename T, typename U>
vec<n, typename binary_arith<T, U>::ret >
operator+(const vec<n,T>& lhs, const vec<n,U>& rhs)
{
vec<n, typename binary_arith<T, U>::ret> tmp;
for (unsigned i = 0; i < n; ++i)
tmp[i] = lhs[i] + rhs[i];
return tmp;
}
// -
template <unsigned n, typename T, typename U>
vec<n,T>&
operator-=(vec<n,T>& lhs, const vec<n,U>& rhs)
{
for (unsigned i = 0; i < n; ++i)
lhs[i] -= rhs[i];
return lhs;
}
template <unsigned n, typename T, typename U>
vec<n, typename binary_arith<T, U>::ret>
operator-(const vec<n,T>& lhs, const vec<n,U>& rhs)
{
vec<n, typename binary_arith<T, U>::ret> tmp;
for (unsigned i = 0; i < n; ++i)
tmp[i] = lhs[i] - rhs[i];
return tmp;
}
template <unsigned n, typename T>
vec<n, T>
operator-(const vec<n,T>& lhs)
{
vec<n, T> tmp;
for (unsigned i = 0; i < n; ++i)
tmp[i] = - lhs[i];
return tmp;
}
// *
template <unsigned n, typename T, typename S>
vec<n,T>&
operator*=(vec<n,T>& lhs, const S& scalar)
{
for (unsigned i = 0; i < n; ++i)
lhs[i] *= scalar;
return lhs;
}
template <unsigned n, typename T, typename S>
vec<n, typename binary_arith<T, S>::ret>
operator*(const vec<n,T>& lhs, const S& scalar)
{
vec<n, typename binary_arith<T, S>::ret> tmp;
for (unsigned i = 0; i < n; ++i)
tmp[i] = lhs[i] * scalar;
return tmp;
}
// /
template <unsigned n, typename T, typename S>
vec<n,T>&
operator/=(vec<n,T>& lhs, const S& scalar)
{
precondition(scalar != 0);
for (unsigned i = 0; i < n; ++i)
lhs[i] /= scalar;
return lhs;
}
template <unsigned n, typename T, typename S>
vec<n, typename binary_arith<T, S>::ret>
operator/(const vec<n,T>& lhs, const S& scalar)
{
precondition(scalar != 0);
vec<n, typename binary_arith<T, S>::ret> tmp;
for (unsigned i = 0; i < n; ++i)
tmp[i] = lhs[i] / scalar;
return tmp;
}
// <<
template <unsigned n, typename T>
std::ostream&
operator<<(std::ostream& ostr, const vec<n,T>& v)
{
ostr << '(';
for (unsigned i = 0; i < n; ++i)
ostr << v[i] << (i == n - 1 ? ")" : ", ");
return ostr;
}
template <unsigned n>
std::ostream&
operator<<(std::ostream& ostr, const vec<n,unsigned char>& v)
{
ostr << '(';
for (unsigned i = 0; i < n; ++i)
ostr << (unsigned int)(v[i]) << (i == n - 1 ? ")" : ", ");
return ostr;
}
template <unsigned n>
std::ostream&
operator<<(std::ostream& ostr, const vec<n,signed char>& v)
{
ostr << '(';
for (unsigned i = 0; i < n; ++i)
ostr << (signed int)(v[i]) << (i == n - 1 ? ")" : ", ");
return ostr;
}
/// mk_vec.
template <typename T>
vec<1, T> mk_vec(const T& v_0)
{
vec<1, T> tmp;
tmp[0] = v_0;
return tmp;
}
template <typename T>
vec<2, T> mk_vec(const T& v_0, const T& v_1)
{
vec<2, T> tmp;
tmp[0] = v_0;
tmp[1] = v_1;
return tmp;
}
template <typename T>
vec<3, T> mk_vec(const T& v_0, const T& v_1, const T& v_2)
{
vec<3, T> tmp;
tmp[0] = v_0;
tmp[1] = v_1;
tmp[2] = v_2;
return tmp;
}
template <typename T>
vec<4, T> mk_vec(const T& v_0, const T& v_1, const T& v_2, const T& v_3)
{
vec<4, T> tmp;
tmp[0] = v_0;
tmp[1] = v_1;
tmp[2] = v_2;
tmp[3] = v_3;
return tmp;
}
} // end of namespace xtd
#endif // ! XTD_VEC_HH
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment