Vectorize.hpp

Go to the documentation of this file.

// Copyright (C) 2013-2015 Kasper Kristensen
// License: GPL-2

// Function body type declarations
// V=vector, T=scalar, I=integer, N=none
#define declareV(arg) const vector<Type> &arg
#define declareT(arg) Type arg
#define declareI(arg) int arg
#define declareN(arg)
// How to extract elementwise subset of the four types
#define elementV(arg,i) arg[i]
#define elementT(arg,i) arg
#define elementI(arg,i) arg
#define elementN(arg,i)
// How to place comma in front of the types
#define commaV ,
#define commaT ,
#define commaI ,
#define commaN
// Update output vector size
#define outputsizeV(n,arg) n = (arg.size()>n ? arg.size() : n)
#define outputsizeT(n,arg)
#define outputsizeI(n,arg)
#define outputsizeN(n,arg)

#define GVECTORIZE(FUN,Type1,Type2,Type3,Type4,Type5,Type6)             \
template <class Type>                                                   \
vector<Type> FUN( declare##Type1(arg1) comma##Type2                     \
                  declare##Type2(arg2) comma##Type3                     \
                  declare##Type3(arg3) comma##Type4                     \
                  declare##Type4(arg4) comma##Type5                     \
                  declare##Type5(arg5) comma##Type6                     \
                  declare##Type6(arg6) )                                \
{                                                                       \
  int n = 0;                                                            \
  outputsize##Type1(n,arg1);                                            \
  outputsize##Type2(n,arg2);                                            \
  outputsize##Type3(n,arg3);                                            \
  outputsize##Type4(n,arg4);                                            \
  outputsize##Type5(n,arg5);                                            \
  outputsize##Type6(n,arg6);                                            \
  vector<Type> res(n);                                                  \
  for(int i=0;i<n;i++) res[i] = FUN( element##Type1(arg1,i) comma##Type2 \
                                     element##Type2(arg2,i) comma##Type3 \
                                     element##Type3(arg3,i) comma##Type4 \
                                     element##Type4(arg4,i) comma##Type5 \
                                     element##Type5(arg5,i) comma##Type6 \
                                     element##Type6(arg6,i) );          \
  return res;                                                           \
}

#define VECTORIZE1_t(FUN)                       \
  GVECTORIZE(FUN,V,N,N,N,N,N)

#define VECTORIZE2_tt(FUN)                      \
  GVECTORIZE(FUN,V,T,N,N,N,N)                   \
  GVECTORIZE(FUN,T,V,N,N,N,N)                   \
  GVECTORIZE(FUN,V,V,N,N,N,N)

#define VECTORIZE3_tti(FUN)                     \
  GVECTORIZE(FUN,V,T,I,N,N,N)                   \
  GVECTORIZE(FUN,T,V,I,N,N,N)                   \
  GVECTORIZE(FUN,V,V,I,N,N,N)

#define VECTORIZE3_ttt(FUN)                     \
  GVECTORIZE(FUN,V,T,T,N,N,N)                   \
  GVECTORIZE(FUN,T,V,T,N,N,N)                   \
  GVECTORIZE(FUN,T,T,V,N,N,N)                   \
  GVECTORIZE(FUN,V,V,T,N,N,N)                   \
  GVECTORIZE(FUN,T,V,V,N,N,N)                   \
  GVECTORIZE(FUN,V,T,V,N,N,N)                   \
  GVECTORIZE(FUN,V,V,V,N,N,N)

#define VECTORIZE4_ttti(FUN)                    \
  GVECTORIZE(FUN,V,T,T,I,N,N)                   \
  GVECTORIZE(FUN,T,V,T,I,N,N)                   \
  GVECTORIZE(FUN,T,T,V,I,N,N)                   \
  GVECTORIZE(FUN,V,V,T,I,N,N)                   \
  GVECTORIZE(FUN,T,V,V,I,N,N)                   \
  GVECTORIZE(FUN,V,T,V,I,N,N)                   \
  GVECTORIZE(FUN,V,V,V,I,N,N)

#define VECTORIZE5_tttti(FUN)                   \
  GVECTORIZE(FUN,V,T,T,T,I,N)                   \
  GVECTORIZE(FUN,T,V,T,T,I,N)                   \
  GVECTORIZE(FUN,T,T,V,T,I,N)                   \
  GVECTORIZE(FUN,V,V,T,T,I,N)                   \
  GVECTORIZE(FUN,T,V,V,T,I,N)                   \
  GVECTORIZE(FUN,V,T,V,T,I,N)                   \
  GVECTORIZE(FUN,V,V,V,T,I,N)

#define VECTORIZE6_ttttti(FUN)                  \
  GVECTORIZE(FUN,V,T,T,T,T,I)                   \
  GVECTORIZE(FUN,T,V,T,T,T,I)                   \
  GVECTORIZE(FUN,T,T,V,T,T,I)                   \
  GVECTORIZE(FUN,V,V,T,T,T,I)                   \
  GVECTORIZE(FUN,T,V,V,T,T,I)                   \
  GVECTORIZE(FUN,V,T,V,T,T,I)                   \
  GVECTORIZE(FUN,V,V,V,T,T,I)

#define VECTORIZE1_n(FUN)                       \
template<class Type>                            \
vector<Type> FUN(int n, Type arg1) {            \
  vector<Type> ans(n);                          \
  for(int i=0; i<n; i++) ans(i) = FUN(arg1);    \
  return ans;                                   \
}

#define VECTORIZE2_n(FUN)                               \
template<class Type>                                    \
vector<Type> FUN(int n, Type arg1, Type arg2) {         \
  vector<Type> ans(n);                                  \
  for(int i=0; i<n; i++) ans(i) = FUN(arg1, arg2);      \
  return ans;                                           \
}

#define VECTORIZE3_n(FUN)                                       \
template<class Type>                                            \
vector<Type> FUN(int n, Type arg1, Type arg2, Type arg3) {      \
  vector<Type> ans(n);                                          \
  for(int i=0; i<n; i++) ans(i) = FUN(arg1, arg2, arg3);        \
  return ans;                                                   \
}

using CppAD::abs;
VECTORIZE1_t(abs)
VECTORIZE1_t(acos)
VECTORIZE1_t(asin)
VECTORIZE1_t(atan)
VECTORIZE1_t(cos)
VECTORIZE1_t(erf)
VECTORIZE1_t(exp)
VECTORIZE1_t(log)
VECTORIZE1_t(log10)
VECTORIZE1_t(sin)
VECTORIZE1_t(sqrt)
VECTORIZE2_tt(pow)