evaluate() [2/2]

template<typename Field>

void SLP< Field >::evaluate	(	int	n,
		const element_type *	values,
		element_type *	out )

Definition at line 713 of file NAG.cpp.

{
  if (n != num_inputs) ERROR("wrong number of inputs");
 
  element_type* out = nullptr;   // used by compiledSLP
  int out_entries_shift = 0;  // position of "out matrix"
 
  int cur_node = num_consts;
  int i;
  copy_complex_array<Field>(num_inputs, values, nodes + cur_node);
  cur_node += num_inputs;
 
  clock_t start_t = clock();  // clock execution time
 
  switch (program->array[4])
    {
      /* obsolete !!!
      case slpPREDICTOR:
        out = nodes+num_consts+num_inputs;
        predictor();
        break;
      case slpCORRECTOR:
        out = nodes+num_consts+num_inputs;
        corrector();
        break;
      */
      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;
              }
          }
        out_entries_shift = i + 1;
        // end: evaluation by interpretation
    }
 
  eval_time += clock() - start_t;
  n_calls++;
 
  switch (program->array[4])
    {
      case slpPREDICTOR:
      case slpCOMPILED:
        // dynamically linked
        copy_complex_array<Field>(rows_out * cols_out, out, ret);
        break;
      default:
        // interpretation
        element_type* c = ret;
        for (i = 0; i < rows_out; i++)
          for (int j = 0; j < cols_out; j++, c++)
            *c = nodes[program->array[i * cols_out + j + out_entries_shift]];
        // end: interpretation
    }
}

References cols_out, compiled_fn, convert_to_absolute_position(), copy_complex_array(), ERROR, eval_time, n_calls, nodes, num_consts, num_inputs, program, rows_out, SLP_HEADER_LEN, slpCOMPILED, slpCOPY, slpEND, slpMULTIsum, slpPREDICTOR, and slpPRODUCT.

Referenced by StraightLineProgram::evaluate(), StraightLineProgram::evaluate(), and rawEvaluateSLP().