evaluate() [1/2]

template<class Field>

Matrix * SLP< Field >::evaluate

(

const Matrix *

vals

)

Definition at line 805 of file NAG.cpp.

{
  element_type* out = nullptr;   // used by compiledSLP
  int out_entries_shift = 0;  // position of "out matrix" in slp->program
 
  int cur_node = num_consts;
  int i;
  if (values->n_cols() != num_inputs)
    ERROR("different number of inputs expected");
  for (i = 0; i < num_inputs; i++, cur_node++)
    nodes[cur_node] = element_type(toBigComplex(C, values->elem(0, i)));
 
  clock_t start_t = clock();  // clock execution time
 
  switch (program->array[4])
    {
      case slpCOMPILED:
        // evaluation via dynamically linked function
        // input: nodes (shifted by number of consts)
        // output: out
        out = nodes + num_consts + num_inputs;
        compiled_fn(nodes + num_consts, out);
        break;
      default:  // evaluation by interpretation
        convert_to_absolute_position();
        i = SLP_HEADER_LEN;
        for (; program->array[i] != slpEND; cur_node++)
          {
            switch (program->array[i])
              {
                case slpCOPY:
                  nodes[cur_node] = nodes[program->array[(++i)++]];
                  break;
                case slpMULTIsum:
                  {
                    int n_summands = program->array[i + 1];
                    nodes[cur_node] =
                        (n_summands > 0)
                            ?  // create a temp var?
                            nodes[program->array[i + 2]]
                            : element_type(0, 0);  // zero if empty sum
                    for (int j = 1; j < n_summands; j++)
                      nodes[cur_node] =
                          nodes[cur_node] + nodes[program->array[i + j + 2]];
                    i += n_summands + 2;
                  }
                  break;
                case slpPRODUCT:
                  nodes[cur_node] = nodes[program->array[i + 1]] *
                                    nodes[program->array[i + 2]];
                  i += 3;
                  break;
                default:
                  ERROR("unknown SLP operation");
                  return nullptr;
              }
          }
        out_entries_shift = i + 1;
        // end: evaluation by interpretation
    }
 
  eval_time += clock() - start_t;
  n_calls++;
 
  const CCC* R = cast_to_CCC(values->get_ring());
  // CCC* R = CCC::create(53); //values->get_ring();
  FreeModule* S = R->make_FreeModule(cols_out);
  FreeModule* T = R->make_FreeModule(rows_out);
  MatrixConstructor mat(T, S);
  mpfr_t re, im;
  mpfr_init(re);
  mpfr_init(im);
  switch (program->array[4])
    {
      case slpPREDICTOR:
      case slpCORRECTOR:
      case slpCOMPILED:
        {
          // printf("predictor output: %d by %d\n", rows_out, cols_out);
          element_type* c = out;
          for (i = 0; i < rows_out; i++)
            for (int j = 0; j < cols_out; j++, c++)
              {
                // printf("%lf %lf \n", c->getreal(), c->getimaginary());
                ring_elem e = from_doubles(R, c->getreal(), c->getimaginary());
 
                mat.set_entry(i, j, e);
              }
        }
        break;
      default:  // interpretation
        for (i = 0; i < rows_out; i++)
          for (int j = 0; j < cols_out; j++)
            {
              element_type c =
                  nodes[program->array[i * cols_out + j + out_entries_shift]];
 
              ring_elem e = from_doubles(R, c.getreal(), c.getimaginary());
 
              mat.set_entry(i, j, e);
            }
        // end: interpretation
    }
  mpfr_clear(re);
  mpfr_clear(im);
  return mat.to_matrix();
}

References C, cast_to_CCC(), CCC, cols_out, compiled_fn, convert_to_absolute_position(), Matrix::elem(), ERROR, eval_time, from_doubles(), Matrix::get_ring(), Ring::make_FreeModule(), Matrix, n_calls, Matrix::n_cols(), nodes, num_consts, num_inputs, program, FreeModule::R, rows_out, MatrixConstructor::set_entry(), SLP_HEADER_LEN, slpCOMPILED, slpCOPY, slpCORRECTOR, slpEND, slpMULTIsum, slpPREDICTOR, slpPRODUCT, T, MatrixConstructor::to_matrix(), and toBigComplex().