Function numeric_map_loop

pure/runtime.cc:14624–14668

template < typename in_mat_type,
           typename out_mat_type >
pure_expr*
numeric_map_loop
( pure_expr *f,       //the function being mapped
  in_mat_type *in,    //the 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< in_mat_type>::type  in_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*
  in_elem_type  *inp  = (reinterpret_cast<in_elem_type* >(in->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 map, so now we apply f to all but the first
  //column in the first row..
  *lasti=0;
  for (size_t j=1; j<in->size2; ++j,++inp,++outp) {
    *lastj=j;
    r = pure_app( f, to_expr(*inp) );
    if (!from_expr(r,v)) return r;
    *outp = v;
    pure_freenew(r);
  }

  //..then the rest of the rows
  for (size_t i=1; i<in->size1; ++i) {
    *lasti=i;
    inp  = (reinterpret_cast< in_elem_type*>( in->data))+i*in->tda;
    outp = (reinterpret_cast<out_elem_type*>(out->data))+i*out->tda;
    for (size_t j=0; j<in->size2; ++j,++inp,++outp) {
      *lastj=j;
      r = pure_app( f, to_expr(*inp) );
      if (!from_expr(r,v)) return r;
      *outp = v;
      pure_freenew(r);
    }
  }
  return 0;
}


//symbolic map loop : mapped function results in heterogenous / non-numerical