Esempio n. 1
0
GtScoreHandler *gt_scorehandler2costhandler(const GtScoreHandler *scorehandler)
{
  GtScoreHandler *costhandler;

  gt_assert(scorehandler != NULL);
  if (scorehandler->scorematrix == NULL)
  {
    GtWord matchscore, mismatchscore, gap_extension, gap_opening,
           maxscore = MAX(MAX(GT_DIV2(scorehandler->matchscore+1),
                         GT_DIV2(scorehandler->mismatchscore+1)),
                     MAX(1 + scorehandler->gap_extension,0));

    matchscore = 2 * maxscore - scorehandler->matchscore;
    mismatchscore = 2 * maxscore - scorehandler->mismatchscore;
    gap_extension = maxscore - scorehandler->gap_extension;
    gap_opening = -scorehandler->gap_opening;
    costhandler = gt_scorehandler_new(matchscore,
                                      mismatchscore,
                                      gap_opening,
                                      gap_extension);
    if (!scorehandler->mappedsequence)
    {
      gt_scorehandler_plain(costhandler);
    }
  } else
  {
    int maxscore;
    GtWord gap_extension, gap_opening;
    unsigned int i, j,
                 dim = gt_score_matrix_get_dimension(scorehandler->scorematrix);
    GtScoreMatrix *costmatrix
      = gt_score_matrix_clone_empty(scorehandler->scorematrix);

    for (maxscore = 0, i = 0; i < dim; i++)
    {
      for (j = 0; j < dim; j++)
      {
        int val = gt_score_matrix_get_score(scorehandler->scorematrix, i, j);

        if (val > maxscore)
        {
          maxscore = val;
        }
      }
    }
    maxscore = MAX(GT_DIV2(maxscore+1), 1 + scorehandler->gap_extension);
    for (i = 0; i < dim; i++)
    {
      for (j = 0; j < dim; j++)
      {
        /* translate */
        int score = gt_score_matrix_get_score(scorehandler->scorematrix,i,j);
        gt_score_matrix_set_score(costmatrix, i, j, 2 * maxscore - score);
      }
    }
    gap_extension = maxscore - scorehandler->gap_extension;
    gap_opening = -scorehandler->gap_opening;
    costhandler = gt_scorehandler_new( 0,0, gap_opening, gap_extension);
    gt_scorehandler_add_scorematrix(costhandler,costmatrix);
  }
  return costhandler;
}
Esempio n. 2
0
/* handle score and cost values */
static GtScoreHandler *gt_arguments2scorehandler(
                             const GtLinspaceArguments *arguments,
                             GtError *err)
{
  GtWord matchscore, mismatchscore, gap_open, gap_extension;
  GtScoreHandler *scorehandler = NULL;
  GtScoreMatrix *scorematrix = NULL;
  int had_err = 0;

  gt_error_check(err);
  if (gt_str_array_size(arguments->linearcosts) > 0)
  {
    GtUword wordindex = 0;

    if (arguments->protein)
    {
      scorematrix
        = gt_score_matrix_new_read_protein(
                          gt_str_array_get(arguments->linearcosts,wordindex++),
                          err);
      if (scorematrix == NULL)
      {
        had_err = -1;
      }
      matchscore = 0;
      mismatchscore = 0;
    } else
    {
      had_err = gt_parse_score_value(__LINE__,&matchscore,
                                     gt_str_array_get(arguments->linearcosts,
                                                      wordindex++),
                                     arguments->global,err);
      if (!had_err)
      {
        had_err = gt_parse_score_value(__LINE__,&mismatchscore,
                                       gt_str_array_get(arguments->linearcosts,
                                                        wordindex++),
                                       arguments->global,err);
      }
    }
    if (!had_err)
    {
      gap_open = 0;
      had_err = gt_parse_score_value(__LINE__,&gap_extension,
                                     gt_str_array_get(arguments->linearcosts,
                                                      wordindex++),
                                     false,err);
    }
  } else /*if (gt_str_array_size(arguments->affinecosts) > 0)*/
  {
    GtUword wordindex = 0;

    if (arguments->protein)
    {
      scorematrix = gt_score_matrix_new_read_protein(
                               gt_str_array_get(arguments->affinecosts,
                                                wordindex++), err);
      if (scorematrix == NULL)
      {
        had_err = -1;
      }
      matchscore = mismatchscore = 0;
    } else
    {
      had_err = gt_parse_score_value(__LINE__,&matchscore,
                                     gt_str_array_get(arguments->affinecosts,
                                                      wordindex++),
                                     arguments->global,err);
      if (!had_err)
      {
        had_err = gt_parse_score_value(__LINE__,&mismatchscore,
                                       gt_str_array_get(arguments->affinecosts,
                                                        wordindex++),
                                       arguments->global,err);
      }
    }
    if (!had_err)
    {
      had_err = gt_parse_score_value(__LINE__,&gap_open,
                                     gt_str_array_get(arguments->affinecosts,
                                                      wordindex++),
                                     false,err);
    }
    if (!had_err)
    {
      had_err = gt_parse_score_value(__LINE__,&gap_extension,
                                     gt_str_array_get(arguments->affinecosts,
                                                      wordindex),
                                     false,err);
    }
  }
  if (!had_err)
  {
    scorehandler = gt_scorehandler_new(matchscore, mismatchscore,
                                       gap_open, gap_extension);
    if (scorematrix != NULL)
    {
      gt_scorehandler_add_scorematrix(scorehandler,scorematrix);
    }
  }
  return scorehandler;
}