Function numeric_zipwith_loop

pure/runtime.cc:14839–14887

           typename in2_mat_type,
           typename out_mat_type >
pure_expr*
numeric_zipwith_loop
( pure_expr *f,       //the function being zipped
  in1_mat_type *in1,   //the 1st operand matrix
  in2_mat_type *in2,   //the 2nd operand matrix
  out_mat_type *out,  //the result matrix
  size_t *lasti,      //last row and column written to
  size_t *lastj )     //  before bailing out in the event that
                      //  the output of f is not the right type
{
  typedef typename element_of<in1_mat_type>::type in1_elem_type;
  typedef typename element_of<in2_mat_type>::type in2_elem_type;
  typedef typename element_of<out_mat_type>::type out_elem_type;

  //need casts for complex case, when data pointer is double*, but
  //we really want complex*
  in1_elem_type *inp1 = (reinterpret_cast<in1_elem_type*>(in1->data ))+1;
  in2_elem_type *inp2 = (reinterpret_cast<in2_elem_type*>(in2->data ))+1;
  out_elem_type *outp = (reinterpret_cast<out_elem_type*>(out->data))+1;
  pure_expr *r; //result expression
  out_elem_type v; //result value

  //we already performed the first zipwith, so now we apply f to all but the
  //first column in the first row..
  *lasti=0;
  for (size_t j=1; j<in1->size2 && j<in2->size2; ++j,++inp1,++inp2,++outp) {
    *lastj=j;
    r = pure_appl( f, 2, to_expr(*inp1), to_expr(*inp2) );
    if (!from_expr(r,v)) return r;
    *outp = v;
    pure_freenew(r);
  }

  //..then the rest of the rows
  for (size_t i=1; i<in1->size1 && i<in2->size1; ++i) {
    *lasti=i;
    inp1 = (reinterpret_cast<in1_elem_type*>(in1->data))+i*in1->tda;
    inp2 = (reinterpret_cast<in2_elem_type*>(in2->data))+i*in2->tda;
    outp = (reinterpret_cast<out_elem_type*>(out->data))+i*out->tda;
    for (size_t j=0; j<in1->size2 && j<in2->size2; ++j,++inp1,++inp2,++outp) {
      *lastj=j;
      r = pure_appl( f, 2, to_expr(*inp1), to_expr(*inp2) );
      if (!from_expr(r,v)) return r;
      *outp = v;
      pure_freenew(r);
    }
  }
  return 0;
}


//symbolic zipwith loop : zipped function results in heterogenous /