CloneSet275


Previous CloneSetNext CloneSetBack to Main Report
Clone
Mass
Clones in
CloneSet
Parameter
Count
Clone
Similarity
Syntax Category
[Sequence Length]
9240.967block
Clone AbstractionParameter Bindings
Clone Instance
(Click to see clone)
Line CountSource Line
Source File
19417
Bio/pairwise2.py
26426
Bio/pairwise2.py
Clone Instance
1
Line Count
9
Source Line
417
Source File
Bio/pairwise2.py

        # Align the first residue in sequenceB to the ith residue in
        # sequence A.  This is like opening up i gaps at the beginning
        # of sequence B.
        score = match_fn(sequenceA[i],sequenceB[0]) 
        if penalize_end_gaps: 
             score+=calc_affine_penalty(i,open_B,extend_B,penalize_extend_when_opening) 

        score_matrix[i][0] = score 


Clone Instance
2
Line Count
6
Source Line
426
Source File
Bio/pairwise2.py

        score = match_fn(sequenceA[0],sequenceB[i]) 
        if penalize_end_gaps: 
             score+=calc_affine_penalty(i,open_A,extend_A,penalize_extend_when_opening) 

        score_matrix[0][i] = score 


        # In the generic algorithm, at each row and column in the score
        # matrix, we had to scan all previous rows and columns to see
        # whether opening a gap might yield a higher score.  Here, since
        # we know the penalties are affine, we can cache just the best
        # score in the previous rows and columns.  Instead of scanning
        # through all the previous rows and cols, we can just look at the
        # cache for the best one.  Whenever the row or col increments, the
        # best cached score just decreases by extending the gap longer.

        # The best score and indexes for each row (goes down all columns).
        # I don't need to store the last row because it's the end of the
        # sequence.


Clone AbstractionParameter Count: 4Parameter Bindings

  # Align the first residue in sequenceB to the ith residue in
  # sequence A.  This is like opening up i gaps at the beginning
  # of sequence B.
  score = match_fn(sequenceA[ [[#variable30a82a60]]],sequenceB[ [[#variable30a829e0]]]) 
  if penalize_end_gaps:
  
    score+=calc_affine_penalty(i, [[#variable30a82960]], [[#variable30a82900]],penalize_extend_when_opening) 
  score_matrix[ [[#variable30a82a60]]][ [[#variable30a829e0]]] = score 
  # In the generic algorithm, at each row and column in the score
  # matrix, we had to scan all previous rows and columns to see
  # whether opening a gap might yield a higher score.  Here, since
  # we know the penalties are affine, we can cache just the best
  # score in the previous rows and columns.  Instead of scanning
  # through all the previous rows and cols, we can just look at the
  # cache for the best one.  Whenever the row or col increments, the
  # best cached score just decreases by extending the gap longer.
  # The best score and indexes for each row (goes down all columns).
  # I don't need to store the last row because it's the end of the
  # sequence.
 

CloneAbstraction
Parameter Bindings
Parameter
Index
Clone
Instance
Parameter
Name
Value
11[[#30a82a60]]
i 
12[[#30a82a60]]
0 
21[[#30a829e0]]
0 
22[[#30a829e0]]
i 
31[[#30a82960]]
open_B 
32[[#30a82960]]
open_A 
41[[#30a82900]]
extend_B 
42[[#30a82900]]
extend_A