3 #include "../common/monolish_common.hpp" 
   28 void vecadd(
const vector<double> &a, 
const vector<double> &b,
 
   30 void vecadd(
const vector<double> &a, 
const vector<double> &b,
 
   31             view1D<vector<double>, 
double> &y);
 
   32 void vecadd(
const vector<double> &a, 
const vector<double> &b,
 
   33             view1D<matrix::Dense<double>, 
double> &y);
 
   34 void vecadd(
const vector<double> &a, 
const view1D<vector<double>, 
double> &b,
 
   36 void vecadd(
const vector<double> &a, 
const view1D<vector<double>, 
double> &b,
 
   37             view1D<vector<double>, 
double> &y);
 
   38 void vecadd(
const vector<double> &a, 
const view1D<vector<double>, 
double> &b,
 
   39             view1D<matrix::Dense<double>, 
double> &y);
 
   40 void vecadd(
const vector<double> &a,
 
   41             const view1D<matrix::Dense<double>, 
double> &b, vector<double> &y);
 
   42 void vecadd(
const vector<double> &a,
 
   43             const view1D<matrix::Dense<double>, 
double> &b,
 
   44             view1D<vector<double>, 
double> &y);
 
   45 void vecadd(
const vector<double> &a,
 
   46             const view1D<matrix::Dense<double>, 
double> &b,
 
   47             view1D<matrix::Dense<double>, 
double> &y);
 
   48 void vecadd(
const view1D<vector<double>, 
double> &a, 
const vector<double> &b,
 
   50 void vecadd(
const view1D<vector<double>, 
double> &a, 
const vector<double> &b,
 
   51             view1D<vector<double>, 
double> &y);
 
   52 void vecadd(
const view1D<vector<double>, 
double> &a, 
const vector<double> &b,
 
   53             view1D<matrix::Dense<double>, 
double> &y);
 
   54 void vecadd(
const view1D<vector<double>, 
double> &a,
 
   55             const view1D<vector<double>, 
double> &b, vector<double> &y);
 
   56 void vecadd(
const view1D<vector<double>, 
double> &a,
 
   57             const view1D<vector<double>, 
double> &b,
 
   58             view1D<vector<double>, 
double> &y);
 
   59 void vecadd(
const view1D<vector<double>, 
double> &a,
 
   60             const view1D<vector<double>, 
double> &b,
 
   61             view1D<matrix::Dense<double>, 
double> &y);
 
   62 void vecadd(
const view1D<vector<double>, 
double> &a,
 
   63             const view1D<matrix::Dense<double>, 
double> &b, vector<double> &y);
 
   64 void vecadd(
const view1D<vector<double>, 
double> &a,
 
   65             const view1D<matrix::Dense<double>, 
double> &b,
 
   66             view1D<vector<double>, 
double> &y);
 
   67 void vecadd(
const view1D<vector<double>, 
double> &a,
 
   68             const view1D<matrix::Dense<double>, 
double> &b,
 
   69             view1D<matrix::Dense<double>, 
double> &y);
 
   70 void vecadd(
const view1D<matrix::Dense<double>, 
double> &a,
 
   71             const vector<double> &b, vector<double> &y);
 
   72 void vecadd(
const view1D<matrix::Dense<double>, 
double> &a,
 
   73             const vector<double> &b, view1D<vector<double>, 
double> &y);
 
   74 void vecadd(
const view1D<matrix::Dense<double>, 
double> &a,
 
   75             const vector<double> &b, view1D<matrix::Dense<double>, 
double> &y);
 
   76 void vecadd(
const view1D<matrix::Dense<double>, 
double> &a,
 
   77             const view1D<vector<double>, 
double> &b, vector<double> &y);
 
   78 void vecadd(
const view1D<matrix::Dense<double>, 
double> &a,
 
   79             const view1D<vector<double>, 
double> &b,
 
   80             view1D<vector<double>, 
double> &y);
 
   81 void vecadd(
const view1D<matrix::Dense<double>, 
double> &a,
 
   82             const view1D<vector<double>, 
double> &b,
 
   83             view1D<matrix::Dense<double>, 
double> &y);
 
   84 void vecadd(
const view1D<matrix::Dense<double>, 
double> &a,
 
   85             const view1D<matrix::Dense<double>, 
double> &b, vector<double> &y);
 
   86 void vecadd(
const view1D<matrix::Dense<double>, 
double> &a,
 
   87             const view1D<matrix::Dense<double>, 
double> &b,
 
   88             view1D<vector<double>, 
double> &y);
 
   89 void vecadd(
const view1D<matrix::Dense<double>, 
double> &a,
 
   90             const view1D<matrix::Dense<double>, 
double> &b,
 
   91             view1D<matrix::Dense<double>, 
double> &y);
 
   92 void vecadd(
const vector<float> &a, 
const vector<float> &b, vector<float> &y);
 
   93 void vecadd(
const vector<float> &a, 
const vector<float> &b,
 
   94             view1D<vector<float>, 
float> &y);
 
   95 void vecadd(
const vector<float> &a, 
const vector<float> &b,
 
   96             view1D<matrix::Dense<float>, 
float> &y);
 
   97 void vecadd(
const vector<float> &a, 
const view1D<vector<float>, 
float> &b,
 
   99 void vecadd(
const vector<float> &a, 
const view1D<vector<float>, 
float> &b,
 
  100             view1D<vector<float>, 
float> &y);
 
  101 void vecadd(
const vector<float> &a, 
const view1D<vector<float>, 
float> &b,
 
  102             view1D<matrix::Dense<float>, 
float> &y);
 
  103 void vecadd(
const vector<float> &a,
 
  104             const view1D<matrix::Dense<float>, 
float> &b, vector<float> &y);
 
  105 void vecadd(
const vector<float> &a,
 
  106             const view1D<matrix::Dense<float>, 
float> &b,
 
  107             view1D<vector<float>, 
float> &y);
 
  108 void vecadd(
const vector<float> &a,
 
  109             const view1D<matrix::Dense<float>, 
float> &b,
 
  110             view1D<matrix::Dense<float>, 
float> &y);
 
  111 void vecadd(
const view1D<vector<float>, 
float> &a, 
const vector<float> &b,
 
  113 void vecadd(
const view1D<vector<float>, 
float> &a, 
const vector<float> &b,
 
  114             view1D<vector<float>, 
float> &y);
 
  115 void vecadd(
const view1D<vector<float>, 
float> &a, 
const vector<float> &b,
 
  116             view1D<matrix::Dense<float>, 
float> &y);
 
  117 void vecadd(
const view1D<vector<float>, 
float> &a,
 
  118             const view1D<vector<float>, 
float> &b, vector<float> &y);
 
  119 void vecadd(
const view1D<vector<float>, 
float> &a,
 
  120             const view1D<vector<float>, 
float> &b,
 
  121             view1D<vector<float>, 
float> &y);
 
  122 void vecadd(
const view1D<vector<float>, 
float> &a,
 
  123             const view1D<vector<float>, 
float> &b,
 
  124             view1D<matrix::Dense<float>, 
float> &y);
 
  125 void vecadd(
const view1D<vector<float>, 
float> &a,
 
  126             const view1D<matrix::Dense<float>, 
float> &b, vector<float> &y);
 
  127 void vecadd(
const view1D<vector<float>, 
float> &a,
 
  128             const view1D<matrix::Dense<float>, 
float> &b,
 
  129             view1D<vector<float>, 
float> &y);
 
  130 void vecadd(
const view1D<vector<float>, 
float> &a,
 
  131             const view1D<matrix::Dense<float>, 
float> &b,
 
  132             view1D<matrix::Dense<float>, 
float> &y);
 
  133 void vecadd(
const view1D<matrix::Dense<float>, 
float> &a,
 
  134             const vector<float> &b, vector<float> &y);
 
  135 void vecadd(
const view1D<matrix::Dense<float>, 
float> &a,
 
  136             const vector<float> &b, view1D<vector<float>, 
float> &y);
 
  137 void vecadd(
const view1D<matrix::Dense<float>, 
float> &a,
 
  138             const vector<float> &b, view1D<matrix::Dense<float>, 
float> &y);
 
  139 void vecadd(
const view1D<matrix::Dense<float>, 
float> &a,
 
  140             const view1D<vector<float>, 
float> &b, vector<float> &y);
 
  141 void vecadd(
const view1D<matrix::Dense<float>, 
float> &a,
 
  142             const view1D<vector<float>, 
float> &b,
 
  143             view1D<vector<float>, 
float> &y);
 
  144 void vecadd(
const view1D<matrix::Dense<float>, 
float> &a,
 
  145             const view1D<vector<float>, 
float> &b,
 
  146             view1D<matrix::Dense<float>, 
float> &y);
 
  147 void vecadd(
const view1D<matrix::Dense<float>, 
float> &a,
 
  148             const view1D<matrix::Dense<float>, 
float> &b, vector<float> &y);
 
  149 void vecadd(
const view1D<matrix::Dense<float>, 
float> &a,
 
  150             const view1D<matrix::Dense<float>, 
float> &b,
 
  151             view1D<vector<float>, 
float> &y);
 
  152 void vecadd(
const view1D<matrix::Dense<float>, 
float> &a,
 
  153             const view1D<matrix::Dense<float>, 
float> &b,
 
  154             view1D<matrix::Dense<float>, 
float> &y);
 
  167 void vecsub(
const vector<double> &a, 
const vector<double> &b,
 
  169 void vecsub(
const vector<double> &a, 
const vector<double> &b,
 
  170             view1D<vector<double>, 
double> &y);
 
  171 void vecsub(
const vector<double> &a, 
const vector<double> &b,
 
  172             view1D<matrix::Dense<double>, 
double> &y);
 
  173 void vecsub(
const vector<double> &a, 
const view1D<vector<double>, 
double> &b,
 
  175 void vecsub(
const vector<double> &a, 
const view1D<vector<double>, 
double> &b,
 
  176             view1D<vector<double>, 
double> &y);
 
  177 void vecsub(
const vector<double> &a, 
const view1D<vector<double>, 
double> &b,
 
  178             view1D<matrix::Dense<double>, 
double> &y);
 
  179 void vecsub(
const vector<double> &a,
 
  180             const view1D<matrix::Dense<double>, 
double> &b, vector<double> &y);
 
  181 void vecsub(
const vector<double> &a,
 
  182             const view1D<matrix::Dense<double>, 
double> &b,
 
  183             view1D<vector<double>, 
double> &y);
 
  184 void vecsub(
const vector<double> &a,
 
  185             const view1D<matrix::Dense<double>, 
double> &b,
 
  186             view1D<matrix::Dense<double>, 
double> &y);
 
  187 void vecsub(
const view1D<vector<double>, 
double> &a, 
const vector<double> &b,
 
  189 void vecsub(
const view1D<vector<double>, 
double> &a, 
const vector<double> &b,
 
  190             view1D<vector<double>, 
double> &y);
 
  191 void vecsub(
const view1D<vector<double>, 
double> &a, 
const vector<double> &b,
 
  192             view1D<matrix::Dense<double>, 
double> &y);
 
  193 void vecsub(
const view1D<vector<double>, 
double> &a,
 
  194             const view1D<vector<double>, 
double> &b, vector<double> &y);
 
  195 void vecsub(
const view1D<vector<double>, 
double> &a,
 
  196             const view1D<vector<double>, 
double> &b,
 
  197             view1D<vector<double>, 
double> &y);
 
  198 void vecsub(
const view1D<vector<double>, 
double> &a,
 
  199             const view1D<vector<double>, 
double> &b,
 
  200             view1D<matrix::Dense<double>, 
double> &y);
 
  201 void vecsub(
const view1D<vector<double>, 
double> &a,
 
  202             const view1D<matrix::Dense<double>, 
double> &b, vector<double> &y);
 
  203 void vecsub(
const view1D<vector<double>, 
double> &a,
 
  204             const view1D<matrix::Dense<double>, 
double> &b,
 
  205             view1D<vector<double>, 
double> &y);
 
  206 void vecsub(
const view1D<vector<double>, 
double> &a,
 
  207             const view1D<matrix::Dense<double>, 
double> &b,
 
  208             view1D<matrix::Dense<double>, 
double> &y);
 
  209 void vecsub(
const view1D<matrix::Dense<double>, 
double> &a,
 
  210             const vector<double> &b, vector<double> &y);
 
  211 void vecsub(
const view1D<matrix::Dense<double>, 
double> &a,
 
  212             const vector<double> &b, view1D<vector<double>, 
double> &y);
 
  213 void vecsub(
const view1D<matrix::Dense<double>, 
double> &a,
 
  214             const vector<double> &b, view1D<matrix::Dense<double>, 
double> &y);
 
  215 void vecsub(
const view1D<matrix::Dense<double>, 
double> &a,
 
  216             const view1D<vector<double>, 
double> &b, vector<double> &y);
 
  217 void vecsub(
const view1D<matrix::Dense<double>, 
double> &a,
 
  218             const view1D<vector<double>, 
double> &b,
 
  219             view1D<vector<double>, 
double> &y);
 
  220 void vecsub(
const view1D<matrix::Dense<double>, 
double> &a,
 
  221             const view1D<vector<double>, 
double> &b,
 
  222             view1D<matrix::Dense<double>, 
double> &y);
 
  223 void vecsub(
const view1D<matrix::Dense<double>, 
double> &a,
 
  224             const view1D<matrix::Dense<double>, 
double> &b, vector<double> &y);
 
  225 void vecsub(
const view1D<matrix::Dense<double>, 
double> &a,
 
  226             const view1D<matrix::Dense<double>, 
double> &b,
 
  227             view1D<vector<double>, 
double> &y);
 
  228 void vecsub(
const view1D<matrix::Dense<double>, 
double> &a,
 
  229             const view1D<matrix::Dense<double>, 
double> &b,
 
  230             view1D<matrix::Dense<double>, 
double> &y);
 
  231 void vecsub(
const vector<float> &a, 
const vector<float> &b, vector<float> &y);
 
  232 void vecsub(
const vector<float> &a, 
const vector<float> &b,
 
  233             view1D<vector<float>, 
float> &y);
 
  234 void vecsub(
const vector<float> &a, 
const vector<float> &b,
 
  235             view1D<matrix::Dense<float>, 
float> &y);
 
  236 void vecsub(
const vector<float> &a, 
const view1D<vector<float>, 
float> &b,
 
  238 void vecsub(
const vector<float> &a, 
const view1D<vector<float>, 
float> &b,
 
  239             view1D<vector<float>, 
float> &y);
 
  240 void vecsub(
const vector<float> &a, 
const view1D<vector<float>, 
float> &b,
 
  241             view1D<matrix::Dense<float>, 
float> &y);
 
  242 void vecsub(
const vector<float> &a,
 
  243             const view1D<matrix::Dense<float>, 
float> &b, vector<float> &y);
 
  244 void vecsub(
const vector<float> &a,
 
  245             const view1D<matrix::Dense<float>, 
float> &b,
 
  246             view1D<vector<float>, 
float> &y);
 
  247 void vecsub(
const vector<float> &a,
 
  248             const view1D<matrix::Dense<float>, 
float> &b,
 
  249             view1D<matrix::Dense<float>, 
float> &y);
 
  250 void vecsub(
const view1D<vector<float>, 
float> &a, 
const vector<float> &b,
 
  252 void vecsub(
const view1D<vector<float>, 
float> &a, 
const vector<float> &b,
 
  253             view1D<vector<float>, 
float> &y);
 
  254 void vecsub(
const view1D<vector<float>, 
float> &a, 
const vector<float> &b,
 
  255             view1D<matrix::Dense<float>, 
float> &y);
 
  256 void vecsub(
const view1D<vector<float>, 
float> &a,
 
  257             const view1D<vector<float>, 
float> &b, vector<float> &y);
 
  258 void vecsub(
const view1D<vector<float>, 
float> &a,
 
  259             const view1D<vector<float>, 
float> &b,
 
  260             view1D<vector<float>, 
float> &y);
 
  261 void vecsub(
const view1D<vector<float>, 
float> &a,
 
  262             const view1D<vector<float>, 
float> &b,
 
  263             view1D<matrix::Dense<float>, 
float> &y);
 
  264 void vecsub(
const view1D<vector<float>, 
float> &a,
 
  265             const view1D<matrix::Dense<float>, 
float> &b, vector<float> &y);
 
  266 void vecsub(
const view1D<vector<float>, 
float> &a,
 
  267             const view1D<matrix::Dense<float>, 
float> &b,
 
  268             view1D<vector<float>, 
float> &y);
 
  269 void vecsub(
const view1D<vector<float>, 
float> &a,
 
  270             const view1D<matrix::Dense<float>, 
float> &b,
 
  271             view1D<matrix::Dense<float>, 
float> &y);
 
  272 void vecsub(
const view1D<matrix::Dense<float>, 
float> &a,
 
  273             const vector<float> &b, vector<float> &y);
 
  274 void vecsub(
const view1D<matrix::Dense<float>, 
float> &a,
 
  275             const vector<float> &b, view1D<vector<float>, 
float> &y);
 
  276 void vecsub(
const view1D<matrix::Dense<float>, 
float> &a,
 
  277             const vector<float> &b, view1D<matrix::Dense<float>, 
float> &y);
 
  278 void vecsub(
const view1D<matrix::Dense<float>, 
float> &a,
 
  279             const view1D<vector<float>, 
float> &b, vector<float> &y);
 
  280 void vecsub(
const view1D<matrix::Dense<float>, 
float> &a,
 
  281             const view1D<vector<float>, 
float> &b,
 
  282             view1D<vector<float>, 
float> &y);
 
  283 void vecsub(
const view1D<matrix::Dense<float>, 
float> &a,
 
  284             const view1D<vector<float>, 
float> &b,
 
  285             view1D<matrix::Dense<float>, 
float> &y);
 
  286 void vecsub(
const view1D<matrix::Dense<float>, 
float> &a,
 
  287             const view1D<matrix::Dense<float>, 
float> &b, vector<float> &y);
 
  288 void vecsub(
const view1D<matrix::Dense<float>, 
float> &a,
 
  289             const view1D<matrix::Dense<float>, 
float> &b,
 
  290             view1D<vector<float>, 
float> &y);
 
  291 void vecsub(
const view1D<matrix::Dense<float>, 
float> &a,
 
  292             const view1D<matrix::Dense<float>, 
float> &b,
 
  293             view1D<matrix::Dense<float>, 
float> &y);
 
  305 void copy(
const vector<double> &x, vector<double> &y);
 
  306 void copy(
const vector<double> &x, view1D<vector<double>, 
double> &y);
 
  307 void copy(
const vector<double> &x, view1D<matrix::Dense<double>, 
double> &y);
 
  308 void copy(
const view1D<vector<double>, 
double> &x, vector<double> &y);
 
  309 void copy(
const view1D<vector<double>, 
double> &x,
 
  310           view1D<vector<double>, 
double> &y);
 
  311 void copy(
const view1D<vector<double>, 
double> &x,
 
  312           view1D<matrix::Dense<double>, 
double> &y);
 
  313 void copy(
const view1D<matrix::Dense<double>, 
double> &x, vector<double> &y);
 
  314 void copy(
const view1D<matrix::Dense<double>, 
double> &x,
 
  315           view1D<vector<double>, 
double> &y);
 
  316 void copy(
const view1D<matrix::Dense<double>, 
double> &x,
 
  317           view1D<matrix::Dense<double>, 
double> &y);
 
  318 void copy(
const vector<float> &x, vector<float> &y);
 
  319 void copy(
const vector<float> &x, view1D<vector<float>, 
float> &y);
 
  320 void copy(
const vector<float> &x, view1D<matrix::Dense<float>, 
float> &y);
 
  321 void copy(
const view1D<vector<float>, 
float> &x, vector<float> &y);
 
  322 void copy(
const view1D<vector<float>, 
float> &x,
 
  323           view1D<vector<float>, 
float> &y);
 
  324 void copy(
const view1D<vector<float>, 
float> &x,
 
  325           view1D<matrix::Dense<float>, 
float> &y);
 
  326 void copy(
const view1D<matrix::Dense<float>, 
float> &x, vector<float> &y);
 
  327 void copy(
const view1D<matrix::Dense<float>, 
float> &x,
 
  328           view1D<vector<float>, 
float> &y);
 
  329 void copy(
const view1D<matrix::Dense<float>, 
float> &x,
 
  330           view1D<matrix::Dense<float>, 
float> &y);
 
  342 void asum(
const vector<double> &x, 
double &ans);
 
  343 void asum(
const view1D<vector<double>, 
double> &x, 
double &ans);
 
  344 void asum(
const view1D<matrix::Dense<double>, 
double> &x, 
double &ans);
 
  345 void asum(
const vector<float> &x, 
float &ans);
 
  346 void asum(
const view1D<vector<float>, 
float> &x, 
float &ans);
 
  347 void asum(
const view1D<matrix::Dense<float>, 
float> &x, 
float &ans);
 
  359 double asum(
const vector<double> &x);
 
  360 double asum(
const view1D<vector<double>, 
double> &x);
 
  361 double asum(
const view1D<matrix::Dense<double>, 
double> &x);
 
  362 float asum(
const vector<float> &x);
 
  363 float asum(
const view1D<vector<float>, 
float> &x);
 
  364 float asum(
const view1D<matrix::Dense<float>, 
float> &x);
 
  376 void sum(
const vector<double> &x, 
double &ans);
 
  377 void sum(
const view1D<vector<double>, 
double> &x, 
double &ans);
 
  378 void sum(
const view1D<matrix::Dense<double>, 
double> &x, 
double &ans);
 
  379 void sum(
const vector<float> &x, 
float &ans);
 
  380 void sum(
const view1D<vector<float>, 
float> &x, 
float &ans);
 
  381 void sum(
const view1D<matrix::Dense<float>, 
float> &x, 
float &ans);
 
  393 double sum(
const vector<double> &x);
 
  394 double sum(
const view1D<vector<double>, 
double> &x);
 
  395 double sum(
const view1D<matrix::Dense<double>, 
double> &x);
 
  396 float sum(
const vector<float> &x);
 
  397 float sum(
const view1D<vector<float>, 
float> &x);
 
  398 float sum(
const view1D<matrix::Dense<float>, 
float> &x);
 
  411 void axpy(
const double alpha, 
const vector<double> &x, vector<double> &y);
 
  412 void axpy(
const double alpha, 
const vector<double> &x,
 
  413           view1D<vector<double>, 
double> &y);
 
  414 void axpy(
const double alpha, 
const vector<double> &x,
 
  415           view1D<matrix::Dense<double>, 
double> &y);
 
  416 void axpy(
const double alpha, 
const view1D<vector<double>, 
double> &x,
 
  418 void axpy(
const double alpha, 
const view1D<vector<double>, 
double> &x,
 
  419           view1D<vector<double>, 
double> &y);
 
  420 void axpy(
const double alpha, 
const view1D<vector<double>, 
double> &x,
 
  421           view1D<matrix::Dense<double>, 
double> &y);
 
  422 void axpy(
const double alpha, 
const view1D<matrix::Dense<double>, 
double> &x,
 
  424 void axpy(
const double alpha, 
const view1D<matrix::Dense<double>, 
double> &x,
 
  425           view1D<vector<double>, 
double> &y);
 
  426 void axpy(
const double alpha, 
const view1D<matrix::Dense<double>, 
double> &x,
 
  427           view1D<matrix::Dense<double>, 
double> &y);
 
  428 void axpy(
const float alpha, 
const vector<float> &x, vector<float> &y);
 
  429 void axpy(
const float alpha, 
const vector<float> &x,
 
  430           view1D<vector<float>, 
float> &y);
 
  431 void axpy(
const float alpha, 
const vector<float> &x,
 
  432           view1D<matrix::Dense<float>, 
float> &y);
 
  433 void axpy(
const float alpha, 
const view1D<vector<float>, 
float> &x,
 
  435 void axpy(
const float alpha, 
const view1D<vector<float>, 
float> &x,
 
  436           view1D<vector<float>, 
float> &y);
 
  437 void axpy(
const float alpha, 
const view1D<vector<float>, 
float> &x,
 
  438           view1D<matrix::Dense<float>, 
float> &y);
 
  439 void axpy(
const float alpha, 
const view1D<matrix::Dense<float>, 
float> &x,
 
  441 void axpy(
const float alpha, 
const view1D<matrix::Dense<float>, 
float> &x,
 
  442           view1D<vector<float>, 
float> &y);
 
  443 void axpy(
const float alpha, 
const view1D<matrix::Dense<float>, 
float> &x,
 
  444           view1D<matrix::Dense<float>, 
float> &y);
 
  458 void axpyz(
const double alpha, 
const vector<double> &x, 
const vector<double> &y,
 
  460 void axpyz(
const double alpha, 
const vector<double> &x, 
const vector<double> &y,
 
  461            view1D<vector<double>, 
double> &z);
 
  462 void axpyz(
const double alpha, 
const vector<double> &x, 
const vector<double> &y,
 
  463            view1D<matrix::Dense<double>, 
double> &z);
 
  464 void axpyz(
const double alpha, 
const vector<double> &x,
 
  465            const view1D<vector<double>, 
double> &y, vector<double> &z);
 
  466 void axpyz(
const double alpha, 
const vector<double> &x,
 
  467            const view1D<vector<double>, 
double> &y,
 
  468            view1D<vector<double>, 
double> &z);
 
  469 void axpyz(
const double alpha, 
const vector<double> &x,
 
  470            const view1D<vector<double>, 
double> &y,
 
  471            view1D<matrix::Dense<double>, 
double> &z);
 
  472 void axpyz(
const double alpha, 
const vector<double> &x,
 
  473            const view1D<matrix::Dense<double>, 
double> &y, vector<double> &z);
 
  474 void axpyz(
const double alpha, 
const vector<double> &x,
 
  475            const view1D<matrix::Dense<double>, 
double> &y,
 
  476            view1D<vector<double>, 
double> &z);
 
  477 void axpyz(
const double alpha, 
const vector<double> &x,
 
  478            const view1D<matrix::Dense<double>, 
double> &y,
 
  479            view1D<matrix::Dense<double>, 
double> &z);
 
  480 void axpyz(
const double alpha, 
const view1D<vector<double>, 
double> &x,
 
  481            const vector<double> &y, vector<double> &z);
 
  482 void axpyz(
const double alpha, 
const view1D<vector<double>, 
double> &x,
 
  483            const vector<double> &y, view1D<vector<double>, 
double> &z);
 
  484 void axpyz(
const double alpha, 
const view1D<vector<double>, 
double> &x,
 
  485            const vector<double> &y, view1D<matrix::Dense<double>, 
double> &z);
 
  486 void axpyz(
const double alpha, 
const view1D<vector<double>, 
double> &x,
 
  487            const view1D<vector<double>, 
double> &y, vector<double> &z);
 
  488 void axpyz(
const double alpha, 
const view1D<vector<double>, 
double> &x,
 
  489            const view1D<vector<double>, 
double> &y,
 
  490            view1D<vector<double>, 
double> &z);
 
  491 void axpyz(
const double alpha, 
const view1D<vector<double>, 
double> &x,
 
  492            const view1D<vector<double>, 
double> &y,
 
  493            view1D<matrix::Dense<double>, 
double> &z);
 
  494 void axpyz(
const double alpha, 
const view1D<vector<double>, 
double> &x,
 
  495            const view1D<matrix::Dense<double>, 
double> &y, vector<double> &z);
 
  496 void axpyz(
const double alpha, 
const view1D<vector<double>, 
double> &x,
 
  497            const view1D<matrix::Dense<double>, 
double> &y,
 
  498            view1D<vector<double>, 
double> &z);
 
  499 void axpyz(
const double alpha, 
const view1D<vector<double>, 
double> &x,
 
  500            const view1D<matrix::Dense<double>, 
double> &y,
 
  501            view1D<matrix::Dense<double>, 
double> &z);
 
  502 void axpyz(
const double alpha, 
const view1D<matrix::Dense<double>, 
double> &x,
 
  503            const vector<double> &y, vector<double> &z);
 
  504 void axpyz(
const double alpha, 
const view1D<matrix::Dense<double>, 
double> &x,
 
  505            const vector<double> &y, view1D<vector<double>, 
double> &z);
 
  506 void axpyz(
const double alpha, 
const view1D<matrix::Dense<double>, 
double> &x,
 
  507            const vector<double> &y, view1D<matrix::Dense<double>, 
double> &z);
 
  508 void axpyz(
const double alpha, 
const view1D<matrix::Dense<double>, 
double> &x,
 
  509            const view1D<vector<double>, 
double> &y, vector<double> &z);
 
  510 void axpyz(
const double alpha, 
const view1D<matrix::Dense<double>, 
double> &x,
 
  511            const view1D<vector<double>, 
double> &y,
 
  512            view1D<vector<double>, 
double> &z);
 
  513 void axpyz(
const double alpha, 
const view1D<matrix::Dense<double>, 
double> &x,
 
  514            const view1D<vector<double>, 
double> &y,
 
  515            view1D<matrix::Dense<double>, 
double> &z);
 
  516 void axpyz(
const double alpha, 
const view1D<matrix::Dense<double>, 
double> &x,
 
  517            const view1D<matrix::Dense<double>, 
double> &y, vector<double> &z);
 
  518 void axpyz(
const double alpha, 
const view1D<matrix::Dense<double>, 
double> &x,
 
  519            const view1D<matrix::Dense<double>, 
double> &y,
 
  520            view1D<vector<double>, 
double> &z);
 
  521 void axpyz(
const double alpha, 
const view1D<matrix::Dense<double>, 
double> &x,
 
  522            const view1D<matrix::Dense<double>, 
double> &y,
 
  523            view1D<matrix::Dense<double>, 
double> &z);
 
  524 void axpyz(
const float alpha, 
const vector<float> &x, 
const vector<float> &y,
 
  526 void axpyz(
const float alpha, 
const vector<float> &x, 
const vector<float> &y,
 
  527            view1D<vector<float>, 
float> &z);
 
  528 void axpyz(
const float alpha, 
const vector<float> &x, 
const vector<float> &y,
 
  529            view1D<matrix::Dense<float>, 
float> &z);
 
  530 void axpyz(
const float alpha, 
const vector<float> &x,
 
  531            const view1D<vector<float>, 
float> &y, vector<float> &z);
 
  532 void axpyz(
const float alpha, 
const vector<float> &x,
 
  533            const view1D<vector<float>, 
float> &y,
 
  534            view1D<vector<float>, 
float> &z);
 
  535 void axpyz(
const float alpha, 
const vector<float> &x,
 
  536            const view1D<vector<float>, 
float> &y,
 
  537            view1D<matrix::Dense<float>, 
float> &z);
 
  538 void axpyz(
const float alpha, 
const vector<float> &x,
 
  539            const view1D<matrix::Dense<float>, 
float> &y, vector<float> &z);
 
  540 void axpyz(
const float alpha, 
const vector<float> &x,
 
  541            const view1D<matrix::Dense<float>, 
float> &y,
 
  542            view1D<vector<float>, 
float> &z);
 
  543 void axpyz(
const float alpha, 
const vector<float> &x,
 
  544            const view1D<matrix::Dense<float>, 
float> &y,
 
  545            view1D<matrix::Dense<float>, 
float> &z);
 
  546 void axpyz(
const float alpha, 
const view1D<vector<float>, 
float> &x,
 
  547            const vector<float> &y, vector<float> &z);
 
  548 void axpyz(
const float alpha, 
const view1D<vector<float>, 
float> &x,
 
  549            const vector<float> &y, view1D<vector<float>, 
float> &z);
 
  550 void axpyz(
const float alpha, 
const view1D<vector<float>, 
float> &x,
 
  551            const vector<float> &y, view1D<matrix::Dense<float>, 
float> &z);
 
  552 void axpyz(
const float alpha, 
const view1D<vector<float>, 
float> &x,
 
  553            const view1D<vector<float>, 
float> &y, vector<float> &z);
 
  554 void axpyz(
const float alpha, 
const view1D<vector<float>, 
float> &x,
 
  555            const view1D<vector<float>, 
float> &y,
 
  556            view1D<vector<float>, 
float> &z);
 
  557 void axpyz(
const float alpha, 
const view1D<vector<float>, 
float> &x,
 
  558            const view1D<vector<float>, 
float> &y,
 
  559            view1D<matrix::Dense<float>, 
float> &z);
 
  560 void axpyz(
const float alpha, 
const view1D<vector<float>, 
float> &x,
 
  561            const view1D<matrix::Dense<float>, 
float> &y, vector<float> &z);
 
  562 void axpyz(
const float alpha, 
const view1D<vector<float>, 
float> &x,
 
  563            const view1D<matrix::Dense<float>, 
float> &y,
 
  564            view1D<vector<float>, 
float> &z);
 
  565 void axpyz(
const float alpha, 
const view1D<vector<float>, 
float> &x,
 
  566            const view1D<matrix::Dense<float>, 
float> &y,
 
  567            view1D<matrix::Dense<float>, 
float> &z);
 
  568 void axpyz(
const float alpha, 
const view1D<matrix::Dense<float>, 
float> &x,
 
  569            const vector<float> &y, vector<float> &z);
 
  570 void axpyz(
const float alpha, 
const view1D<matrix::Dense<float>, 
float> &x,
 
  571            const vector<float> &y, view1D<vector<float>, 
float> &z);
 
  572 void axpyz(
const float alpha, 
const view1D<matrix::Dense<float>, 
float> &x,
 
  573            const vector<float> &y, view1D<matrix::Dense<float>, 
float> &z);
 
  574 void axpyz(
const float alpha, 
const view1D<matrix::Dense<float>, 
float> &x,
 
  575            const view1D<vector<float>, 
float> &y, vector<float> &z);
 
  576 void axpyz(
const float alpha, 
const view1D<matrix::Dense<float>, 
float> &x,
 
  577            const view1D<vector<float>, 
float> &y,
 
  578            view1D<vector<float>, 
float> &z);
 
  579 void axpyz(
const float alpha, 
const view1D<matrix::Dense<float>, 
float> &x,
 
  580            const view1D<vector<float>, 
float> &y,
 
  581            view1D<matrix::Dense<float>, 
float> &z);
 
  582 void axpyz(
const float alpha, 
const view1D<matrix::Dense<float>, 
float> &x,
 
  583            const view1D<matrix::Dense<float>, 
float> &y, vector<float> &z);
 
  584 void axpyz(
const float alpha, 
const view1D<matrix::Dense<float>, 
float> &x,
 
  585            const view1D<matrix::Dense<float>, 
float> &y,
 
  586            view1D<vector<float>, 
float> &z);
 
  587 void axpyz(
const float alpha, 
const view1D<matrix::Dense<float>, 
float> &x,
 
  588            const view1D<matrix::Dense<float>, 
float> &y,
 
  589            view1D<matrix::Dense<float>, 
float> &z);
 
  602 void dot(
const vector<double> &x, 
const vector<double> &y, 
double &ans);
 
  603 void dot(
const vector<double> &x, 
const view1D<vector<double>, 
double> &y,
 
  605 void dot(
const vector<double> &x,
 
  606          const view1D<matrix::Dense<double>, 
double> &y, 
double &ans);
 
  607 void dot(
const view1D<vector<double>, 
double> &x, 
const vector<double> &y,
 
  609 void dot(
const view1D<vector<double>, 
double> &x,
 
  610          const view1D<vector<double>, 
double> &y, 
double &ans);
 
  611 void dot(
const view1D<vector<double>, 
double> &x,
 
  612          const view1D<matrix::Dense<double>, 
double> &y, 
double &ans);
 
  613 void dot(
const view1D<matrix::Dense<double>, 
double> &x,
 
  614          const vector<double> &y, 
double &ans);
 
  615 void dot(
const view1D<matrix::Dense<double>, 
double> &x,
 
  616          const view1D<vector<double>, 
double> &y, 
double &ans);
 
  617 void dot(
const view1D<matrix::Dense<double>, 
double> &x,
 
  618          const view1D<matrix::Dense<double>, 
double> &y, 
double &ans);
 
  619 void dot(
const vector<float> &x, 
const vector<float> &y, 
float &ans);
 
  620 void dot(
const vector<float> &x, 
const view1D<vector<float>, 
float> &y,
 
  622 void dot(
const vector<float> &x, 
const view1D<matrix::Dense<float>, 
float> &y,
 
  624 void dot(
const view1D<vector<float>, 
float> &x, 
const vector<float> &y,
 
  626 void dot(
const view1D<vector<float>, 
float> &x,
 
  627          const view1D<vector<float>, 
float> &y, 
float &ans);
 
  628 void dot(
const view1D<vector<float>, 
float> &x,
 
  629          const view1D<matrix::Dense<float>, 
float> &y, 
float &ans);
 
  630 void dot(
const view1D<matrix::Dense<float>, 
float> &x, 
const vector<float> &y,
 
  632 void dot(
const view1D<matrix::Dense<float>, 
float> &x,
 
  633          const view1D<vector<float>, 
float> &y, 
float &ans);
 
  634 void dot(
const view1D<matrix::Dense<float>, 
float> &x,
 
  635          const view1D<matrix::Dense<float>, 
float> &y, 
float &ans);
 
  648 double dot(
const vector<double> &x, 
const vector<double> &y);
 
  649 double dot(
const vector<double> &x, 
const view1D<vector<double>, 
double> &y);
 
  650 double dot(
const vector<double> &x,
 
  651            const view1D<matrix::Dense<double>, 
double> &y);
 
  652 double dot(
const view1D<vector<double>, 
double> &x, 
const vector<double> &y);
 
  653 double dot(
const view1D<vector<double>, 
double> &x,
 
  654            const view1D<vector<double>, 
double> &y);
 
  655 double dot(
const view1D<vector<double>, 
double> &x,
 
  656            const view1D<matrix::Dense<double>, 
double> &y);
 
  657 double dot(
const view1D<matrix::Dense<double>, 
double> &x,
 
  658            const vector<double> &y);
 
  659 double dot(
const view1D<matrix::Dense<double>, 
double> &x,
 
  660            const view1D<vector<double>, 
double> &y);
 
  661 double dot(
const view1D<matrix::Dense<double>, 
double> &x,
 
  662            const view1D<matrix::Dense<double>, 
double> &y);
 
  663 float dot(
const vector<float> &x, 
const vector<float> &y);
 
  664 float dot(
const vector<float> &x, 
const view1D<vector<float>, 
float> &y);
 
  665 float dot(
const vector<float> &x, 
const view1D<matrix::Dense<float>, 
float> &y);
 
  666 float dot(
const view1D<vector<float>, 
float> &x, 
const vector<float> &y);
 
  667 float dot(
const view1D<vector<float>, 
float> &x,
 
  668           const view1D<vector<float>, 
float> &y);
 
  669 float dot(
const view1D<vector<float>, 
float> &x,
 
  670           const view1D<matrix::Dense<float>, 
float> &y);
 
  671 float dot(
const view1D<matrix::Dense<float>, 
float> &x, 
const vector<float> &y);
 
  672 float dot(
const view1D<matrix::Dense<float>, 
float> &x,
 
  673           const view1D<vector<float>, 
float> &y);
 
  674 float dot(
const view1D<matrix::Dense<float>, 
float> &x,
 
  675           const view1D<matrix::Dense<float>, 
float> &y);
 
  687 void nrm1(
const vector<double> &x, 
double &ans);
 
  688 void nrm1(
const view1D<vector<double>, 
double> &x, 
double &ans);
 
  689 void nrm1(
const view1D<matrix::Dense<double>, 
double> &x, 
double &ans);
 
  690 void nrm1(
const vector<float> &x, 
float &ans);
 
  691 void nrm1(
const view1D<vector<float>, 
float> &x, 
float &ans);
 
  692 void nrm1(
const view1D<matrix::Dense<float>, 
float> &x, 
float &ans);
 
  704 double nrm1(
const vector<double> &x);
 
  705 double nrm1(
const view1D<vector<double>, 
double> &x);
 
  706 double nrm1(
const view1D<matrix::Dense<double>, 
double> &x);
 
  707 float nrm1(
const vector<float> &x);
 
  708 float nrm1(
const view1D<vector<float>, 
float> &x);
 
  709 float nrm1(
const view1D<matrix::Dense<float>, 
float> &x);
 
  721 void nrm2(
const vector<double> &x, 
double &ans);
 
  722 void nrm2(
const view1D<vector<double>, 
double> &x, 
double &ans);
 
  723 void nrm2(
const view1D<matrix::Dense<double>, 
double> &x, 
double &ans);
 
  724 void nrm2(
const vector<float> &x, 
float &ans);
 
  725 void nrm2(
const view1D<vector<float>, 
float> &x, 
float &ans);
 
  726 void nrm2(
const view1D<matrix::Dense<float>, 
float> &x, 
float &ans);
 
  738 double nrm2(
const vector<double> &x);
 
  739 double nrm2(
const view1D<vector<double>, 
double> &x);
 
  740 double nrm2(
const view1D<matrix::Dense<double>, 
double> &x);
 
  741 float nrm2(
const vector<float> &x);
 
  742 float nrm2(
const view1D<vector<float>, 
float> &x);
 
  743 float nrm2(
const view1D<matrix::Dense<float>, 
float> &x);
 
  755 void scal(
const double alpha, vector<double> &x);
 
  756 void scal(
const double alpha, view1D<vector<double>, 
double> &x);
 
  757 void scal(
const double alpha, view1D<matrix::Dense<double>, 
double> &x);
 
  758 void scal(
const float alpha, vector<float> &x);
 
  759 void scal(
const float alpha, view1D<vector<float>, 
float> &x);
 
  760 void scal(
const float alpha, view1D<matrix::Dense<float>, 
float> &x);
 
  773 void xpay(
const double alpha, 
const vector<double> &x, vector<double> &y);
 
  774 void xpay(
const double alpha, 
const vector<double> &x,
 
  775           view1D<vector<double>, 
double> &y);
 
  776 void xpay(
const double alpha, 
const vector<double> &x,
 
  777           view1D<matrix::Dense<double>, 
double> &y);
 
  778 void xpay(
const double alpha, 
const view1D<vector<double>, 
double> &x,
 
  780 void xpay(
const double alpha, 
const view1D<vector<double>, 
double> &x,
 
  781           view1D<vector<double>, 
double> &y);
 
  782 void xpay(
const double alpha, 
const view1D<vector<double>, 
double> &x,
 
  783           view1D<matrix::Dense<double>, 
double> &y);
 
  784 void xpay(
const double alpha, 
const view1D<matrix::Dense<double>, 
double> &x,
 
  786 void xpay(
const double alpha, 
const view1D<matrix::Dense<double>, 
double> &x,
 
  787           view1D<vector<double>, 
double> &y);
 
  788 void xpay(
const double alpha, 
const view1D<matrix::Dense<double>, 
double> &x,
 
  789           view1D<matrix::Dense<double>, 
double> &y);
 
  790 void xpay(
const float alpha, 
const vector<float> &x, vector<float> &y);
 
  791 void xpay(
const float alpha, 
const vector<float> &x,
 
  792           view1D<vector<float>, 
float> &y);
 
  793 void xpay(
const float alpha, 
const vector<float> &x,
 
  794           view1D<matrix::Dense<float>, 
float> &y);
 
  795 void xpay(
const float alpha, 
const view1D<vector<float>, 
float> &x,
 
  797 void xpay(
const float alpha, 
const view1D<vector<float>, 
float> &x,
 
  798           view1D<vector<float>, 
float> &y);
 
  799 void xpay(
const float alpha, 
const view1D<vector<float>, 
float> &x,
 
  800           view1D<matrix::Dense<float>, 
float> &y);
 
  801 void xpay(
const float alpha, 
const view1D<matrix::Dense<float>, 
float> &x,
 
  803 void xpay(
const float alpha, 
const view1D<matrix::Dense<float>, 
float> &x,
 
  804           view1D<vector<float>, 
float> &y);
 
  805 void xpay(
const float alpha, 
const view1D<matrix::Dense<float>, 
float> &x,
 
  806           view1D<matrix::Dense<float>, 
float> &y);