jacobian()

template<class Field>

SLP< Field > * SLP< Field >::jacobian	(	bool	makeHxH,
		SLP< Field > *&	slpHxH,
		bool	makeHxtH,
		SLP< Field > *&	slpHxtH )

!! assume: appending ZERO

Definition at line 612 of file NAG.cpp.

{
  if (rows_out != 1)
    {
      ERROR("1-row slp expected");
      return nullptr;
    };
 
  int num_outputs = rows_out * cols_out;
  int* end_program = program->array + program->len - num_outputs;
 
  SLP<Field>* res = new SLP<Field>;
  res->C = C;
  res->is_relative_position = true;
  res->num_inputs = num_inputs;
  res->num_operations = num_operations;
  res->rows_out = num_inputs;
  res->cols_out = cols_out;
 
  //  gc_vector<element_type> consts; // !!! use to optimize constants
  gc_vector<int> prog;
  prog.reserve(program->len);
  for (int i = SLP_HEADER_LEN;
       i < program->len - num_outputs - 1 /*for slpEND*/;
       i++)
    prog.push_back(program->array[i]);
  res->node_index = node_index;
 
  std::vector<int> out_pos(res->rows_out *
                           res->cols_out);  // records absolute position of output entries
 
  for (int j = 0; j < num_outputs; j++)
    for (int i = 0; i < num_inputs; i++)
      out_pos[i * res->cols_out + j] =
          res->diffNodeInput(end_program[j] - num_consts -
                                 num_inputs /*position of j-th output in prog*/,
                             i,
                             prog);  // uses res->num_operations
  // make program
  res->program = M2_makearrayint(SLP_HEADER_LEN + prog.size() + 1 +
                                 res->rows_out * res->cols_out);
  res->program->array[0] = res->num_consts =
      num_consts + 1;  
  res->program->array[1] = res->num_inputs;
  res->program->array[2] = res->rows_out;
  res->program->array[3] = res->cols_out;
  prog.push_back(slpEND);
  for (int i = 0; i < num_inputs; i++)
    for (int j = 0; j < num_outputs; j++)
      {
        int t = out_pos[i * res->cols_out + j];
        prog.push_back((t == ZERO_CONST)
                        ? num_consts /*ref to ZERO*/
                        : t + res->num_consts +
                              num_inputs);  // position of the output
      }
  memcpy(res->program->array + SLP_HEADER_LEN,
         prog.data(),
         sizeof(int) * prog.size());
 
  // make nodes: [constants, inputs, operations]
  make_nodes(res->nodes,
             res->num_consts + res->num_inputs + res->num_operations);
  // memcpy(res->nodes, nodes, num_consts*sizeof(element_type)); // old
  // constants
  for (int i = 0; i < num_consts; i++)
    {
      res->nodes[i] = nodes[i];
    }
 
  res->nodes[num_consts] = element_type(0, 0);  // ... plus ZERO
 
  if (makeHxH)
    {
      slpHxH = res->copy();
      int* c = slpHxH->program->array + slpHxH->program->len - slpHxH->cols_out;
      for (int j = 0; j < num_outputs; j++, c++)
        *c = end_program[j] - num_consts + res->num_consts;
    }
  if (makeHxtH)
    {
      slpHxtH = res->copy();
      slpHxtH->rows_out++;
      // how to kill M2_arrayint ???
      slpHxtH->program = M2_makearrayint(slpHxtH->program->len + cols_out);
      memcpy(slpHxtH->program->array,
             res->program->array,
             sizeof(int) * res->program->len);
      int* c = slpHxtH->program->array + res->program->len;
      for (int j = 0; j < num_outputs; j++, c++)
        *c = end_program[j] - num_consts + res->num_consts;
    }
  return res;
}

References C, cols_out, copy(), diffNodeInput(), ERROR, is_relative_position, M2_makearrayint(), make_nodes(), node_index, nodes, num_consts, num_inputs, num_operations, program, rows_out, SLP(), SLP_HEADER_LEN, slpEND, and ZERO_CONST.

Referenced by StraightLineProgram::jacobian().