vector_vml.cpp

Go to the documentation of this file.

// this code is generated by gen_vector_vml.sh
#include "../../../include/monolish_vml.hpp"
#include "../../internal/monolish_internal.hpp"
#include "./arithmetic/vecadd.hpp"
#include "./arithmetic/vecdiv.hpp"
#include "./arithmetic/vecmul.hpp"
#include "./arithmetic/vecsub.hpp"
#include "./math_1_3op/vecmax.hpp"
#include "./math_1_3op/vecmin.hpp"
#include "./math_1_3op/vecpow.hpp"
#include "./math_2op/vecasin.hpp"
#include "./math_2op/vecasinh.hpp"
#include "./math_2op/vecatan.hpp"
#include "./math_2op/vecatanh.hpp"
#include "./math_2op/vecceil.hpp"
#include "./math_2op/vecfloor.hpp"
#include "./math_2op/vecreciprocal.hpp"
#include "./math_2op/vecsign.hpp"
#include "./math_2op/vecsin.hpp"
#include "./math_2op/vecsinh.hpp"
#include "./math_2op/vecsqrt.hpp"
#include "./math_2op/vectan.hpp"
#include "./math_2op/vectanh.hpp"
 
namespace monolish {
namespace vml {
 
void add(const vector<double> &a, const vector<double> &b, vector<double> &y) {
  vvadd_core(a, b, y);
}
void add(const vector<double> &a, const vector<double> &b,
         view1D<vector<double>, double> &y) {
  vvadd_core(a, b, y);
}
void add(const vector<double> &a, const vector<double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvadd_core(a, b, y);
}
void add(const vector<double> &a, const view1D<vector<double>, double> &b,
         vector<double> &y) {
  vvadd_core(a, b, y);
}
void add(const vector<double> &a, const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvadd_core(a, b, y);
}
void add(const vector<double> &a, const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvadd_core(a, b, y);
}
void add(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvadd_core(a, b, y);
}
void add(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvadd_core(a, b, y);
}
void add(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<vector<double>, double> &a, const vector<double> &b,
         vector<double> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<vector<double>, double> &a, const vector<double> &b,
         view1D<vector<double>, double> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<vector<double>, double> &a, const vector<double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b, vector<double> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, vector<double> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, view1D<vector<double>, double> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, view1D<matrix::Dense<double>, double> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b, vector<double> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvadd_core(a, b, y);
}
void add(const vector<float> &a, const vector<float> &b, vector<float> &y) {
  vvadd_core(a, b, y);
}
void add(const vector<float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvadd_core(a, b, y);
}
void add(const vector<float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvadd_core(a, b, y);
}
void add(const vector<float> &a, const view1D<vector<float>, float> &b,
         vector<float> &y) {
  vvadd_core(a, b, y);
}
void add(const vector<float> &a, const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvadd_core(a, b, y);
}
void add(const vector<float> &a, const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvadd_core(a, b, y);
}
void add(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         vector<float> &y) {
  vvadd_core(a, b, y);
}
void add(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvadd_core(a, b, y);
}
void add(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<vector<float>, float> &a, const vector<float> &b,
         vector<float> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<vector<float>, float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<vector<float>, float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b, vector<float> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b, vector<float> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         vector<float> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b, vector<float> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b, vector<float> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvadd_core(a, b, y);
}
void add(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvadd_core(a, b, y);
}
void sub(const vector<double> &a, const vector<double> &b, vector<double> &y) {
  vvsub_core(a, b, y);
}
void sub(const vector<double> &a, const vector<double> &b,
         view1D<vector<double>, double> &y) {
  vvsub_core(a, b, y);
}
void sub(const vector<double> &a, const vector<double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvsub_core(a, b, y);
}
void sub(const vector<double> &a, const view1D<vector<double>, double> &b,
         vector<double> &y) {
  vvsub_core(a, b, y);
}
void sub(const vector<double> &a, const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvsub_core(a, b, y);
}
void sub(const vector<double> &a, const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvsub_core(a, b, y);
}
void sub(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvsub_core(a, b, y);
}
void sub(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvsub_core(a, b, y);
}
void sub(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<vector<double>, double> &a, const vector<double> &b,
         vector<double> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<vector<double>, double> &a, const vector<double> &b,
         view1D<vector<double>, double> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<vector<double>, double> &a, const vector<double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b, vector<double> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, vector<double> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, view1D<vector<double>, double> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, view1D<matrix::Dense<double>, double> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b, vector<double> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvsub_core(a, b, y);
}
void sub(const vector<float> &a, const vector<float> &b, vector<float> &y) {
  vvsub_core(a, b, y);
}
void sub(const vector<float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvsub_core(a, b, y);
}
void sub(const vector<float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvsub_core(a, b, y);
}
void sub(const vector<float> &a, const view1D<vector<float>, float> &b,
         vector<float> &y) {
  vvsub_core(a, b, y);
}
void sub(const vector<float> &a, const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvsub_core(a, b, y);
}
void sub(const vector<float> &a, const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvsub_core(a, b, y);
}
void sub(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         vector<float> &y) {
  vvsub_core(a, b, y);
}
void sub(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvsub_core(a, b, y);
}
void sub(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<vector<float>, float> &a, const vector<float> &b,
         vector<float> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<vector<float>, float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<vector<float>, float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b, vector<float> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b, vector<float> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         vector<float> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b, vector<float> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b, vector<float> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvsub_core(a, b, y);
}
void sub(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvsub_core(a, b, y);
}
void mul(const vector<double> &a, const vector<double> &b, vector<double> &y) {
  vvmul_core(a, b, y);
}
void mul(const vector<double> &a, const vector<double> &b,
         view1D<vector<double>, double> &y) {
  vvmul_core(a, b, y);
}
void mul(const vector<double> &a, const vector<double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmul_core(a, b, y);
}
void mul(const vector<double> &a, const view1D<vector<double>, double> &b,
         vector<double> &y) {
  vvmul_core(a, b, y);
}
void mul(const vector<double> &a, const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvmul_core(a, b, y);
}
void mul(const vector<double> &a, const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmul_core(a, b, y);
}
void mul(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvmul_core(a, b, y);
}
void mul(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvmul_core(a, b, y);
}
void mul(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<vector<double>, double> &a, const vector<double> &b,
         vector<double> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<vector<double>, double> &a, const vector<double> &b,
         view1D<vector<double>, double> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<vector<double>, double> &a, const vector<double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b, vector<double> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, vector<double> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, view1D<vector<double>, double> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, view1D<matrix::Dense<double>, double> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b, vector<double> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmul_core(a, b, y);
}
void mul(const vector<float> &a, const vector<float> &b, vector<float> &y) {
  vvmul_core(a, b, y);
}
void mul(const vector<float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvmul_core(a, b, y);
}
void mul(const vector<float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmul_core(a, b, y);
}
void mul(const vector<float> &a, const view1D<vector<float>, float> &b,
         vector<float> &y) {
  vvmul_core(a, b, y);
}
void mul(const vector<float> &a, const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvmul_core(a, b, y);
}
void mul(const vector<float> &a, const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmul_core(a, b, y);
}
void mul(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         vector<float> &y) {
  vvmul_core(a, b, y);
}
void mul(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvmul_core(a, b, y);
}
void mul(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<vector<float>, float> &a, const vector<float> &b,
         vector<float> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<vector<float>, float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<vector<float>, float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b, vector<float> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b, vector<float> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         vector<float> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b, vector<float> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b, vector<float> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvmul_core(a, b, y);
}
void mul(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmul_core(a, b, y);
}
void div(const vector<double> &a, const vector<double> &b, vector<double> &y) {
  vvdiv_core(a, b, y);
}
void div(const vector<double> &a, const vector<double> &b,
         view1D<vector<double>, double> &y) {
  vvdiv_core(a, b, y);
}
void div(const vector<double> &a, const vector<double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvdiv_core(a, b, y);
}
void div(const vector<double> &a, const view1D<vector<double>, double> &b,
         vector<double> &y) {
  vvdiv_core(a, b, y);
}
void div(const vector<double> &a, const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvdiv_core(a, b, y);
}
void div(const vector<double> &a, const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvdiv_core(a, b, y);
}
void div(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvdiv_core(a, b, y);
}
void div(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvdiv_core(a, b, y);
}
void div(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<vector<double>, double> &a, const vector<double> &b,
         vector<double> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<vector<double>, double> &a, const vector<double> &b,
         view1D<vector<double>, double> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<vector<double>, double> &a, const vector<double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b, vector<double> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, vector<double> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, view1D<vector<double>, double> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, view1D<matrix::Dense<double>, double> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b, vector<double> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvdiv_core(a, b, y);
}
void div(const vector<float> &a, const vector<float> &b, vector<float> &y) {
  vvdiv_core(a, b, y);
}
void div(const vector<float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvdiv_core(a, b, y);
}
void div(const vector<float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvdiv_core(a, b, y);
}
void div(const vector<float> &a, const view1D<vector<float>, float> &b,
         vector<float> &y) {
  vvdiv_core(a, b, y);
}
void div(const vector<float> &a, const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvdiv_core(a, b, y);
}
void div(const vector<float> &a, const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvdiv_core(a, b, y);
}
void div(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         vector<float> &y) {
  vvdiv_core(a, b, y);
}
void div(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvdiv_core(a, b, y);
}
void div(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<vector<float>, float> &a, const vector<float> &b,
         vector<float> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<vector<float>, float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<vector<float>, float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b, vector<float> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b, vector<float> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         vector<float> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b, vector<float> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b, vector<float> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvdiv_core(a, b, y);
}
void div(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvdiv_core(a, b, y);
}
 
void add(const vector<double> &a, const double alpha, vector<double> &y) {
  svadd_core(a, alpha, y);
}
void add(const vector<double> &a, const double alpha,
         view1D<vector<double>, double> &y) {
  svadd_core(a, alpha, y);
}
void add(const vector<double> &a, const double alpha,
         view1D<matrix::Dense<double>, double> &y) {
  svadd_core(a, alpha, y);
}
void add(const view1D<vector<double>, double> &a, const double alpha,
         vector<double> &y) {
  svadd_core(a, alpha, y);
}
void add(const view1D<vector<double>, double> &a, const double alpha,
         view1D<vector<double>, double> &y) {
  svadd_core(a, alpha, y);
}
void add(const view1D<vector<double>, double> &a, const double alpha,
         view1D<matrix::Dense<double>, double> &y) {
  svadd_core(a, alpha, y);
}
void add(const view1D<matrix::Dense<double>, double> &a, const double alpha,
         vector<double> &y) {
  svadd_core(a, alpha, y);
}
void add(const view1D<matrix::Dense<double>, double> &a, const double alpha,
         view1D<vector<double>, double> &y) {
  svadd_core(a, alpha, y);
}
void add(const view1D<matrix::Dense<double>, double> &a, const double alpha,
         view1D<matrix::Dense<double>, double> &y) {
  svadd_core(a, alpha, y);
}
void add(const vector<float> &a, const float alpha, vector<float> &y) {
  svadd_core(a, alpha, y);
}
void add(const vector<float> &a, const float alpha,
         view1D<vector<float>, float> &y) {
  svadd_core(a, alpha, y);
}
void add(const vector<float> &a, const float alpha,
         view1D<matrix::Dense<float>, float> &y) {
  svadd_core(a, alpha, y);
}
void add(const view1D<vector<float>, float> &a, const float alpha,
         vector<float> &y) {
  svadd_core(a, alpha, y);
}
void add(const view1D<vector<float>, float> &a, const float alpha,
         view1D<vector<float>, float> &y) {
  svadd_core(a, alpha, y);
}
void add(const view1D<vector<float>, float> &a, const float alpha,
         view1D<matrix::Dense<float>, float> &y) {
  svadd_core(a, alpha, y);
}
void add(const view1D<matrix::Dense<float>, float> &a, const float alpha,
         vector<float> &y) {
  svadd_core(a, alpha, y);
}
void add(const view1D<matrix::Dense<float>, float> &a, const float alpha,
         view1D<vector<float>, float> &y) {
  svadd_core(a, alpha, y);
}
void add(const view1D<matrix::Dense<float>, float> &a, const float alpha,
         view1D<matrix::Dense<float>, float> &y) {
  svadd_core(a, alpha, y);
}
void sub(const vector<double> &a, const double alpha, vector<double> &y) {
  svsub_core(a, alpha, y);
}
void sub(const vector<double> &a, const double alpha,
         view1D<vector<double>, double> &y) {
  svsub_core(a, alpha, y);
}
void sub(const vector<double> &a, const double alpha,
         view1D<matrix::Dense<double>, double> &y) {
  svsub_core(a, alpha, y);
}
void sub(const view1D<vector<double>, double> &a, const double alpha,
         vector<double> &y) {
  svsub_core(a, alpha, y);
}
void sub(const view1D<vector<double>, double> &a, const double alpha,
         view1D<vector<double>, double> &y) {
  svsub_core(a, alpha, y);
}
void sub(const view1D<vector<double>, double> &a, const double alpha,
         view1D<matrix::Dense<double>, double> &y) {
  svsub_core(a, alpha, y);
}
void sub(const view1D<matrix::Dense<double>, double> &a, const double alpha,
         vector<double> &y) {
  svsub_core(a, alpha, y);
}
void sub(const view1D<matrix::Dense<double>, double> &a, const double alpha,
         view1D<vector<double>, double> &y) {
  svsub_core(a, alpha, y);
}
void sub(const view1D<matrix::Dense<double>, double> &a, const double alpha,
         view1D<matrix::Dense<double>, double> &y) {
  svsub_core(a, alpha, y);
}
void sub(const vector<float> &a, const float alpha, vector<float> &y) {
  svsub_core(a, alpha, y);
}
void sub(const vector<float> &a, const float alpha,
         view1D<vector<float>, float> &y) {
  svsub_core(a, alpha, y);
}
void sub(const vector<float> &a, const float alpha,
         view1D<matrix::Dense<float>, float> &y) {
  svsub_core(a, alpha, y);
}
void sub(const view1D<vector<float>, float> &a, const float alpha,
         vector<float> &y) {
  svsub_core(a, alpha, y);
}
void sub(const view1D<vector<float>, float> &a, const float alpha,
         view1D<vector<float>, float> &y) {
  svsub_core(a, alpha, y);
}
void sub(const view1D<vector<float>, float> &a, const float alpha,
         view1D<matrix::Dense<float>, float> &y) {
  svsub_core(a, alpha, y);
}
void sub(const view1D<matrix::Dense<float>, float> &a, const float alpha,
         vector<float> &y) {
  svsub_core(a, alpha, y);
}
void sub(const view1D<matrix::Dense<float>, float> &a, const float alpha,
         view1D<vector<float>, float> &y) {
  svsub_core(a, alpha, y);
}
void sub(const view1D<matrix::Dense<float>, float> &a, const float alpha,
         view1D<matrix::Dense<float>, float> &y) {
  svsub_core(a, alpha, y);
}
void mul(const vector<double> &a, const double alpha, vector<double> &y) {
  svmul_core(a, alpha, y);
}
void mul(const vector<double> &a, const double alpha,
         view1D<vector<double>, double> &y) {
  svmul_core(a, alpha, y);
}
void mul(const vector<double> &a, const double alpha,
         view1D<matrix::Dense<double>, double> &y) {
  svmul_core(a, alpha, y);
}
void mul(const view1D<vector<double>, double> &a, const double alpha,
         vector<double> &y) {
  svmul_core(a, alpha, y);
}
void mul(const view1D<vector<double>, double> &a, const double alpha,
         view1D<vector<double>, double> &y) {
  svmul_core(a, alpha, y);
}
void mul(const view1D<vector<double>, double> &a, const double alpha,
         view1D<matrix::Dense<double>, double> &y) {
  svmul_core(a, alpha, y);
}
void mul(const view1D<matrix::Dense<double>, double> &a, const double alpha,
         vector<double> &y) {
  svmul_core(a, alpha, y);
}
void mul(const view1D<matrix::Dense<double>, double> &a, const double alpha,
         view1D<vector<double>, double> &y) {
  svmul_core(a, alpha, y);
}
void mul(const view1D<matrix::Dense<double>, double> &a, const double alpha,
         view1D<matrix::Dense<double>, double> &y) {
  svmul_core(a, alpha, y);
}
void mul(const vector<float> &a, const float alpha, vector<float> &y) {
  svmul_core(a, alpha, y);
}
void mul(const vector<float> &a, const float alpha,
         view1D<vector<float>, float> &y) {
  svmul_core(a, alpha, y);
}
void mul(const vector<float> &a, const float alpha,
         view1D<matrix::Dense<float>, float> &y) {
  svmul_core(a, alpha, y);
}
void mul(const view1D<vector<float>, float> &a, const float alpha,
         vector<float> &y) {
  svmul_core(a, alpha, y);
}
void mul(const view1D<vector<float>, float> &a, const float alpha,
         view1D<vector<float>, float> &y) {
  svmul_core(a, alpha, y);
}
void mul(const view1D<vector<float>, float> &a, const float alpha,
         view1D<matrix::Dense<float>, float> &y) {
  svmul_core(a, alpha, y);
}
void mul(const view1D<matrix::Dense<float>, float> &a, const float alpha,
         vector<float> &y) {
  svmul_core(a, alpha, y);
}
void mul(const view1D<matrix::Dense<float>, float> &a, const float alpha,
         view1D<vector<float>, float> &y) {
  svmul_core(a, alpha, y);
}
void mul(const view1D<matrix::Dense<float>, float> &a, const float alpha,
         view1D<matrix::Dense<float>, float> &y) {
  svmul_core(a, alpha, y);
}
void div(const vector<double> &a, const double alpha, vector<double> &y) {
  svdiv_core(a, alpha, y);
}
void div(const vector<double> &a, const double alpha,
         view1D<vector<double>, double> &y) {
  svdiv_core(a, alpha, y);
}
void div(const vector<double> &a, const double alpha,
         view1D<matrix::Dense<double>, double> &y) {
  svdiv_core(a, alpha, y);
}
void div(const view1D<vector<double>, double> &a, const double alpha,
         vector<double> &y) {
  svdiv_core(a, alpha, y);
}
void div(const view1D<vector<double>, double> &a, const double alpha,
         view1D<vector<double>, double> &y) {
  svdiv_core(a, alpha, y);
}
void div(const view1D<vector<double>, double> &a, const double alpha,
         view1D<matrix::Dense<double>, double> &y) {
  svdiv_core(a, alpha, y);
}
void div(const view1D<matrix::Dense<double>, double> &a, const double alpha,
         vector<double> &y) {
  svdiv_core(a, alpha, y);
}
void div(const view1D<matrix::Dense<double>, double> &a, const double alpha,
         view1D<vector<double>, double> &y) {
  svdiv_core(a, alpha, y);
}
void div(const view1D<matrix::Dense<double>, double> &a, const double alpha,
         view1D<matrix::Dense<double>, double> &y) {
  svdiv_core(a, alpha, y);
}
void div(const vector<float> &a, const float alpha, vector<float> &y) {
  svdiv_core(a, alpha, y);
}
void div(const vector<float> &a, const float alpha,
         view1D<vector<float>, float> &y) {
  svdiv_core(a, alpha, y);
}
void div(const vector<float> &a, const float alpha,
         view1D<matrix::Dense<float>, float> &y) {
  svdiv_core(a, alpha, y);
}
void div(const view1D<vector<float>, float> &a, const float alpha,
         vector<float> &y) {
  svdiv_core(a, alpha, y);
}
void div(const view1D<vector<float>, float> &a, const float alpha,
         view1D<vector<float>, float> &y) {
  svdiv_core(a, alpha, y);
}
void div(const view1D<vector<float>, float> &a, const float alpha,
         view1D<matrix::Dense<float>, float> &y) {
  svdiv_core(a, alpha, y);
}
void div(const view1D<matrix::Dense<float>, float> &a, const float alpha,
         vector<float> &y) {
  svdiv_core(a, alpha, y);
}
void div(const view1D<matrix::Dense<float>, float> &a, const float alpha,
         view1D<vector<float>, float> &y) {
  svdiv_core(a, alpha, y);
}
void div(const view1D<matrix::Dense<float>, float> &a, const float alpha,
         view1D<matrix::Dense<float>, float> &y) {
  svdiv_core(a, alpha, y);
}
 
void pow(const vector<double> &a, const vector<double> &b, vector<double> &y) {
  vvpow_core(a, b, y);
}
void pow(const vector<double> &a, const vector<double> &b,
         view1D<vector<double>, double> &y) {
  vvpow_core(a, b, y);
}
void pow(const vector<double> &a, const vector<double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvpow_core(a, b, y);
}
void pow(const vector<double> &a, const view1D<vector<double>, double> &b,
         vector<double> &y) {
  vvpow_core(a, b, y);
}
void pow(const vector<double> &a, const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvpow_core(a, b, y);
}
void pow(const vector<double> &a, const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvpow_core(a, b, y);
}
void pow(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvpow_core(a, b, y);
}
void pow(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvpow_core(a, b, y);
}
void pow(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<vector<double>, double> &a, const vector<double> &b,
         vector<double> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<vector<double>, double> &a, const vector<double> &b,
         view1D<vector<double>, double> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<vector<double>, double> &a, const vector<double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b, vector<double> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, vector<double> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, view1D<vector<double>, double> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, view1D<matrix::Dense<double>, double> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b, vector<double> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvpow_core(a, b, y);
}
void pow(const vector<float> &a, const vector<float> &b, vector<float> &y) {
  vvpow_core(a, b, y);
}
void pow(const vector<float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvpow_core(a, b, y);
}
void pow(const vector<float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvpow_core(a, b, y);
}
void pow(const vector<float> &a, const view1D<vector<float>, float> &b,
         vector<float> &y) {
  vvpow_core(a, b, y);
}
void pow(const vector<float> &a, const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvpow_core(a, b, y);
}
void pow(const vector<float> &a, const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvpow_core(a, b, y);
}
void pow(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         vector<float> &y) {
  vvpow_core(a, b, y);
}
void pow(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvpow_core(a, b, y);
}
void pow(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<vector<float>, float> &a, const vector<float> &b,
         vector<float> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<vector<float>, float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<vector<float>, float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b, vector<float> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b, vector<float> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         vector<float> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b, vector<float> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b, vector<float> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvpow_core(a, b, y);
}
void pow(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvpow_core(a, b, y);
}
 
void pow(const vector<double> &a, const double alpha, vector<double> &y) {
  svpow_core(a, alpha, y);
}
void pow(const vector<double> &a, const double alpha,
         view1D<vector<double>, double> &y) {
  svpow_core(a, alpha, y);
}
void pow(const vector<double> &a, const double alpha,
         view1D<matrix::Dense<double>, double> &y) {
  svpow_core(a, alpha, y);
}
void pow(const view1D<vector<double>, double> &a, const double alpha,
         vector<double> &y) {
  svpow_core(a, alpha, y);
}
void pow(const view1D<vector<double>, double> &a, const double alpha,
         view1D<vector<double>, double> &y) {
  svpow_core(a, alpha, y);
}
void pow(const view1D<vector<double>, double> &a, const double alpha,
         view1D<matrix::Dense<double>, double> &y) {
  svpow_core(a, alpha, y);
}
void pow(const view1D<matrix::Dense<double>, double> &a, const double alpha,
         vector<double> &y) {
  svpow_core(a, alpha, y);
}
void pow(const view1D<matrix::Dense<double>, double> &a, const double alpha,
         view1D<vector<double>, double> &y) {
  svpow_core(a, alpha, y);
}
void pow(const view1D<matrix::Dense<double>, double> &a, const double alpha,
         view1D<matrix::Dense<double>, double> &y) {
  svpow_core(a, alpha, y);
}
void pow(const vector<float> &a, const float alpha, vector<float> &y) {
  svpow_core(a, alpha, y);
}
void pow(const vector<float> &a, const float alpha,
         view1D<vector<float>, float> &y) {
  svpow_core(a, alpha, y);
}
void pow(const vector<float> &a, const float alpha,
         view1D<matrix::Dense<float>, float> &y) {
  svpow_core(a, alpha, y);
}
void pow(const view1D<vector<float>, float> &a, const float alpha,
         vector<float> &y) {
  svpow_core(a, alpha, y);
}
void pow(const view1D<vector<float>, float> &a, const float alpha,
         view1D<vector<float>, float> &y) {
  svpow_core(a, alpha, y);
}
void pow(const view1D<vector<float>, float> &a, const float alpha,
         view1D<matrix::Dense<float>, float> &y) {
  svpow_core(a, alpha, y);
}
void pow(const view1D<matrix::Dense<float>, float> &a, const float alpha,
         vector<float> &y) {
  svpow_core(a, alpha, y);
}
void pow(const view1D<matrix::Dense<float>, float> &a, const float alpha,
         view1D<vector<float>, float> &y) {
  svpow_core(a, alpha, y);
}
void pow(const view1D<matrix::Dense<float>, float> &a, const float alpha,
         view1D<matrix::Dense<float>, float> &y) {
  svpow_core(a, alpha, y);
}
 
void sin(const vector<double> &a, vector<double> &y) { vsin_core(a, y); }
void sin(const vector<double> &a, view1D<vector<double>, double> &y) {
  vsin_core(a, y);
}
void sin(const vector<double> &a, view1D<matrix::Dense<double>, double> &y) {
  vsin_core(a, y);
}
void sin(const view1D<vector<double>, double> &a, vector<double> &y) {
  vsin_core(a, y);
}
void sin(const view1D<vector<double>, double> &a,
         view1D<vector<double>, double> &y) {
  vsin_core(a, y);
}
void sin(const view1D<vector<double>, double> &a,
         view1D<matrix::Dense<double>, double> &y) {
  vsin_core(a, y);
}
void sin(const view1D<matrix::Dense<double>, double> &a, vector<double> &y) {
  vsin_core(a, y);
}
void sin(const view1D<matrix::Dense<double>, double> &a,
         view1D<vector<double>, double> &y) {
  vsin_core(a, y);
}
void sin(const view1D<matrix::Dense<double>, double> &a,
         view1D<matrix::Dense<double>, double> &y) {
  vsin_core(a, y);
}
void sin(const vector<float> &a, vector<float> &y) { vsin_core(a, y); }
void sin(const vector<float> &a, view1D<vector<float>, float> &y) {
  vsin_core(a, y);
}
void sin(const vector<float> &a, view1D<matrix::Dense<float>, float> &y) {
  vsin_core(a, y);
}
void sin(const view1D<vector<float>, float> &a, vector<float> &y) {
  vsin_core(a, y);
}
void sin(const view1D<vector<float>, float> &a,
         view1D<vector<float>, float> &y) {
  vsin_core(a, y);
}
void sin(const view1D<vector<float>, float> &a,
         view1D<matrix::Dense<float>, float> &y) {
  vsin_core(a, y);
}
void sin(const view1D<matrix::Dense<float>, float> &a, vector<float> &y) {
  vsin_core(a, y);
}
void sin(const view1D<matrix::Dense<float>, float> &a,
         view1D<vector<float>, float> &y) {
  vsin_core(a, y);
}
void sin(const view1D<matrix::Dense<float>, float> &a,
         view1D<matrix::Dense<float>, float> &y) {
  vsin_core(a, y);
}
void sqrt(const vector<double> &a, vector<double> &y) { vsqrt_core(a, y); }
void sqrt(const vector<double> &a, view1D<vector<double>, double> &y) {
  vsqrt_core(a, y);
}
void sqrt(const vector<double> &a, view1D<matrix::Dense<double>, double> &y) {
  vsqrt_core(a, y);
}
void sqrt(const view1D<vector<double>, double> &a, vector<double> &y) {
  vsqrt_core(a, y);
}
void sqrt(const view1D<vector<double>, double> &a,
          view1D<vector<double>, double> &y) {
  vsqrt_core(a, y);
}
void sqrt(const view1D<vector<double>, double> &a,
          view1D<matrix::Dense<double>, double> &y) {
  vsqrt_core(a, y);
}
void sqrt(const view1D<matrix::Dense<double>, double> &a, vector<double> &y) {
  vsqrt_core(a, y);
}
void sqrt(const view1D<matrix::Dense<double>, double> &a,
          view1D<vector<double>, double> &y) {
  vsqrt_core(a, y);
}
void sqrt(const view1D<matrix::Dense<double>, double> &a,
          view1D<matrix::Dense<double>, double> &y) {
  vsqrt_core(a, y);
}
void sqrt(const vector<float> &a, vector<float> &y) { vsqrt_core(a, y); }
void sqrt(const vector<float> &a, view1D<vector<float>, float> &y) {
  vsqrt_core(a, y);
}
void sqrt(const vector<float> &a, view1D<matrix::Dense<float>, float> &y) {
  vsqrt_core(a, y);
}
void sqrt(const view1D<vector<float>, float> &a, vector<float> &y) {
  vsqrt_core(a, y);
}
void sqrt(const view1D<vector<float>, float> &a,
          view1D<vector<float>, float> &y) {
  vsqrt_core(a, y);
}
void sqrt(const view1D<vector<float>, float> &a,
          view1D<matrix::Dense<float>, float> &y) {
  vsqrt_core(a, y);
}
void sqrt(const view1D<matrix::Dense<float>, float> &a, vector<float> &y) {
  vsqrt_core(a, y);
}
void sqrt(const view1D<matrix::Dense<float>, float> &a,
          view1D<vector<float>, float> &y) {
  vsqrt_core(a, y);
}
void sqrt(const view1D<matrix::Dense<float>, float> &a,
          view1D<matrix::Dense<float>, float> &y) {
  vsqrt_core(a, y);
}
void sinh(const vector<double> &a, vector<double> &y) { vsinh_core(a, y); }
void sinh(const vector<double> &a, view1D<vector<double>, double> &y) {
  vsinh_core(a, y);
}
void sinh(const vector<double> &a, view1D<matrix::Dense<double>, double> &y) {
  vsinh_core(a, y);
}
void sinh(const view1D<vector<double>, double> &a, vector<double> &y) {
  vsinh_core(a, y);
}
void sinh(const view1D<vector<double>, double> &a,
          view1D<vector<double>, double> &y) {
  vsinh_core(a, y);
}
void sinh(const view1D<vector<double>, double> &a,
          view1D<matrix::Dense<double>, double> &y) {
  vsinh_core(a, y);
}
void sinh(const view1D<matrix::Dense<double>, double> &a, vector<double> &y) {
  vsinh_core(a, y);
}
void sinh(const view1D<matrix::Dense<double>, double> &a,
          view1D<vector<double>, double> &y) {
  vsinh_core(a, y);
}
void sinh(const view1D<matrix::Dense<double>, double> &a,
          view1D<matrix::Dense<double>, double> &y) {
  vsinh_core(a, y);
}
void sinh(const vector<float> &a, vector<float> &y) { vsinh_core(a, y); }
void sinh(const vector<float> &a, view1D<vector<float>, float> &y) {
  vsinh_core(a, y);
}
void sinh(const vector<float> &a, view1D<matrix::Dense<float>, float> &y) {
  vsinh_core(a, y);
}
void sinh(const view1D<vector<float>, float> &a, vector<float> &y) {
  vsinh_core(a, y);
}
void sinh(const view1D<vector<float>, float> &a,
          view1D<vector<float>, float> &y) {
  vsinh_core(a, y);
}
void sinh(const view1D<vector<float>, float> &a,
          view1D<matrix::Dense<float>, float> &y) {
  vsinh_core(a, y);
}
void sinh(const view1D<matrix::Dense<float>, float> &a, vector<float> &y) {
  vsinh_core(a, y);
}
void sinh(const view1D<matrix::Dense<float>, float> &a,
          view1D<vector<float>, float> &y) {
  vsinh_core(a, y);
}
void sinh(const view1D<matrix::Dense<float>, float> &a,
          view1D<matrix::Dense<float>, float> &y) {
  vsinh_core(a, y);
}
void asin(const vector<double> &a, vector<double> &y) { vasin_core(a, y); }
void asin(const vector<double> &a, view1D<vector<double>, double> &y) {
  vasin_core(a, y);
}
void asin(const vector<double> &a, view1D<matrix::Dense<double>, double> &y) {
  vasin_core(a, y);
}
void asin(const view1D<vector<double>, double> &a, vector<double> &y) {
  vasin_core(a, y);
}
void asin(const view1D<vector<double>, double> &a,
          view1D<vector<double>, double> &y) {
  vasin_core(a, y);
}
void asin(const view1D<vector<double>, double> &a,
          view1D<matrix::Dense<double>, double> &y) {
  vasin_core(a, y);
}
void asin(const view1D<matrix::Dense<double>, double> &a, vector<double> &y) {
  vasin_core(a, y);
}
void asin(const view1D<matrix::Dense<double>, double> &a,
          view1D<vector<double>, double> &y) {
  vasin_core(a, y);
}
void asin(const view1D<matrix::Dense<double>, double> &a,
          view1D<matrix::Dense<double>, double> &y) {
  vasin_core(a, y);
}
void asin(const vector<float> &a, vector<float> &y) { vasin_core(a, y); }
void asin(const vector<float> &a, view1D<vector<float>, float> &y) {
  vasin_core(a, y);
}
void asin(const vector<float> &a, view1D<matrix::Dense<float>, float> &y) {
  vasin_core(a, y);
}
void asin(const view1D<vector<float>, float> &a, vector<float> &y) {
  vasin_core(a, y);
}
void asin(const view1D<vector<float>, float> &a,
          view1D<vector<float>, float> &y) {
  vasin_core(a, y);
}
void asin(const view1D<vector<float>, float> &a,
          view1D<matrix::Dense<float>, float> &y) {
  vasin_core(a, y);
}
void asin(const view1D<matrix::Dense<float>, float> &a, vector<float> &y) {
  vasin_core(a, y);
}
void asin(const view1D<matrix::Dense<float>, float> &a,
          view1D<vector<float>, float> &y) {
  vasin_core(a, y);
}
void asin(const view1D<matrix::Dense<float>, float> &a,
          view1D<matrix::Dense<float>, float> &y) {
  vasin_core(a, y);
}
void asinh(const vector<double> &a, vector<double> &y) { vasinh_core(a, y); }
void asinh(const vector<double> &a, view1D<vector<double>, double> &y) {
  vasinh_core(a, y);
}
void asinh(const vector<double> &a, view1D<matrix::Dense<double>, double> &y) {
  vasinh_core(a, y);
}
void asinh(const view1D<vector<double>, double> &a, vector<double> &y) {
  vasinh_core(a, y);
}
void asinh(const view1D<vector<double>, double> &a,
           view1D<vector<double>, double> &y) {
  vasinh_core(a, y);
}
void asinh(const view1D<vector<double>, double> &a,
           view1D<matrix::Dense<double>, double> &y) {
  vasinh_core(a, y);
}
void asinh(const view1D<matrix::Dense<double>, double> &a, vector<double> &y) {
  vasinh_core(a, y);
}
void asinh(const view1D<matrix::Dense<double>, double> &a,
           view1D<vector<double>, double> &y) {
  vasinh_core(a, y);
}
void asinh(const view1D<matrix::Dense<double>, double> &a,
           view1D<matrix::Dense<double>, double> &y) {
  vasinh_core(a, y);
}
void asinh(const vector<float> &a, vector<float> &y) { vasinh_core(a, y); }
void asinh(const vector<float> &a, view1D<vector<float>, float> &y) {
  vasinh_core(a, y);
}
void asinh(const vector<float> &a, view1D<matrix::Dense<float>, float> &y) {
  vasinh_core(a, y);
}
void asinh(const view1D<vector<float>, float> &a, vector<float> &y) {
  vasinh_core(a, y);
}
void asinh(const view1D<vector<float>, float> &a,
           view1D<vector<float>, float> &y) {
  vasinh_core(a, y);
}
void asinh(const view1D<vector<float>, float> &a,
           view1D<matrix::Dense<float>, float> &y) {
  vasinh_core(a, y);
}
void asinh(const view1D<matrix::Dense<float>, float> &a, vector<float> &y) {
  vasinh_core(a, y);
}
void asinh(const view1D<matrix::Dense<float>, float> &a,
           view1D<vector<float>, float> &y) {
  vasinh_core(a, y);
}
void asinh(const view1D<matrix::Dense<float>, float> &a,
           view1D<matrix::Dense<float>, float> &y) {
  vasinh_core(a, y);
}
void tan(const vector<double> &a, vector<double> &y) { vtan_core(a, y); }
void tan(const vector<double> &a, view1D<vector<double>, double> &y) {
  vtan_core(a, y);
}
void tan(const vector<double> &a, view1D<matrix::Dense<double>, double> &y) {
  vtan_core(a, y);
}
void tan(const view1D<vector<double>, double> &a, vector<double> &y) {
  vtan_core(a, y);
}
void tan(const view1D<vector<double>, double> &a,
         view1D<vector<double>, double> &y) {
  vtan_core(a, y);
}
void tan(const view1D<vector<double>, double> &a,
         view1D<matrix::Dense<double>, double> &y) {
  vtan_core(a, y);
}
void tan(const view1D<matrix::Dense<double>, double> &a, vector<double> &y) {
  vtan_core(a, y);
}
void tan(const view1D<matrix::Dense<double>, double> &a,
         view1D<vector<double>, double> &y) {
  vtan_core(a, y);
}
void tan(const view1D<matrix::Dense<double>, double> &a,
         view1D<matrix::Dense<double>, double> &y) {
  vtan_core(a, y);
}
void tan(const vector<float> &a, vector<float> &y) { vtan_core(a, y); }
void tan(const vector<float> &a, view1D<vector<float>, float> &y) {
  vtan_core(a, y);
}
void tan(const vector<float> &a, view1D<matrix::Dense<float>, float> &y) {
  vtan_core(a, y);
}
void tan(const view1D<vector<float>, float> &a, vector<float> &y) {
  vtan_core(a, y);
}
void tan(const view1D<vector<float>, float> &a,
         view1D<vector<float>, float> &y) {
  vtan_core(a, y);
}
void tan(const view1D<vector<float>, float> &a,
         view1D<matrix::Dense<float>, float> &y) {
  vtan_core(a, y);
}
void tan(const view1D<matrix::Dense<float>, float> &a, vector<float> &y) {
  vtan_core(a, y);
}
void tan(const view1D<matrix::Dense<float>, float> &a,
         view1D<vector<float>, float> &y) {
  vtan_core(a, y);
}
void tan(const view1D<matrix::Dense<float>, float> &a,
         view1D<matrix::Dense<float>, float> &y) {
  vtan_core(a, y);
}
void tanh(const vector<double> &a, vector<double> &y) { vtanh_core(a, y); }
void tanh(const vector<double> &a, view1D<vector<double>, double> &y) {
  vtanh_core(a, y);
}
void tanh(const vector<double> &a, view1D<matrix::Dense<double>, double> &y) {
  vtanh_core(a, y);
}
void tanh(const view1D<vector<double>, double> &a, vector<double> &y) {
  vtanh_core(a, y);
}
void tanh(const view1D<vector<double>, double> &a,
          view1D<vector<double>, double> &y) {
  vtanh_core(a, y);
}
void tanh(const view1D<vector<double>, double> &a,
          view1D<matrix::Dense<double>, double> &y) {
  vtanh_core(a, y);
}
void tanh(const view1D<matrix::Dense<double>, double> &a, vector<double> &y) {
  vtanh_core(a, y);
}
void tanh(const view1D<matrix::Dense<double>, double> &a,
          view1D<vector<double>, double> &y) {
  vtanh_core(a, y);
}
void tanh(const view1D<matrix::Dense<double>, double> &a,
          view1D<matrix::Dense<double>, double> &y) {
  vtanh_core(a, y);
}
void tanh(const vector<float> &a, vector<float> &y) { vtanh_core(a, y); }
void tanh(const vector<float> &a, view1D<vector<float>, float> &y) {
  vtanh_core(a, y);
}
void tanh(const vector<float> &a, view1D<matrix::Dense<float>, float> &y) {
  vtanh_core(a, y);
}
void tanh(const view1D<vector<float>, float> &a, vector<float> &y) {
  vtanh_core(a, y);
}
void tanh(const view1D<vector<float>, float> &a,
          view1D<vector<float>, float> &y) {
  vtanh_core(a, y);
}
void tanh(const view1D<vector<float>, float> &a,
          view1D<matrix::Dense<float>, float> &y) {
  vtanh_core(a, y);
}
void tanh(const view1D<matrix::Dense<float>, float> &a, vector<float> &y) {
  vtanh_core(a, y);
}
void tanh(const view1D<matrix::Dense<float>, float> &a,
          view1D<vector<float>, float> &y) {
  vtanh_core(a, y);
}
void tanh(const view1D<matrix::Dense<float>, float> &a,
          view1D<matrix::Dense<float>, float> &y) {
  vtanh_core(a, y);
}
void atan(const vector<double> &a, vector<double> &y) { vatan_core(a, y); }
void atan(const vector<double> &a, view1D<vector<double>, double> &y) {
  vatan_core(a, y);
}
void atan(const vector<double> &a, view1D<matrix::Dense<double>, double> &y) {
  vatan_core(a, y);
}
void atan(const view1D<vector<double>, double> &a, vector<double> &y) {
  vatan_core(a, y);
}
void atan(const view1D<vector<double>, double> &a,
          view1D<vector<double>, double> &y) {
  vatan_core(a, y);
}
void atan(const view1D<vector<double>, double> &a,
          view1D<matrix::Dense<double>, double> &y) {
  vatan_core(a, y);
}
void atan(const view1D<matrix::Dense<double>, double> &a, vector<double> &y) {
  vatan_core(a, y);
}
void atan(const view1D<matrix::Dense<double>, double> &a,
          view1D<vector<double>, double> &y) {
  vatan_core(a, y);
}
void atan(const view1D<matrix::Dense<double>, double> &a,
          view1D<matrix::Dense<double>, double> &y) {
  vatan_core(a, y);
}
void atan(const vector<float> &a, vector<float> &y) { vatan_core(a, y); }
void atan(const vector<float> &a, view1D<vector<float>, float> &y) {
  vatan_core(a, y);
}
void atan(const vector<float> &a, view1D<matrix::Dense<float>, float> &y) {
  vatan_core(a, y);
}
void atan(const view1D<vector<float>, float> &a, vector<float> &y) {
  vatan_core(a, y);
}
void atan(const view1D<vector<float>, float> &a,
          view1D<vector<float>, float> &y) {
  vatan_core(a, y);
}
void atan(const view1D<vector<float>, float> &a,
          view1D<matrix::Dense<float>, float> &y) {
  vatan_core(a, y);
}
void atan(const view1D<matrix::Dense<float>, float> &a, vector<float> &y) {
  vatan_core(a, y);
}
void atan(const view1D<matrix::Dense<float>, float> &a,
          view1D<vector<float>, float> &y) {
  vatan_core(a, y);
}
void atan(const view1D<matrix::Dense<float>, float> &a,
          view1D<matrix::Dense<float>, float> &y) {
  vatan_core(a, y);
}
void atanh(const vector<double> &a, vector<double> &y) { vatanh_core(a, y); }
void atanh(const vector<double> &a, view1D<vector<double>, double> &y) {
  vatanh_core(a, y);
}
void atanh(const vector<double> &a, view1D<matrix::Dense<double>, double> &y) {
  vatanh_core(a, y);
}
void atanh(const view1D<vector<double>, double> &a, vector<double> &y) {
  vatanh_core(a, y);
}
void atanh(const view1D<vector<double>, double> &a,
           view1D<vector<double>, double> &y) {
  vatanh_core(a, y);
}
void atanh(const view1D<vector<double>, double> &a,
           view1D<matrix::Dense<double>, double> &y) {
  vatanh_core(a, y);
}
void atanh(const view1D<matrix::Dense<double>, double> &a, vector<double> &y) {
  vatanh_core(a, y);
}
void atanh(const view1D<matrix::Dense<double>, double> &a,
           view1D<vector<double>, double> &y) {
  vatanh_core(a, y);
}
void atanh(const view1D<matrix::Dense<double>, double> &a,
           view1D<matrix::Dense<double>, double> &y) {
  vatanh_core(a, y);
}
void atanh(const vector<float> &a, vector<float> &y) { vatanh_core(a, y); }
void atanh(const vector<float> &a, view1D<vector<float>, float> &y) {
  vatanh_core(a, y);
}
void atanh(const vector<float> &a, view1D<matrix::Dense<float>, float> &y) {
  vatanh_core(a, y);
}
void atanh(const view1D<vector<float>, float> &a, vector<float> &y) {
  vatanh_core(a, y);
}
void atanh(const view1D<vector<float>, float> &a,
           view1D<vector<float>, float> &y) {
  vatanh_core(a, y);
}
void atanh(const view1D<vector<float>, float> &a,
           view1D<matrix::Dense<float>, float> &y) {
  vatanh_core(a, y);
}
void atanh(const view1D<matrix::Dense<float>, float> &a, vector<float> &y) {
  vatanh_core(a, y);
}
void atanh(const view1D<matrix::Dense<float>, float> &a,
           view1D<vector<float>, float> &y) {
  vatanh_core(a, y);
}
void atanh(const view1D<matrix::Dense<float>, float> &a,
           view1D<matrix::Dense<float>, float> &y) {
  vatanh_core(a, y);
}
void ceil(const vector<double> &a, vector<double> &y) { vceil_core(a, y); }
void ceil(const vector<double> &a, view1D<vector<double>, double> &y) {
  vceil_core(a, y);
}
void ceil(const vector<double> &a, view1D<matrix::Dense<double>, double> &y) {
  vceil_core(a, y);
}
void ceil(const view1D<vector<double>, double> &a, vector<double> &y) {
  vceil_core(a, y);
}
void ceil(const view1D<vector<double>, double> &a,
          view1D<vector<double>, double> &y) {
  vceil_core(a, y);
}
void ceil(const view1D<vector<double>, double> &a,
          view1D<matrix::Dense<double>, double> &y) {
  vceil_core(a, y);
}
void ceil(const view1D<matrix::Dense<double>, double> &a, vector<double> &y) {
  vceil_core(a, y);
}
void ceil(const view1D<matrix::Dense<double>, double> &a,
          view1D<vector<double>, double> &y) {
  vceil_core(a, y);
}
void ceil(const view1D<matrix::Dense<double>, double> &a,
          view1D<matrix::Dense<double>, double> &y) {
  vceil_core(a, y);
}
void ceil(const vector<float> &a, vector<float> &y) { vceil_core(a, y); }
void ceil(const vector<float> &a, view1D<vector<float>, float> &y) {
  vceil_core(a, y);
}
void ceil(const vector<float> &a, view1D<matrix::Dense<float>, float> &y) {
  vceil_core(a, y);
}
void ceil(const view1D<vector<float>, float> &a, vector<float> &y) {
  vceil_core(a, y);
}
void ceil(const view1D<vector<float>, float> &a,
          view1D<vector<float>, float> &y) {
  vceil_core(a, y);
}
void ceil(const view1D<vector<float>, float> &a,
          view1D<matrix::Dense<float>, float> &y) {
  vceil_core(a, y);
}
void ceil(const view1D<matrix::Dense<float>, float> &a, vector<float> &y) {
  vceil_core(a, y);
}
void ceil(const view1D<matrix::Dense<float>, float> &a,
          view1D<vector<float>, float> &y) {
  vceil_core(a, y);
}
void ceil(const view1D<matrix::Dense<float>, float> &a,
          view1D<matrix::Dense<float>, float> &y) {
  vceil_core(a, y);
}
void floor(const vector<double> &a, vector<double> &y) { vfloor_core(a, y); }
void floor(const vector<double> &a, view1D<vector<double>, double> &y) {
  vfloor_core(a, y);
}
void floor(const vector<double> &a, view1D<matrix::Dense<double>, double> &y) {
  vfloor_core(a, y);
}
void floor(const view1D<vector<double>, double> &a, vector<double> &y) {
  vfloor_core(a, y);
}
void floor(const view1D<vector<double>, double> &a,
           view1D<vector<double>, double> &y) {
  vfloor_core(a, y);
}
void floor(const view1D<vector<double>, double> &a,
           view1D<matrix::Dense<double>, double> &y) {
  vfloor_core(a, y);
}
void floor(const view1D<matrix::Dense<double>, double> &a, vector<double> &y) {
  vfloor_core(a, y);
}
void floor(const view1D<matrix::Dense<double>, double> &a,
           view1D<vector<double>, double> &y) {
  vfloor_core(a, y);
}
void floor(const view1D<matrix::Dense<double>, double> &a,
           view1D<matrix::Dense<double>, double> &y) {
  vfloor_core(a, y);
}
void floor(const vector<float> &a, vector<float> &y) { vfloor_core(a, y); }
void floor(const vector<float> &a, view1D<vector<float>, float> &y) {
  vfloor_core(a, y);
}
void floor(const vector<float> &a, view1D<matrix::Dense<float>, float> &y) {
  vfloor_core(a, y);
}
void floor(const view1D<vector<float>, float> &a, vector<float> &y) {
  vfloor_core(a, y);
}
void floor(const view1D<vector<float>, float> &a,
           view1D<vector<float>, float> &y) {
  vfloor_core(a, y);
}
void floor(const view1D<vector<float>, float> &a,
           view1D<matrix::Dense<float>, float> &y) {
  vfloor_core(a, y);
}
void floor(const view1D<matrix::Dense<float>, float> &a, vector<float> &y) {
  vfloor_core(a, y);
}
void floor(const view1D<matrix::Dense<float>, float> &a,
           view1D<vector<float>, float> &y) {
  vfloor_core(a, y);
}
void floor(const view1D<matrix::Dense<float>, float> &a,
           view1D<matrix::Dense<float>, float> &y) {
  vfloor_core(a, y);
}
void sign(const vector<double> &a, vector<double> &y) { vsign_core(a, y); }
void sign(const vector<double> &a, view1D<vector<double>, double> &y) {
  vsign_core(a, y);
}
void sign(const vector<double> &a, view1D<matrix::Dense<double>, double> &y) {
  vsign_core(a, y);
}
void sign(const view1D<vector<double>, double> &a, vector<double> &y) {
  vsign_core(a, y);
}
void sign(const view1D<vector<double>, double> &a,
          view1D<vector<double>, double> &y) {
  vsign_core(a, y);
}
void sign(const view1D<vector<double>, double> &a,
          view1D<matrix::Dense<double>, double> &y) {
  vsign_core(a, y);
}
void sign(const view1D<matrix::Dense<double>, double> &a, vector<double> &y) {
  vsign_core(a, y);
}
void sign(const view1D<matrix::Dense<double>, double> &a,
          view1D<vector<double>, double> &y) {
  vsign_core(a, y);
}
void sign(const view1D<matrix::Dense<double>, double> &a,
          view1D<matrix::Dense<double>, double> &y) {
  vsign_core(a, y);
}
void sign(const vector<float> &a, vector<float> &y) { vsign_core(a, y); }
void sign(const vector<float> &a, view1D<vector<float>, float> &y) {
  vsign_core(a, y);
}
void sign(const vector<float> &a, view1D<matrix::Dense<float>, float> &y) {
  vsign_core(a, y);
}
void sign(const view1D<vector<float>, float> &a, vector<float> &y) {
  vsign_core(a, y);
}
void sign(const view1D<vector<float>, float> &a,
          view1D<vector<float>, float> &y) {
  vsign_core(a, y);
}
void sign(const view1D<vector<float>, float> &a,
          view1D<matrix::Dense<float>, float> &y) {
  vsign_core(a, y);
}
void sign(const view1D<matrix::Dense<float>, float> &a, vector<float> &y) {
  vsign_core(a, y);
}
void sign(const view1D<matrix::Dense<float>, float> &a,
          view1D<vector<float>, float> &y) {
  vsign_core(a, y);
}
void sign(const view1D<matrix::Dense<float>, float> &a,
          view1D<matrix::Dense<float>, float> &y) {
  vsign_core(a, y);
}
void reciprocal(const vector<double> &a, vector<double> &y) {
  vreciprocal_core(a, y);
}
void reciprocal(const vector<double> &a, view1D<vector<double>, double> &y) {
  vreciprocal_core(a, y);
}
void reciprocal(const vector<double> &a,
                view1D<matrix::Dense<double>, double> &y) {
  vreciprocal_core(a, y);
}
void reciprocal(const view1D<vector<double>, double> &a, vector<double> &y) {
  vreciprocal_core(a, y);
}
void reciprocal(const view1D<vector<double>, double> &a,
                view1D<vector<double>, double> &y) {
  vreciprocal_core(a, y);
}
void reciprocal(const view1D<vector<double>, double> &a,
                view1D<matrix::Dense<double>, double> &y) {
  vreciprocal_core(a, y);
}
void reciprocal(const view1D<matrix::Dense<double>, double> &a,
                vector<double> &y) {
  vreciprocal_core(a, y);
}
void reciprocal(const view1D<matrix::Dense<double>, double> &a,
                view1D<vector<double>, double> &y) {
  vreciprocal_core(a, y);
}
void reciprocal(const view1D<matrix::Dense<double>, double> &a,
                view1D<matrix::Dense<double>, double> &y) {
  vreciprocal_core(a, y);
}
void reciprocal(const vector<float> &a, vector<float> &y) {
  vreciprocal_core(a, y);
}
void reciprocal(const vector<float> &a, view1D<vector<float>, float> &y) {
  vreciprocal_core(a, y);
}
void reciprocal(const vector<float> &a,
                view1D<matrix::Dense<float>, float> &y) {
  vreciprocal_core(a, y);
}
void reciprocal(const view1D<vector<float>, float> &a, vector<float> &y) {
  vreciprocal_core(a, y);
}
void reciprocal(const view1D<vector<float>, float> &a,
                view1D<vector<float>, float> &y) {
  vreciprocal_core(a, y);
}
void reciprocal(const view1D<vector<float>, float> &a,
                view1D<matrix::Dense<float>, float> &y) {
  vreciprocal_core(a, y);
}
void reciprocal(const view1D<matrix::Dense<float>, float> &a,
                vector<float> &y) {
  vreciprocal_core(a, y);
}
void reciprocal(const view1D<matrix::Dense<float>, float> &a,
                view1D<vector<float>, float> &y) {
  vreciprocal_core(a, y);
}
void reciprocal(const view1D<matrix::Dense<float>, float> &a,
                view1D<matrix::Dense<float>, float> &y) {
  vreciprocal_core(a, y);
}
 
void max(const vector<double> &a, const vector<double> &b, vector<double> &y) {
  vvmax_core(a, b, y);
}
void max(const vector<double> &a, const vector<double> &b,
         view1D<vector<double>, double> &y) {
  vvmax_core(a, b, y);
}
void max(const vector<double> &a, const vector<double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmax_core(a, b, y);
}
void max(const vector<double> &a, const view1D<vector<double>, double> &b,
         vector<double> &y) {
  vvmax_core(a, b, y);
}
void max(const vector<double> &a, const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvmax_core(a, b, y);
}
void max(const vector<double> &a, const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmax_core(a, b, y);
}
void max(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvmax_core(a, b, y);
}
void max(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvmax_core(a, b, y);
}
void max(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<vector<double>, double> &a, const vector<double> &b,
         vector<double> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<vector<double>, double> &a, const vector<double> &b,
         view1D<vector<double>, double> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<vector<double>, double> &a, const vector<double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b, vector<double> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, vector<double> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, view1D<vector<double>, double> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, view1D<matrix::Dense<double>, double> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b, vector<double> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmax_core(a, b, y);
}
void max(const vector<float> &a, const vector<float> &b, vector<float> &y) {
  vvmax_core(a, b, y);
}
void max(const vector<float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvmax_core(a, b, y);
}
void max(const vector<float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmax_core(a, b, y);
}
void max(const vector<float> &a, const view1D<vector<float>, float> &b,
         vector<float> &y) {
  vvmax_core(a, b, y);
}
void max(const vector<float> &a, const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvmax_core(a, b, y);
}
void max(const vector<float> &a, const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmax_core(a, b, y);
}
void max(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         vector<float> &y) {
  vvmax_core(a, b, y);
}
void max(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvmax_core(a, b, y);
}
void max(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<vector<float>, float> &a, const vector<float> &b,
         vector<float> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<vector<float>, float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<vector<float>, float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b, vector<float> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b, vector<float> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         vector<float> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b, vector<float> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b, vector<float> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvmax_core(a, b, y);
}
void max(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmax_core(a, b, y);
}
void min(const vector<double> &a, const vector<double> &b, vector<double> &y) {
  vvmin_core(a, b, y);
}
void min(const vector<double> &a, const vector<double> &b,
         view1D<vector<double>, double> &y) {
  vvmin_core(a, b, y);
}
void min(const vector<double> &a, const vector<double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmin_core(a, b, y);
}
void min(const vector<double> &a, const view1D<vector<double>, double> &b,
         vector<double> &y) {
  vvmin_core(a, b, y);
}
void min(const vector<double> &a, const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvmin_core(a, b, y);
}
void min(const vector<double> &a, const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmin_core(a, b, y);
}
void min(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvmin_core(a, b, y);
}
void min(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvmin_core(a, b, y);
}
void min(const vector<double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<vector<double>, double> &a, const vector<double> &b,
         vector<double> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<vector<double>, double> &a, const vector<double> &b,
         view1D<vector<double>, double> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<vector<double>, double> &a, const vector<double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b, vector<double> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<vector<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<vector<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, vector<double> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, view1D<vector<double>, double> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<matrix::Dense<double>, double> &a,
         const vector<double> &b, view1D<matrix::Dense<double>, double> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b, vector<double> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<matrix::Dense<double>, double> &a,
         const view1D<vector<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b, vector<double> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<vector<double>, double> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<matrix::Dense<double>, double> &a,
         const view1D<matrix::Dense<double>, double> &b,
         view1D<matrix::Dense<double>, double> &y) {
  vvmin_core(a, b, y);
}
void min(const vector<float> &a, const vector<float> &b, vector<float> &y) {
  vvmin_core(a, b, y);
}
void min(const vector<float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvmin_core(a, b, y);
}
void min(const vector<float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmin_core(a, b, y);
}
void min(const vector<float> &a, const view1D<vector<float>, float> &b,
         vector<float> &y) {
  vvmin_core(a, b, y);
}
void min(const vector<float> &a, const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvmin_core(a, b, y);
}
void min(const vector<float> &a, const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmin_core(a, b, y);
}
void min(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         vector<float> &y) {
  vvmin_core(a, b, y);
}
void min(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvmin_core(a, b, y);
}
void min(const vector<float> &a, const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<vector<float>, float> &a, const vector<float> &b,
         vector<float> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<vector<float>, float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<vector<float>, float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b, vector<float> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<vector<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b, vector<float> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<vector<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         vector<float> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         view1D<vector<float>, float> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<matrix::Dense<float>, float> &a, const vector<float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b, vector<float> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<matrix::Dense<float>, float> &a,
         const view1D<vector<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b, vector<float> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<vector<float>, float> &y) {
  vvmin_core(a, b, y);
}
void min(const view1D<matrix::Dense<float>, float> &a,
         const view1D<matrix::Dense<float>, float> &b,
         view1D<matrix::Dense<float>, float> &y) {
  vvmin_core(a, b, y);
}
 
double max(const vector<double> &y) {
  return vmax_core<vector<double>, double>(y);
}
double max(const view1D<vector<double>, double> &y) {
  return vmax_core<view1D<vector<double>, double>, double>(y);
}
double max(const view1D<matrix::Dense<double>, double> &y) {
  return vmax_core<view1D<matrix::Dense<double>, double>, double>(y);
}
float max(const vector<float> &y) { return vmax_core<vector<float>, float>(y); }
float max(const view1D<vector<float>, float> &y) {
  return vmax_core<view1D<vector<float>, float>, float>(y);
}
float max(const view1D<matrix::Dense<float>, float> &y) {
  return vmax_core<view1D<matrix::Dense<float>, float>, float>(y);
}
double min(const vector<double> &y) {
  return vmin_core<vector<double>, double>(y);
}
double min(const view1D<vector<double>, double> &y) {
  return vmin_core<view1D<vector<double>, double>, double>(y);
}
double min(const view1D<matrix::Dense<double>, double> &y) {
  return vmin_core<view1D<matrix::Dense<double>, double>, double>(y);
}
float min(const vector<float> &y) { return vmin_core<vector<float>, float>(y); }
float min(const view1D<vector<float>, float> &y) {
  return vmin_core<view1D<vector<float>, float>, float>(y);
}
float min(const view1D<matrix::Dense<float>, float> &y) {
  return vmin_core<view1D<matrix::Dense<float>, float>, float>(y);
}
 
} // namespace vml
} // namespace monolish