extl/math/detail/vvector_expr.h

   1 /* ///////////////////////////////////////////////////////////////////////
   2  * File:                vvector_expr.h
   3  *
   4  * Created:             08.08.11
   5  * Updated:             09.01.27
   6  *
   7  * Brief:               the vvector_expr class
   8  *
   9  * [<Home>]
  10  * Copyright (c) 2008-2020, Waruqi All rights reserved.
  11  * //////////////////////////////////////////////////////////////////// */
  12
  13 #ifndef EXTL_MATH_DETAIL_VVECTOR_EXPR_H
  14 #define EXTL_MATH_DETAIL_VVECTOR_EXPR_H
  15
  16 /* ///////////////////////////////////////////////////////////////////////
  17  * Includes
  18  */
  19 #include "../prefix.h"
  20 #include "expr_op.h"
  21
  22 /* ///////////////////////////////////////////////////////////////////////
  23  * ::extl::detail namespace
  24  */
  25 EXTL_BEGIN_NAMESPACE
  26 EXTL_DETAIL_BEGIN_NAMESPACE
  27
  28 /* \brief vvector_expr
  29  *
  30  * \param T The value type
  31  * \param E The expression type: e.g. eop_add<eop_mul<...> ...> or eop_scalar<>
  32  *
  33  */
  34 template<       typename_param_k T
  35                 ,       typename_param_k E
  36                 >
  37 class vvector_expr
  38 {
  39         public:
  40                 typedef E                                                                                                                                       expr_type;
  41                 typedef vvector_expr                                                                                                                    class_type;
  42                 typedef typename_type_k expr_type::value_type                                                           value_type;
  43                 typedef typename_type_k expr_type::pointer                                                                      pointer;
  44                 typedef typename_type_k expr_type::const_pointer                                                        const_pointer;
  45                 typedef typename_type_k expr_type::reference                                                            reference;
  46                 typedef typename_type_k expr_type::const_reference                                                      const_reference;
  47                 typedef typename_type_k expr_type::size_type                                                            size_type;
  48                 typedef typename_type_k expr_type::bool_type                                                            bool_type;
  49                 typedef typename_type_k expr_type::difference_type                                                      difference_type;
  50                 typedef typename_type_k expr_type::int_type                                                                     int_type;
  51                 typedef typename_type_k expr_type::index_type                                                           index_type;
  52
  53         private:
  54                 expr_type                                                                                                                                       m_expr;
  55
  56         public:
  57                 explicit_k vvector_expr(expr_type const& expr)
  58                         : m_expr(expr)
  59                 {
  60                 }
  61
  62         public:
  63                 size_type                       size() const                                            { return m_expr.size(); }
  64
  65         public:
  66                 value_type                      operator [](index_type index) const     { return m_expr[index]; }
  67
  68         public:
  69                 expr_type&                      expr()                  { return m_expr;        }
  70                 expr_type const&        expr() const    { return m_expr;        }
  71 };
  72
  73 // expr + expr
  74 template<       typename_param_k T
  75                 ,       typename_param_k E1
  76                 ,       typename_param_k E2
  77                 >
  78 vvector_expr    <       T
  79                         ,       eop_add <T, E1, E2>
  80                         >
  81 operator +(vvector_expr<T, E1> const& expr1, vvector_expr<T, E2> const& expr2)
  82 {
  83         return vvector_expr     <       T
  84                                                 ,       eop_add <T, E1, E2>
  85                                                 >
  86                                                 (       eop_add <T, E1, E2>
  87                                                                         (       expr1.expr()
  88                                                                         ,       expr2.expr()
  89                                                                         )
  90                                                 );
  91 }
  92
  93 // expr - expr
  94 template<       typename_param_k T
  95                 ,       typename_param_k E1
  96                 ,       typename_param_k E2
  97                 >
  98 vvector_expr    <       T
  99                         ,       eop_sub <T, E1, E2>
 100                         >
 101 operator -(vvector_expr<T, E1> const& expr1, vvector_expr<T, E2> const& expr2)
 102 {
 103         return vvector_expr     <       T
 104                                                 ,       eop_sub <T, E1, E2>
 105                                                 >
 106                                                 (       eop_sub <T, E1, E2>
 107                                                                         (       expr1.expr()
 108                                                                         ,       expr2.expr()
 109                                                                         )
 110                                                 );
 111 }
 112
 113 #ifdef EXTL_MATH_EOP_SCALAR_SUPPORT
 114 // expr + value
 115 template<       typename_param_k T
 116                 ,       typename_param_k E1
 117                 >
 118 vvector_expr    <       T
 119                         ,       eop_add <       T
 120                                                 ,       E1
 121                                                 ,       eop_scalar<T>
 122                                                 >
 123                         >
 124 operator +(vvector_expr<T, E1> const& expr1, T const& value)
 125 {
 126         return vvector_expr     <       T
 127                                                 ,       eop_add <       T
 128                                                                         ,       E1
 129                                                                         ,       eop_scalar<T>
 130                                                                         >
 131                                                 >
 132                                                 (       eop_add <       T
 133                                                                         ,       E1
 134                                                                         ,       eop_scalar<T>
 135                                                                         >
 136                                                                         (       expr1.expr()
 137                                                                         ,       eop_scalar<T>(value) // temporary copy
 138                                                                         )
 139                                                 );
 140 }
 141 // value + expr
 142 template<       typename_param_k T
 143                 ,       typename_param_k E2
 144                 >
 145 vvector_expr    <       T
 146                         ,       eop_add <       T
 147                                                 ,       eop_scalar<T>
 148                                                 ,       E2
 149                                                 >
 150                         >
 151 operator +(T const& value, vvector_expr<T, E2> const& expr2)
 152 {
 153         return vvector_expr     <       T
 154                                                 ,       eop_add <       T
 155                                                                         ,       eop_scalar<T>
 156                                                                         ,       E2
 157                                                                         >
 158                                                 >
 159                                                 (       eop_add <       T
 160                                                                         ,       eop_scalar<T>
 161                                                                         ,       E2
 162                                                                         >
 163                                                                         (       eop_scalar<T>(value) // temporary copy
 164                                                                         ,       expr2.expr()
 165                                                                         )
 166                                                 );
 167 }
 168
 169 // expr - value
 170 template<       typename_param_k T
 171                 ,       typename_param_k E1
 172                 >
 173 vvector_expr    <       T
 174                         ,       eop_sub <       T
 175                                                 ,       E1
 176                                                 ,       eop_scalar<T>
 177                                                 >
 178                         >
 179 operator -(vvector_expr<T, E1> const& expr1, T const& value)
 180 {
 181         return vvector_expr     <       T
 182                                                 ,       eop_sub <       T
 183                                                                         ,       E1
 184                                                                         ,       eop_scalar<T>
 185                                                                         >
 186                                                 >
 187                                                 (       eop_sub <       T
 188                                                                         ,       E1
 189                                                                         ,       eop_scalar<T>
 190                                                                         >
 191                                                                         (       expr1.expr()
 192                                                                         ,       eop_scalar<T>(value) // temporary copy
 193                                                                         )
 194                                                 );
 195 }
 196 // value - expr
 197 template<       typename_param_k T
 198                 ,       typename_param_k E2
 199                 >
 200 vvector_expr    <       T
 201                         ,       eop_sub <       T
 202                                                 ,       eop_scalar<T>
 203                                                 ,       E2
 204                                                 >
 205                         >
 206 operator -(T const& value, vvector_expr<T, E2> const& expr2)
 207 {
 208         return vvector_expr     <       T
 209                                                 ,       eop_sub <       T
 210                                                                         ,       eop_scalar<T>
 211                                                                         ,       E2
 212                                                                         >
 213                                                 >
 214                                                 (       eop_sub <       T
 215                                                                         ,       eop_scalar<T>
 216                                                                         ,       E2
 217                                                                         >
 218                                                                         (       eop_scalar<T>(value) // temporary copy
 219                                                                         ,       expr2.expr()
 220                                                                         )
 221                                                 );
 222 }
 223
 224 // expr * value
 225 template<       typename_param_k T
 226                 ,       typename_param_k E1
 227                 >
 228 vvector_expr    <       T
 229                         ,       eop_mul <       T
 230                                                 ,       E1
 231                                                 ,       eop_scalar<T>
 232                                                 >
 233                         >
 234 operator *(vvector_expr<T, E1> const& expr1, T const& value)
 235 {
 236         return vvector_expr     <       T
 237                                                 ,       eop_mul <       T
 238                                                                         ,       E1
 239                                                                         ,       eop_scalar<T>
 240                                                                         >
 241                                                 >
 242                                                 (       eop_mul <       T
 243                                                                         ,       E1
 244                                                                         ,       eop_scalar<T>
 245                                                                         >
 246                                                                         (       expr1.expr()
 247                                                                         ,       eop_scalar<T>(value) // temporary copy
 248                                                                         )
 249                                                 );
 250 }
 251 // value * expr
 252 template<       typename_param_k T
 253                 ,       typename_param_k E2
 254                 >
 255 vvector_expr    <       T
 256                         ,       eop_mul <       T
 257                                                 ,       eop_scalar<T>
 258                                                 ,       E2
 259                                                 >
 260                         >
 261 operator *(T const& value, vvector_expr<T, E2> const& expr2)
 262 {
 263         return vvector_expr     <       T
 264                                                 ,       eop_mul <       T
 265                                                                         ,       eop_scalar<T>
 266                                                                         ,       E2
 267                                                                         >
 268                                                 >
 269                                                 (       eop_mul <       T
 270                                                                         ,       eop_scalar<T>
 271                                                                         ,       E2
 272                                                                         >
 273                                                                         (       eop_scalar<T>(value) // temporary copy
 274                                                                         ,       expr2.expr()
 275                                                                         )
 276                                                 );
 277 }
 278 // expr / value
 279 template<       typename_param_k T
 280                 ,       typename_param_k E1
 281                 >
 282 vvector_expr    <       T
 283                         ,       eop_div <       T
 284                                                 ,       E1
 285                                                 ,       eop_scalar<T>
 286                                                 >
 287                         >
 288 operator /(vvector_expr<T, E1> const& expr1, T const& value)
 289 {
 290         return vvector_expr     <       T
 291                                                 ,       eop_div <       T
 292                                                                         ,       E1
 293                                                                         ,       eop_scalar<T>
 294                                                                         >
 295                                                 >
 296                                                 (       eop_div <       T
 297                                                                         ,       E1
 298                                                                         ,       eop_scalar<T>
 299                                                                         >
 300                                                                         (       expr1.expr()
 301                                                                         ,       eop_scalar<T>(value) // temporary copy
 302                                                                         )
 303                                                 );
 304 }
 305 // value / expr
 306 template<       typename_param_k T
 307                 ,       typename_param_k E2
 308                 >
 309 vvector_expr    <       T
 310                         ,       eop_div <       T
 311                                                 ,       eop_scalar<T>
 312                                                 ,       E2
 313                                                 >
 314                         >
 315 operator /(T const& value, vvector_expr<T, E2> const& expr2)
 316 {
 317         return vvector_expr     <       T
 318                                                 ,       eop_div <       T
 319                                                                         ,       eop_scalar<T>
 320                                                                         ,       E2
 321                                                                         >
 322                                                 >
 323                                                 (       eop_div <       T
 324                                                                         ,       eop_scalar<T>
 325                                                                         ,       E2
 326                                                                         >
 327                                                                         (       eop_scalar<T>(value) // temporary copy
 328                                                                         ,       expr2.expr()
 329                                                                         )
 330                                                 );
 331 }
 332 #endif
 333 /* ///////////////////////////////////////////////////////////////////////
 334  * ::extl::detail namespace
 335  */
 336 EXTL_DETAIL_END_NAMESPACE
 337 EXTL_END_NAMESPACE
 338
 339 /* //////////////////////////////////////////////////////////////////// */
 340 #endif  /* EXTL_MATH_DETAIL_VVECTOR_EXPR_H */
 341 /* //////////////////////////////////////////////////////////////////// */