428 lines
19 KiB
C++
428 lines
19 KiB
C++
/*
|
|
* Copyright 2015-2020 Michele "King_DuckZ" Santullo
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "vectorwrapper/sequence_bt.hpp"
|
|
#include "vectorwrapper/size_type.hpp"
|
|
#include "vectorwrapper/implem_vec_base.hpp"
|
|
#include "vectorwrapper/implem_vec_common.hpp"
|
|
#include <ciso646>
|
|
#include <type_traits>
|
|
#include <array>
|
|
#include <cassert>
|
|
#include <functional>
|
|
|
|
#define VWR_VERSION_MAJOR @PROJECT_VERSION_MAJOR@
|
|
#define VWR_VERSION_MINOR @PROJECT_VERSION_MINOR@
|
|
#define VWR_VERSION_PATCH @PROJECT_VERSION_PATCH@
|
|
|
|
#if defined VWR_OUTER_NAMESPACE
|
|
namespace VWR_OUTER_NAMESPACE {
|
|
#endif
|
|
|
|
namespace vwr {
|
|
template <typename V>
|
|
struct VectorWrapperInfo;
|
|
|
|
template <typename V, size_type S>
|
|
class Vec;
|
|
|
|
namespace implem {
|
|
#if defined(VWR_WITH_IMPLICIT_CONVERSIONS)
|
|
template <typename V1, typename V2, size_type D>
|
|
Vec<V1>& assign ( Vec<V1, D>& parLeft, const Vec<V2, D>& parRight );
|
|
#endif
|
|
|
|
template <typename T, size_type S=VectorWrapperInfo<T>::dimensions>
|
|
struct offsets_array_wrapper {
|
|
template <size_type... I>
|
|
offsets_array_wrapper ( const bt::number_seq<size_type, I...>& );
|
|
|
|
const std::array<unsigned int, S> offsets;
|
|
};
|
|
|
|
template <typename V, bool Enabled> struct Vec1Promotion;
|
|
template <typename V> struct Vec1Promotion<V, false> { };
|
|
template <typename V> struct Vec1Promotion<V, true> {
|
|
typedef Vec<typename VectorWrapperInfo<V>::higher_vector_type> higher_vector_type;
|
|
typedef typename VectorWrapperInfo<V>::scalar_type scalar_type;
|
|
|
|
static_assert(VectorWrapperInfo<typename VectorWrapperInfo<V>::higher_vector_type>::dimensions == 2, "Wrong promoted vector type");
|
|
|
|
higher_vector_type x1 ( void ) const { return xn(scalar_type(1)); }
|
|
higher_vector_type x0 ( void ) const { return xn(scalar_type(0)); }
|
|
higher_vector_type xn ( const scalar_type& parN ) const;
|
|
higher_vector_type nx ( const scalar_type& parN ) const;
|
|
};
|
|
|
|
template <typename V, bool Enabled> struct Vec2Promotion;
|
|
template <typename V> struct Vec2Promotion<V, false> {};
|
|
template <typename V> struct Vec2Promotion<V, true> {
|
|
typedef Vec<typename VectorWrapperInfo<V>::higher_vector_type> higher_vector_type;
|
|
typedef typename VectorWrapperInfo<V>::scalar_type scalar_type;
|
|
|
|
static_assert(VectorWrapperInfo<typename VectorWrapperInfo<V>::higher_vector_type>::dimensions == 3, "Wrong promoted vector type");
|
|
|
|
higher_vector_type xy1 ( void ) const { return xyn(scalar_type(1)); }
|
|
higher_vector_type xy0 ( void ) const { return xyn(scalar_type(0)); }
|
|
higher_vector_type xyn ( const scalar_type& parZ ) const;
|
|
};
|
|
|
|
template <typename V, bool Enabled> struct Vec3Promotion;
|
|
template <typename V> struct Vec3Promotion<V, false> {};
|
|
template <typename V> struct Vec3Promotion<V, true> {
|
|
typedef Vec<typename VectorWrapperInfo<V>::higher_vector_type> higher_vector_type;
|
|
typedef typename VectorWrapperInfo<V>::scalar_type scalar_type;
|
|
|
|
static_assert(VectorWrapperInfo<typename VectorWrapperInfo<V>::higher_vector_type>::dimensions == 4, "Wrong promoted vector type");
|
|
|
|
higher_vector_type xyz1 ( void ) const { return xyzw(scalar_type(1)); }
|
|
higher_vector_type xyz0 ( void ) const { return xyzw(scalar_type(0)); }
|
|
higher_vector_type xyzw ( const scalar_type& parW ) const;
|
|
};
|
|
|
|
template <typename V, bool Enabled> struct Vec3Demotion;
|
|
template <typename V> struct Vec3Demotion<V, false> : Vec3Promotion<V, HasHigherVecTypedef<V>::value> {};
|
|
template <typename V> struct Vec3Demotion<V, true> : Vec3Promotion<V, HasHigherVecTypedef<V>::value> {
|
|
typedef Vec<typename VectorWrapperInfo<V>::lower_vector_type> lower_vector_type;
|
|
typedef typename VectorWrapperInfo<V>::scalar_type scalar_type;
|
|
|
|
static_assert(VectorWrapperInfo<typename VectorWrapperInfo<V>::lower_vector_type>::dimensions == 2, "Wrong demoted vector type");
|
|
|
|
lower_vector_type xy ( void ) const;
|
|
lower_vector_type xz ( void ) const;
|
|
lower_vector_type yz ( void ) const;
|
|
};
|
|
|
|
template <typename V, bool Enabled> struct Vec4Demotion;
|
|
template <typename V> struct Vec4Demotion<V, false> {};
|
|
template <typename V> struct Vec4Demotion<V, true> {
|
|
typedef Vec<typename VectorWrapperInfo<V>::lower_vector_type> lower_vector_type;
|
|
typedef typename VectorWrapperInfo<V>::scalar_type scalar_type;
|
|
|
|
static_assert(VectorWrapperInfo<typename VectorWrapperInfo<V>::lower_vector_type>::dimensions == 3, "Wrong demoted vector type");
|
|
|
|
lower_vector_type xyz ( void ) const;
|
|
lower_vector_type xyw ( void ) const;
|
|
lower_vector_type xzw ( void ) const;
|
|
lower_vector_type yzw ( void ) const;
|
|
};
|
|
|
|
template <typename V, size_type D>
|
|
struct VecAccessors;
|
|
|
|
template <typename V>
|
|
struct VecAccessors<V, 4> : Vec4Demotion<V, HasLowerVecTypedef<VectorWrapperInfo<V>>::value> {
|
|
typedef typename VectorWrapperInfo<V>::scalar_type scalar_type;
|
|
const Vec<V>& xyzw ( void ) const { return *static_cast<const Vec<V>*>(this); }
|
|
const scalar_type& x ( void ) const;
|
|
const scalar_type& y ( void ) const;
|
|
const scalar_type& z ( void ) const;
|
|
const scalar_type& w ( void ) const;
|
|
scalar_type& x ( void );
|
|
scalar_type& y ( void );
|
|
scalar_type& z ( void );
|
|
scalar_type& w ( void );
|
|
|
|
#if defined(VWR_EXTRA_SETTERS)
|
|
void set_x (const scalar_type& v) { x() = v; }
|
|
void set_y (const scalar_type& v) { y() = v; }
|
|
void set_z (const scalar_type& v) { z() = v; }
|
|
void set_w (const scalar_type& v) { w() = v; }
|
|
#endif
|
|
|
|
#if defined(VWR_EXTRA_ACCESSORS)
|
|
Vec<V> xyz0 ( void ) const { return Vec<V>(x(), y(), z(), scalar_type(0)); }
|
|
Vec<V> xyz1 ( void ) const { return Vec<V>(x(), y(), z(), scalar_type(1)); }
|
|
Vec<V> x0zw ( void ) const { return Vec<V>(x(), scalar_type(0), z(), w()); }
|
|
Vec<V> x1zw ( void ) const { return Vec<V>(x(), scalar_type(1), z(), w()); }
|
|
Vec<V> _0yzw ( void ) const { return Vec<V>(scalar_type(0), y(), z(), w()); }
|
|
Vec<V> _1yzw ( void ) const { return Vec<V>(scalar_type(1), y(), z(), w()); }
|
|
Vec<V> wxyz ( void ) const { return Vec<V>(w(), x(), y(), z()); }
|
|
#endif
|
|
};
|
|
|
|
//Workaround for visual studio - VecAccessors<V, 3> should inherit from
|
|
//both Vec3Promotion and Vec3Demotion, but when I do that, sizeof(Vec)
|
|
//is wrong. I had to linearize the inheritance hierarchy so that the
|
|
//sizeof(Vec<V>) == sizeof(V) condition is verified.
|
|
template <typename V>
|
|
struct VecAccessors<V, 3> : Vec3Demotion<V, HasLowerVecTypedef<VectorWrapperInfo<V>>::value> {
|
|
typedef typename VectorWrapperInfo<V>::scalar_type scalar_type;
|
|
const Vec<V>& xyz ( void ) const { return *static_cast<const Vec<V>*>(this); }
|
|
const scalar_type& x ( void ) const;
|
|
const scalar_type& y ( void ) const;
|
|
const scalar_type& z ( void ) const;
|
|
scalar_type& x ( void );
|
|
scalar_type& y ( void );
|
|
scalar_type& z ( void );
|
|
|
|
#if defined(VWR_EXTRA_SETTERS)
|
|
void set_x (const scalar_type& v) { x() = v; }
|
|
void set_y (const scalar_type& v) { y() = v; }
|
|
void set_z (const scalar_type& v) { z() = v; }
|
|
#endif
|
|
|
|
#if defined(VWR_EXTRA_ACCESSORS)
|
|
Vec<V> xy0 ( void ) const { return Vec<V>(x(), y(), scalar_type(0)); }
|
|
Vec<V> xy1 ( void ) const { return Vec<V>(x(), y(), scalar_type(1)); }
|
|
Vec<V> x0z ( void ) const { return Vec<V>(x(), scalar_type(0), z()); }
|
|
Vec<V> x1z ( void ) const { return Vec<V>(x(), scalar_type(1), z()); }
|
|
Vec<V> _0yz ( void ) const { return Vec<V>(scalar_type(0), y(), z()); }
|
|
Vec<V> _1yz ( void ) const { return Vec<V>(scalar_type(1), y(), z()); }
|
|
Vec<V> zxy ( void ) const { return Vec<V>(z(), x(), y()); }
|
|
#endif
|
|
};
|
|
|
|
template <typename V>
|
|
struct VecAccessors<V, 2> : Vec2Promotion<V, HasHigherVecTypedef<VectorWrapperInfo<V>>::value> {
|
|
typedef typename VectorWrapperInfo<V>::scalar_type scalar_type;
|
|
const Vec<V>& xy ( void ) const { return *static_cast<const Vec<V>*>(this); }
|
|
const scalar_type& x ( void ) const;
|
|
const scalar_type& y ( void ) const;
|
|
scalar_type& x ( void );
|
|
scalar_type& y ( void );
|
|
|
|
#if defined(VWR_EXTRA_SETTERS)
|
|
void set_x (const scalar_type& v) { x() = v; }
|
|
void set_y (const scalar_type& v) { y() = v; }
|
|
#endif
|
|
|
|
#if defined(VWR_EXTRA_ACCESSORS)
|
|
Vec<V> x0 ( void ) const { return Vec<V>(x(), scalar_type(0)); }
|
|
Vec<V> x1 ( void ) const { return Vec<V>(x(), scalar_type(1)); }
|
|
Vec<V> yx ( void ) const { return Vec<V>(y(), x()); }
|
|
Vec<V> _0y ( void ) const { return Vec<V>(scalar_type(0), y()); }
|
|
Vec<V> _1y ( void ) const { return Vec<V>(scalar_type(1), y()); }
|
|
#endif
|
|
};
|
|
|
|
template <typename V>
|
|
struct VecAccessors<V, 1> : Vec1Promotion<V, HasHigherVecTypedef<VectorWrapperInfo<V>>::value> {
|
|
typedef typename VectorWrapperInfo<V>::scalar_type scalar_type;
|
|
scalar_type& x ( void );
|
|
const scalar_type& x ( void ) const;
|
|
|
|
#if defined(VWR_EXTRA_SETTERS)
|
|
void set_x (const scalar_type& v) { x() = v; }
|
|
#endif
|
|
};
|
|
|
|
template <bool LastVal, typename V1, typename V2, typename ComposeOp, typename Op>
|
|
constexpr bool compare ( const Vec<V1>& parLeft, const Vec<V2>& parRight, Op parComposeOp, Op parOp, bt::number_seq<size_type> );
|
|
template <bool LastVal, typename V1, typename V2, typename ComposeOp, typename Op, size_type I1, size_type... I>
|
|
bool compare ( const Vec<V1>& parLeft, const Vec<V2>& parRight, ComposeOp parComposeOp, Op parOp, bt::number_seq<size_type, I1, I...> );
|
|
|
|
template <typename V1, typename V2, typename Op, size_type... I>
|
|
Vec<typename std::common_type<V1, V2>::type> binary_op ( const Vec<V1>& parLeft, const Vec<V2>& parRight, Op parOp, const Vec<typename std::common_type<V1, V2>::type>& parLastVal, bt::number_seq<size_type, I...> );
|
|
} //namespace implem
|
|
|
|
template <typename V, size_type S>
|
|
class Vec : public implem::VecBase<V> {
|
|
public:
|
|
enum {
|
|
dimensions = S
|
|
};
|
|
};
|
|
|
|
template <typename V>
|
|
class Vec<V, 1> : public implem::VecBase<V>, public implem::VecAccessors<V, 1> {
|
|
static_assert(std::is_standard_layout<implem::VecBase<V>>::value, "Base class must be a standard layout type");
|
|
public:
|
|
typedef typename implem::VecBase<V>::vector_type vector_type;
|
|
typedef typename implem::VecBase<V>::scalar_type scalar_type;
|
|
enum {
|
|
dimensions = 1
|
|
};
|
|
|
|
static const Vec<V, 1> unit_x;
|
|
|
|
Vec ( void ) = default;
|
|
Vec ( const Vec& parOther ) : implem::VecBase<V>(parOther) { }
|
|
Vec ( const vector_type& parIn ) : implem::VecBase<V>(parIn) { }
|
|
template <typename T>
|
|
explicit Vec ( const typename std::enable_if<std::is_same<T, scalar_type>::value and not std::is_same<scalar_type, vector_type>::value, T>::type& parX ) : implem::VecBase<V>(parX) { }
|
|
#if defined(VWR_WITH_IMPLICIT_CONVERSIONS)
|
|
template <typename V2> Vec ( const Vec<V2, dimensions>& parOther ) { implem::assign(*this, parOther); }
|
|
template <typename V2>
|
|
Vec& operator= ( const Vec<V2, dimensions>& parOther ) { return implem::assign(*this, parOther); }
|
|
#endif
|
|
|
|
Vec& operator= ( const Vec& parOther ) { return implem::assign_same_type(*this, parOther); }
|
|
};
|
|
|
|
template <typename V>
|
|
class Vec<V, 2> : public implem::VecBase<V>, public implem::VecAccessors<V, 2> {
|
|
static_assert(std::is_standard_layout<implem::VecBase<V>>::value, "Base class must be a standard layout type");
|
|
static_assert(std::is_standard_layout<implem::VecAccessors<V, 2>>::value, "Base class must be a standard layout type");
|
|
public:
|
|
typedef typename implem::VecBase<V>::scalar_type scalar_type;
|
|
typedef typename implem::VecBase<V>::vector_type vector_type;
|
|
enum {
|
|
dimensions = 2
|
|
};
|
|
|
|
static const Vec<V, 2> unit_x;
|
|
static const Vec<V, 2> unit_y;
|
|
|
|
Vec ( void ) = default;
|
|
Vec ( const Vec& parOther ) : implem::VecBase<V>(parOther) { }
|
|
Vec ( const vector_type& parIn ) : implem::VecBase<V>(parIn) { }
|
|
explicit Vec ( const scalar_type parX ) : implem::VecBase<V>(parX) { }
|
|
Vec ( scalar_type parX, scalar_type parY ) : implem::VecBase<V>(parX, parY) { }
|
|
#if defined(VWR_WITH_IMPLICIT_CONVERSIONS)
|
|
template <typename V2> Vec ( const Vec<V2, dimensions>& parOther ) { implem::assign(*this, parOther); }
|
|
template <typename V2>
|
|
Vec& operator= ( const Vec<V2, dimensions>& parOther ) { return implem::assign(*this, parOther); }
|
|
#endif
|
|
|
|
Vec& operator= ( const Vec& parOther ) { return implem::assign_same_type(*this, parOther); }
|
|
Vec& operator= ( const vector_type& parOther ) { this->data() = parOther; return *this; }
|
|
};
|
|
|
|
template <typename V>
|
|
class Vec<V, 3> : public implem::VecBase<V>, public implem::VecAccessors<V, 3> {
|
|
static_assert(std::is_standard_layout<implem::VecBase<V>>::value, "Base class must be a standard layout type");
|
|
static_assert(std::is_standard_layout<implem::VecAccessors<V, 3>>::value, "Base class must be a standard layout type");
|
|
public:
|
|
typedef typename implem::VecBase<V>::scalar_type scalar_type;
|
|
typedef typename implem::VecBase<V>::vector_type vector_type;
|
|
enum {
|
|
dimensions = 3
|
|
};
|
|
|
|
static const Vec<V, 3> unit_x;
|
|
static const Vec<V, 3> unit_y;
|
|
static const Vec<V, 3> unit_z;
|
|
|
|
Vec ( void ) = default;
|
|
Vec ( const Vec& parOther ) : implem::VecBase<V>(parOther) { }
|
|
Vec ( const vector_type& parIn ) : implem::VecBase<V>(parIn) { }
|
|
explicit Vec ( const scalar_type parX ) : implem::VecBase<V>(parX) { }
|
|
Vec ( scalar_type parX, scalar_type parY, scalar_type parZ ) : implem::VecBase<V>(parX, parY, parZ) { }
|
|
#if defined(VWR_WITH_IMPLICIT_CONVERSIONS)
|
|
template <typename V2> Vec ( const Vec<V2, dimensions>& parOther ) { implem::assign(*this, parOther); }
|
|
template <typename V2>
|
|
Vec& operator= ( const Vec<V2, dimensions>& parOther ) { return implem::assign(*this, parOther); }
|
|
#endif
|
|
|
|
Vec& operator= ( const Vec& parOther ) { return implem::assign_same_type(*this, parOther); }
|
|
Vec& operator= ( const vector_type& parOther ) { this->data() = parOther; return *this; }
|
|
};
|
|
|
|
template <typename V>
|
|
class Vec<V, 4> : public implem::VecBase<V>, public implem::VecAccessors<V, 4> {
|
|
static_assert(std::is_standard_layout<implem::VecBase<V>>::value, "Base class must be a standard layout type");
|
|
static_assert(std::is_standard_layout<implem::VecAccessors<V, 4>>::value, "Base class must be a standard layout type");
|
|
public:
|
|
typedef typename implem::VecBase<V>::scalar_type scalar_type;
|
|
typedef typename implem::VecBase<V>::vector_type vector_type;
|
|
enum {
|
|
dimensions = 4
|
|
};
|
|
|
|
static const Vec<V, 4> unit_x;
|
|
static const Vec<V, 4> unit_y;
|
|
static const Vec<V, 4> unit_z;
|
|
static const Vec<V, 4> unit_w;
|
|
|
|
Vec ( void ) = default;
|
|
Vec ( const Vec& parOther ) : implem::VecBase<V>(parOther) { }
|
|
Vec ( const vector_type& parIn ) : implem::VecBase<V>(parIn) { }
|
|
explicit Vec ( const scalar_type parX ) : implem::VecBase<V>(parX) { }
|
|
Vec ( scalar_type parX, scalar_type parY, scalar_type parZ, scalar_type parW ) : implem::VecBase<V>(parX, parY, parZ, parW) { }
|
|
#if defined(VWR_WITH_IMPLICIT_CONVERSIONS)
|
|
template <typename V2> Vec ( const Vec<V2, dimensions>& parOther ) { implem::assign(*this, parOther); }
|
|
template <typename V2>
|
|
Vec& operator= ( const Vec<V2, dimensions>& parOther ) { return implem::assign(*this, parOther); }
|
|
#endif
|
|
|
|
Vec& operator= ( const Vec& parOther ) { return implem::assign_same_type(*this, parOther); }
|
|
Vec& operator= ( const vector_type& parOther ) { this->data() = parOther; return *this; }
|
|
};
|
|
|
|
template <typename V>
|
|
Vec<V> mk_vec ( const V& parVec );
|
|
|
|
template <typename V1, typename V2>
|
|
bool operator== ( const Vec<V1>& parLeft, const Vec<V2>& parRight );
|
|
template <typename V1, typename V2>
|
|
bool operator!= ( const Vec<V1>& parLeft, const Vec<V2>& parRight );
|
|
template <typename V1, typename V2>
|
|
bool operator< ( const Vec<V1>& parLeft, const Vec<V2>& parRight );
|
|
template <typename V1, typename V2>
|
|
bool operator> ( const Vec<V1>& parLeft, const Vec<V2>& parRight );
|
|
template <typename V1, typename V2>
|
|
bool operator<= ( const Vec<V1>& parLeft, const Vec<V2>& parRight );
|
|
template <typename V1, typename V2>
|
|
bool operator>= ( const Vec<V1>& parLeft, const Vec<V2>& parRight );
|
|
|
|
template <typename V>
|
|
bool operator== ( const Vec<V>& parLeft, const typename VectorWrapperInfo<V>::scalar_type& parRight );
|
|
template <typename V>
|
|
bool operator< ( const Vec<V>& parLeft, const typename VectorWrapperInfo<V>::scalar_type& parRight );
|
|
template <typename V>
|
|
Vec<V> operator- ( const Vec<V>& parVec );
|
|
|
|
template <typename V1, typename T>
|
|
bool operator> ( const Vec<V1>& parLeft, const T& parRight );
|
|
template <typename V1, typename T>
|
|
bool operator<= ( const Vec<V1>& parLeft, const T& parRight );
|
|
template <typename V1, typename T>
|
|
bool operator>= ( const Vec<V1>& parLeft, const T& parRight );
|
|
template <typename V1, typename T>
|
|
bool operator!= ( const Vec<V1>& parLeft, const T& parRight );
|
|
|
|
template <typename V1, typename V2>
|
|
Vec<typename std::common_type<V1, V2>::type> operator+ ( const Vec<V1>& parLeft, const Vec<V2>& parRight );
|
|
template <typename V1, typename V2>
|
|
Vec<typename std::common_type<V1, V2>::type> operator- ( const Vec<V1>& parLeft, const Vec<V2>& parRight );
|
|
template <typename V1, typename V2>
|
|
Vec<typename std::common_type<V1, V2>::type> operator* ( const Vec<V1>& parLeft, const Vec<V2>& parRight );
|
|
template <typename V1, typename V2>
|
|
Vec<typename std::common_type<V1, V2>::type> operator/ ( const Vec<V1>& parLeft, const Vec<V2>& parRight );
|
|
template <typename V1, typename V2>
|
|
Vec<typename std::common_type<V1, V2>::type> operator% ( const Vec<V1>& parLeft, const Vec<V2>& parRight );
|
|
|
|
template <typename V>
|
|
Vec<V> operator+ ( const Vec<V>& parLeft, const typename Vec<V>::scalar_type& parRight );
|
|
template <typename V>
|
|
Vec<V> operator- ( const Vec<V>& parLeft, const typename Vec<V>::scalar_type& parRight );
|
|
template <typename V>
|
|
Vec<V> operator* ( const Vec<V>& parLeft, const typename Vec<V>::scalar_type& parRight );
|
|
template <typename V>
|
|
Vec<V> operator/ ( const Vec<V>& parLeft, const typename Vec<V>::scalar_type& parRight );
|
|
template <typename V>
|
|
Vec<V> operator% ( const Vec<V>& parLeft, const typename Vec<V>::scalar_type& parRight );
|
|
template <typename V>
|
|
Vec<V> operator+ ( const typename Vec<V>::scalar_type& parLeft, const Vec<V>& parRight );
|
|
template <typename V>
|
|
Vec<V> operator- ( const typename Vec<V>::scalar_type& parLeft, const Vec<V>& parRight );
|
|
template <typename V>
|
|
Vec<V> operator* ( const typename Vec<V>::scalar_type& parLeft, const Vec<V>& parRight );
|
|
template <typename V>
|
|
Vec<V> operator/ ( const typename Vec<V>::scalar_type& parLeft, const Vec<V>& parRight );
|
|
template <typename V>
|
|
Vec<V> operator% ( const typename Vec<V>::scalar_type& parLeft, const Vec<V>& parRight );
|
|
} //namespace vwr
|
|
|
|
#if defined VWR_OUTER_NAMESPACE
|
|
} //namespace VWR_OUTER_NAMESPACE
|
|
#endif
|
|
|
|
#include "vectorwrapper/vectorwrapper.inl"
|