1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
|
// <dwu/operators> -*- C++ -*-
//
// Copyright (c) 2019 Wolfgang 'datenwolf' Draxinger
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
#pragma once
#ifndef DWU__OPERATORS__
#define DWU__OPERATORS__ 1
#include <algorithm>
#include <utility>
namespace dwu { namespace operators {
#define DWU_OPERATOR(O) \
template<template<typename,typename> class C, typename Tl, typename A, typename Tr> \
C<Tl,A> operator O (C<Tl,A> const&l, Tr const &r) { \
C<Tl,A> v(l.size()); \
auto vi = v.begin(); auto li = l.begin(); \
while( vi != v.end() ){ \
*vi++ = *li++ O r; \
} \
return std::move(v); \
} \
template<template<typename,typename> class C, typename Tl, typename A, typename Tr> \
C<Tr,A> operator O (Tl const &l, C<Tr,A> const &r) { \
C<Tr,A> v(r.size()); \
auto vi = v.begin(); auto ri = r.begin(); \
while( vi != v.end() ){ \
*vi++ = l O *ri++; \
} \
return std::move(v); \
} \
template<template<typename,typename> class Cl, template<typename,typename> class Cr, typename Tl, typename Al, typename Tr, typename Ar> \
Cl<Tl,Al> operator O (Cl<Tl,Al> const &l, Cr<Tr,Ar> const &r) { \
Cl<Tl,Al> v( std::min(l.size(), r.size()) ); \
auto vi = v.begin(); auto li = l.begin(); auto ri = r.begin(); \
while( vi != v.end() ){ \
*vi++ = *li++ O *ri++; \
} \
return std::move(v); \
} \
template<template<typename,typename> class C, typename Tl, typename A, typename Tr> \
C<Tl,A>& operator O##= (C<Tl,A> &l, Tr const& r){ \
for(auto &x:l){ x O##= r; } \
return l; \
} \
template<template<typename,typename> class Cl, template<typename,typename> class Cr, typename Tl, typename Al, typename Tr, typename Ar> \
Cl<Tl,Al>& operator O##= (Cl<Tl,Al> &l, Cr<Tr,Ar> const& r){ \
auto li = l.begin(); auto ri = r.begin(); \
while( li != l.end() && ri != r.end() ){ \
*li++ O##= *ri++; \
} \
return l; \
}
DWU_OPERATOR(+)
DWU_OPERATOR(-)
DWU_OPERATOR(*)
DWU_OPERATOR(/)
DWU_OPERATOR(%)
DWU_OPERATOR(^)
DWU_OPERATOR(&)
DWU_OPERATOR(|)
} }
#endif/*DWU__OPERATORS__*/
|
