diffNodeInput()

template<class Field>

int SLP< Field >::diffNodeInput ( int n, int v, gc_vector< int > & prog )

private

Definition at line 450 of file NAG.cpp.

{
  int i = node_index[n];
  switch (prog[i])
    {
      /* case slpCOPY:
         break;*/
      case slpMULTIsum:
        {
          int n_summands = prog[(++i)++];
          std::vector<int> part_pos(n_summands);
          int c = 0;  // count nonzeroes
          int last_non_zero = ZERO_CONST;
          for (int j = 0; j < n_summands; j++)
            {
              part_pos[j] = diffPartReference(n, prog[i++], v, prog);
              if (part_pos[j] != ZERO_CONST)
                {
                  c++;
                  last_non_zero = part_pos[j];
                }
            }
          if (c == 0) return ZERO_CONST;
          if (c == 1) return last_non_zero;
          int cur_p = num_operations++;
          node_index.push_back(prog.size());
          prog.push_back(slpMULTIsum);
          prog.push_back(c);
          for (int j = 0; j < n_summands; j++)
            {
              if (part_pos[j] != ZERO_CONST)
                prog.push_back(part_pos[j] -
                            cur_p);  // relative position of the j-th part
            }
          return cur_p;
        }
      case slpPRODUCT:
        {
          int a = prog[(++i)++];
          int b = prog[i++];
          int da = diffPartReference(n, a, v, prog);
          int db = diffPartReference(n, b, v, prog);
          if (db == ZERO_CONST)
            {
              if (da == ZERO_CONST) return ZERO_CONST;
              if (da == ONE_CONST)
                {
                  if (b < 0)  // if refers to operation node
                    return n + b;
                  else if (b >= CONST_OFFSET)
                    {  // ... constant
                      int cur_p = num_operations++;
                      node_index.push_back(prog.size());
                      prog.push_back(slpCOPY);  // is there better way?
                      prog.push_back(b);
                      return cur_p;
                    }
                  else
                    {  // ... input
                      ERROR("input node not expected");
                      return ZERO_CONST;
                    };
                }
              else
                {
                  int cur_p = num_operations++;
                  node_index.push_back(prog.size());
                  prog.push_back(slpPRODUCT);
                  prog.push_back(da - cur_p);
                  if (b < 0)            // if refers to an operation node
                    b = n + b - cur_p;  // recalculate wrt cur_p
                  prog.push_back(b);
                  return cur_p;
                }
            }
          else if (da == ZERO_CONST)
            {  // ... and db != 0
              if (db == ONE_CONST)
                {
                  if (a < 0)  // if refers to an operation node
                    return n + a;
                  else if (a >= CONST_OFFSET)
                    {  // ... constant
                      int cur_p = num_operations++;
                      node_index.push_back(prog.size());
                      prog.push_back(slpCOPY);  // is there a better way ?
                      if (a < 0)             // if refers to an operation node
                        a = n + a - cur_p;   // recalculate wrt cur_p
                      prog.push_back(a);
                      return cur_p;
                    }
                  else
                    {  // ... input
                      ERROR("input node not expected");
                      return ZERO_CONST;
                    };
                }
              else
                {  // db!=0 and db!=1
                  int cur_p = num_operations++;
                  node_index.push_back(prog.size());
                  prog.push_back(slpPRODUCT);
                  prog.push_back(db - cur_p);
                  if (a < 0)            // if refers to an operation node
                    a = n + a - cur_p;  // recalculate wrt cur_p
                  prog.push_back(a);
                  return cur_p;
                }
            }
          else
            {  // da |=0 and db !=0
              int part1 = ZERO_CONST;
              int is_part1_created = (da != ONE_CONST);
              if (is_part1_created)
                {
                  int cur_p = num_operations++;
                  node_index.push_back(prog.size());
                  prog.push_back(slpPRODUCT);
                  prog.push_back(da - cur_p);
                  if (b < 0)            // if refers to an operation node
                    b = n + b - cur_p;  // recalculate wrt cur_p
                  prog.push_back(b);
                  part1 = cur_p;
                }
              int part2 = ZERO_CONST;
              int is_part2_created = (db != ONE_CONST);
              if (is_part2_created)
                {
                  int cur_p = num_operations++;
                  node_index.push_back(prog.size());
                  prog.push_back(slpPRODUCT);
                  prog.push_back(db - cur_p);
                  if (a < 0)            // if refers to an operation node
                    a = n + a - cur_p;  // recalculate wrt cur_p
                  prog.push_back(a);
                  part2 = cur_p;
                }
              int cur_p = num_operations++;
              node_index.push_back(prog.size());
              prog.push_back(slpMULTIsum);
              prog.push_back(2);
              if (is_part1_created)
                prog.push_back(part1 - cur_p);
              else
                prog.push_back((b < 0) ? b + n - cur_p : b);
              if (is_part2_created)
                prog.push_back(part2 - cur_p);
              else
                prog.push_back((a < 0) ? a + n - cur_p : a);
              return cur_p;
            }
        }
      default:
        ERROR("unknown SLP operation");
        printf("i = %d, a[i] = %d\n", i, prog[i]);
        return 0;
    }
}

References CONST_OFFSET, diffPartReference(), node_index, num_operations, ONE_CONST, slpCOPY, slpMULTIsum, slpPRODUCT, and ZERO_CONST.

Referenced by diffPartReference(), and jacobian().